Observation / Retained result
Observation Retained result
Required effect Repeating key-A with the same payload leaves one reservation for that key.
Baseline retry Returns integer ID 2; reservations for the key have IDs 2 and 3.
Corrected retry Returns integer ID 2; only reservation 2 exists for the key.
Decision boundary Corrected selected checks pass. Human intent validation is unperformed; Change acceptance is not assessed.

This exhibit selects the target rows for readability. The actual oracle checks all declared reservation and ledger columns, including the unrelated seed rows. The loss seam is a local adapter, with no network transport.

Inspect the retained observations

01 / The change and its authority

What does applying AI4SDLC guidance mean for one change?

A one-change assurance record connects a proposed change to the evidence and decisions needed to assess it. It can live in an issue, repository document or controlled review system. This worksheet is an engineering application of the guidance, not an exact AI4SDLC-mandated artifact or a native Proof import format.

Keep these questions separate:

Question / Record that answers it
Question Record that answers it
Does this express the stakeholder's intended behavior? Versioned source, resolved contradictions and an actual human validation record.
What result should the implementation produce? Requirement-derived expectations with their rationale, inputs, state and observation boundary.
What actually happened? Identifiable implementation calls, raw outcomes, effects and execution metadata.
Is this evidence sufficient for the requested decision? Review findings, remaining obligations and a decision by the designated authority.

Use the record when AI assists with a requirement draft, test, implementation or evidence summary. Record exactly which contribution occurred. A proposed test is not an executed test; execution is not review; review is not approval. A generated artifact can occupy any of those states independently.

The task here is the handoff for one change. Deriving a particular test oracle, assessing an entire requirements set and organizing an agent's wider workflow are related tasks with their own scope.

The plays address their stated organizational context. Your program still owns applicable governance, IV&V, accreditation and authorizing officials. The Testing play excludes autonomous acceptance and does not replace required procedures. A guidance page's GA status describes content maturity; it does not grant project, model, environment or release authorization. Testing scope · Guidance lifecycle

02 / Start with the record

Free one-change assurance worksheet

Copy the entire block. Complete it from actual artifacts and observations; use UNKNOWN, UNASSIGNED or UNPERFORMED where appropriate. A role name becomes accountable only when an actual person or owning queue accepts it.

Before execution, identify the candidate, establish a writable contained environment, review the oracle and capture path, and resolve the permissions required for the intended tools and data. Completing this form does not perform those activities.

ONE-CHANGE ASSURANCE RECORD: BLANK

IDENTITY AND DECISION
Change ID; record revision; record owner:
Requested decision and exact scope:
Stakeholder need and consequence of getting it wrong:
Source request: location, exact revision/digest, relevant passage:
Related interface/policy sources and exact revisions:
Contradictions; assumptions; missing decisions; owner for each:
Preserved behavior; intentional changes; excluded behavior and reason:

GUIDANCE AND APPLICABILITY
For each guidance source:
  URL/title:
  Edition or visible status/update; retrieval or retained-copy identity:
  Read extent; unread linked material:
  Applicable recommendations and reason; project adoption decision:
Governing project policy/revision; assurance or independence obligations:
Actual project/tool/model/environment authorization and evidence:
Data scope and permitted handling; execution containment:
Do not infer project authorization from guidance maturity.

INTENT VALIDATION AND REQUIREMENT
Requirement ID/revision and exact statement:
Source-to-requirement interpretation and justification:
Actual human validator/name/role; required authority:
Validation method, reviewed source/revision, findings and disposition:
Validation status/date/evidence, or UNPERFORMED:
Requirement approval: actual approver/policy/revision/evidence, or UNKNOWN:
Input domain, interface and caller preconditions:
Key scope/equality/normalization; payload types/equality:
Time source/units/window/boundary/retention/cleanup policy:
Known policy gaps and their decision impact:
Independent expected responses, exceptions and required effects:
Oracle source/revision; why independent of implementation behavior:
Oracle reviewer and review result, or UNPERFORMED:

AUTHORSHIP AND ARTIFACT STATES
For each draft, requirement, code change, test, adapter, oracle and summary:
  Artifact/revision/digest:
  Actual author; tool/version; model/version if used, or UNKNOWN/NONE:
  Prompt/context/source revisions; retained output and subsequent edits:
  Authoring environment; authorization basis:
  Proposed status:
  Generated status and actual provenance:
  Executed status/run identity:
  Reviewed status/reviewer/scope:
  Approved status/authority/policy:
Do not invent model involvement, human signatures or completed reviews.

IMPLEMENTATION AND EXECUTION BASIS
Baseline revision/file/function/build identity:
Correction revision/file/function/build identity:
Harness/oracle/adapter/input/procedure identities:
Runtime/OS/dependencies/storage versions and actual settings:
Schema/seed/full relevant columns; external effects and exclusions:
Actual service entry; caller; path from harness to implementation:
Response capture point; loss/fault seam; what the caller receives:
State/effect capture point; connection/transaction/completion semantics:
Evidence that the intended code and selected cases were reached:
Prerequisites; working directory; exact commands and flags:
Fresh output location; original capture location and digests:
Run start/end; child/wrapper exits and their meaning:
Execution errors, invalid observations, skips and missing work:

EXPECTED VERSUS OBSERVED
For every case, including positive, repeat, conflict and controls:
  Case ID; requirement revision; exact input and starting state:
  Expected handler result, with literal types/values:
  Expected caller receipt/response/exception, separately:
  Expected full relevant state/effects, with columns and ordering:
  Actual handler result:
  Actual caller receipt/response/exception:
  Actual full relevant state/effects:
  Assertion/comparison rule; result; evidence location:
  What the result supports and what it leaves unresolved:
Failure witness and diagnosis:
Implemented correction; same-witness replay; regression/control results:
Check sensitivity or deliberately inadequate check, with provenance:
Counts with separate units:
  Logical attempts; actual entries; normal returns; withheld results;
  received replies; state observations; assertions/pass/fail:
Do not relabel these counts as requirements, users or coverage.

REVIEW, GAPS AND DECISIONS
Independent evidence review:
  Actual reviewer/independence arrangement; reviewed artifacts/revisions;
  findings, disposition, date and evidence, or UNPERFORMED:
Intended-behavior validation: separate status and actual human record:
Requirement approval: separate status and authority:
Change acceptance: NOT ASSESSED / ACCEPT / REJECT / HOLD:
  Actual authority; policy; acceptance criteria; evidence; conditions:
Native workflow actions actually performed, if any:
Merge authorization/status:
Deployment authorization/status:
Release authorization/status:
Article/artifact review does not substitute for product validation.

For each unresolved concurrency/replica/retention-boundary/clock/
transport/storage/input/external-effect/authority obligation:
  Scope; required observation or decision; status:
  Actual owner/person or queue, or UNASSIGNED:
  Proposed responsible role if still unassigned:
  Impact on the requested decision; dependency and next action:
  Exception/amendment authority, rationale, expiry, if actually granted:

CURRENCY AND NEXT ACTIONS
Evidence basis still matches? Assessment and authorized reuse, if any:
Revisit on changes to source intent, requirement, key/payload/time rules,
schema/storage, implementation, adapter/harness/oracle/inputs, runtime,
tool/model/prompt/context/environment or authorization/acceptance policy.
For each trigger: affected evidence, revalidation/rerun owner and action:
Next action; actual assignee/queue; due point; blocking dependency:
Evidence retention/access location and responsible owner:
Initial execution: NOT RUN. Initial acceptance: NOT ASSESSED.

Use the filled record to check what belongs in each field.

03 / Evidence inside the record

A retry returns the original ID and still writes a duplicate

The previous illustration used interface agreement v3, SW-REQ-241 revision 2, R17 and a 24-hour promise. Its identifiers and result table were explicitly invented. They are not historical customer observations or Proof execution, and the new fixture does not authenticate them.

The new teaching change, TEACHING-RETRY-01, has its own contract, inputs and literal oracle, fixed before the primary campaign. Its intended benefit is repeatable reservation creation after a completed result is withheld. No actual stakeholder has validated that teaching intent.

Declare the local contract before interpreting the result

The entrypoints are baseline_reserve(path,key,payload,now_hours) and corrected_reserve(path,key,payload,now_hours). One sequential caller uses call_adapter(handler,path,key,payload,now_hours,withhold=False) with a fresh SQLite file for each variant.

Keys are raw nonempty ASCII strings compared exactly. Payloads have exactly sku as a string and quantity as a positive exact integer, excluding Boolean values. These are caller preconditions, not an exercised input validator.

The authored replay domain is 0 <= elapsed < 24 under a stable monotonic supplied integer clock. Only supplied values 0, 1 and 2 run. There is no real waiting, expiry implementation, boundary-at-24 test or full-window evidence. The operation key is a local argument; no HTTP method, endpoint or Idempotency-Key protocol is established.

Attempt / Input / Independent expected behavior
Attempt Input Independent expected behavior
First, result withheld key-A, {"sku":"part-A","quantity":1}, supplied hour 0 Commit reservation 2 and its ledger entry. Handler returns {"kind":"reserved","reservation_id":2}. Adapter withholds it; caller receives no response.
Repeat Same key/payload, hour 1 Return the original integer ID 2 without another reservation or ledger write.
Conflict key-A, quantity 2, hour 2 Return {"kind":"conflict","code":"KEY_PAYLOAD_MISMATCH","reservation_id":null} without another write.
Useful new work key-B, original payload, hour 2 Create a new reservation and ledger entry; this fresh seeded fixture expects integer ID 3.

The initial database contains unrelated reservation 1 and its ledger entry. ID 3 is an exact expectation for this seed and allocator history, not a general business requirement for consecutive identifiers.

Observe completion and receipt separately

The actual adapter calls the selected handler. On the first attempt, the handler commits and returns reservation 2. The adapter then discards that completed result and raises ResponseLost. The harness independently retains the handler return and records the caller outcome:

{"received":false,"response":null,"exception_type":"ResponseLost"}

Here response:null means no received product response. It is not a normal null response from the service. Likewise, the profiler's return=None on adapter exception unwind is not a normal caller reply. This seam exercises deliberate local withholding, not a socket failure or transport outage.

After setup and every attempt, a new observer connection reads every declared column in reservations and ledger, in defined order. These observations establish committed state at those points. They do not demonstrate process-restart, power-loss, fsync or storage-failure behavior. Internal sqlite_sequence is outside the application-state oracle.

Compare the independent expectation with the actual effects

Observation / Baseline / Corrected
Observation Baseline Corrected
First withheld attempt Handler returns 2; caller receives nothing; reservation 2 persists. Same expected outcome.
Same-payload repeat Caller receives 2, but another key-A reservation, ID 3, persists. Caller receives 2; no extra row.
Changed-payload conflict Exact conflict response; no new write. The earlier duplicate remains. Exact conflict response; state remains correct.
Distinct key Creates and returns 4 because the duplicate already consumed 3. Creates and returns the expected 3.

The baseline's full-state check after conflict fails because it still contains the earlier duplicate. That is not evidence of a new conflict-side write: the before/after relation and SQL trace show unchanged state during conflict.

The deliberately authored response-only fragment checks the received response kinds and the retry's original ID. It passes the baseline. The full gate compares exact typed handler and caller outcomes, complete ordered application state, selected entry counts and the conflict's before/after state relation. Both gates assess the same observations, with no extra service calls.

Variant / Weak response-only gate / Full gate / Child exit
Variant Weak response-only gate Full gate Child exit
Seeded faulty baseline PASS, 2/2 checks FAIL, 11/16 checks pass; 5 fail 1
Implemented correction PASS, 2/2 checks PASS, 16/16 checks 0

Inspect the complete result · Compare the literal oracle · Download the runnable evidence kit

The implemented correction removes the replay write

Both variants already look up the ledger and reject a different payload before writing. The seeded baseline deliberately inserts an extra reservation on a matching replay. The correction disables that branch and returns the existing ID without creating another row. These are the actual exported functions:

def baseline_reserve(path,key,payload,now_hours):
    return _reserve(path,key,payload,now_hours,True)

def corrected_reserve(path,key,payload,now_hours):
    return _reserve(path,key,payload,now_hours,False)

The last argument controls duplicate_before_replay in the shared implementation. Both variants already group a genuinely new reservation and ledger entry under BEGIN IMMEDIATE and COMMIT. This correction did not introduce those transactions.

The corrected sequence ran against its own fresh database. It did not migrate or clean the baseline's duplicates. Its conflict and new-key cases retain both rejection behavior and useful work; the result cannot be achieved simply by refusing every call.

To reproduce, extract the kit, use CPython 3.12+ with standard-library sqlite3 and a writable local directory, and choose a new output directory:

python3 -B reproduce.py --output replay-output

No Proof installation, solver, pip package, network, account or credential is required. Wrapper exit 0 means the expected contrast reproduced: baseline child 1 and corrected child 0. It does not accept the baseline or authorize a change. Preserve a new replay separately from the retained primary capture.

Complete filled one-change record

ONE-CHANGE ASSURANCE RECORD: FILLED

IDENTITY AND INTENT
Change: TEACHING-RETRY-01.
Record basis: frozen CONTRACT.md, assurance-record.json and derived
EVIDENCE-HANDOFF.json; this inline form is not a native Proof schema.
Source intent and candidate requirement revision: CONTRACT.md at the
SHA-256 below. No approved project requirement ID is established.
Recorded decision scope: bounded teaching-evidence assessment.
Product acceptance remains NOT ASSESSED.
Need: a caller can repeat a completed reservation after its result is
withheld, without another reservation; conflict rejects; new keys work.
Authority of that need: newly authored teaching intent.
Original interface agreement v3, SW-REQ-241 revision 2, R17, 24-hour
promise and result table: INVENTED; no historical execution inherited.
No customer request, stakeholder approval or actual AI4SDLC pilot exists
in this evidence. Actual project/intent owner: UNASSIGNED.

GUIDANCE BASIS
Requirements Engineering:
  https://code.mil/AI4SDLC/plays/requirements_engineering_play/
  GA; visible update 2025-12-31; main substantive body read.
Testing:
  https://code.mil/AI4SDLC/plays/testing-play/
  GA; visible update 2025-12-26; executive/scope, sections 3-4,
  5.1/anti-pattern and targeted 6-7 read, not full play/subplays.
Lifecycle:
  https://code.mil/AI4SDLC/lifecycle/
  GA; visible update 2025-09-18; substantive description read.
Application: retain source, actual validation, independent expectations,
execution and separate decisions for one change.
Exact worksheet is an engineering application, not a mandated form.
Project adoption/governing policy: UNKNOWN.
Actual tool/model/environment authorization: UNPERFORMED.
GA guidance approval is not project, tool or release authorization.

REQUIREMENT, DOMAIN AND VALIDATION
Candidate requirement:
  For an admitted same-key/same-payload repeat, return the original
  reservation ID without another reservation or ledger write.
  A changed payload for the key returns the exact conflict outcome and
  makes no additional write. A distinct key creates useful new work.
Time domain: stable monotonic supplied integer now_hours;
  0 <= elapsed < 24. Selected schedule: 0, 1, 2, 2.
No real waiting, expiry/cleanup implementation, full-window evidence,
at/after-24 policy, clock rollback or time-validation experiment.
Keys: exact nonempty raw ASCII strings, with no normalization.
Payload: exactly {sku:string, quantity:positive exact int}; bool excluded.
These are caller preconditions, not an executed input validator.
Execution scope: one sequential caller/writer; fresh file SQLite per variant.
No HTTP header/method/endpoint, real transport outage, stock service,
replica or concurrent execution.
Human intent validator: UNASSIGNED.
Human validation/requirement approval: UNPERFORMED; no signature/date.
Contradictions/assumptions: teaching scope has no customer authority;
  broad retention and deployment claims remain unresolved.
Independent oracle: literal expected.json fixed before execution,
  justified by the authored contract, not inferred from handler output.
Human validation of the contract/oracle's suitability: UNPERFORMED.

ACTUAL AUTHORSHIP AND STATES
Requirement draft/contract, implementation, inputs, oracle, harness and
weak fragment: author-created teaching artifacts.
Individual teaching-author identity and authoring tool: not recorded.
Authoring environment for contract, code, tests and oracle: UNKNOWN.
The primary environment below describes execution only.
Named model/version/prompt for candidate generation: none retained or
claimed. The generated-style weak fragment is not actual AI output.
Execution tools: CPython, stdlib sqlite3, subprocess, sys.setprofile,
SQLite trace callback and fresh-connection state reader.
Proposed: broader verification and authority actions remain open.
Generated: runtime observations/reports produced by the Python harness;
  no model-generated candidate code/test artifact is claimed.
Executed: one primary campaign with baseline and corrected variants.
Reviewed: execution review material retained in EXECUTION-REVIEW.json;
  project-appointed review status: NOT RECORDED.
Approved: no actual product-intent/project/model/environment approval.
Article/evidence review does not supply product validation or acceptance.

CONTENT IDENTITIES: SHA-256
CONTRACT.md:
  e63e14c14048c101a59c17468720cb3ff2b182829895ad4111508b45449ff3fa
assurance-record.json:
  d4f92160d1f29b870f7a113d07167d8182e75fafedf6fefe22228d2e963e3c6e
reservation.py (baseline, correction, shared handler and adapter):
  8b8a68f509af1aa915cdabcc4005935428dd875233b93904e1f5f2df818406ed
run.py (harness, typed comparator, observer and weak fragment):
  0362eecd468612a7cc95001dc5d2d52f3d5c5e5a0455ac868c12f44fc22c14ee
reproduce.py (campaign wrapper):
  ce04ad2cf1ba7cac1e54ddc6e9e1cc65fd6330c2ecd7b7570b7abaff050c8248
inputs.json:
  797273919f70a8e359ed9c1ba9b776d719d545c147022c4c9273b4d9577bfe4b
expected.json:
  31e1ae73c5f2632322eda6ab551e68e54af258937cfa59d32c4849a3659650a4
All seven files remained unchanged through the primary campaign.

CALL PATH AND CAPTURE
reproduce.py starts run.py once for each variant.
run.py calls call_adapter(handler,path,key,payload,now_hours,withhold).
Actual handlers:
  baseline_reserve(path,key,payload,now_hours)
  corrected_reserve(path,key,payload,now_hours)
They call _reserve with duplicate_before_replay=True/False respectively.
Profiles bind source/function identities to actual arguments and returns.
On first-withheld:
  handler commits and returns {"kind":"reserved","reservation_id":2};
  adapter discards it and raises ResponseLost;
  caller receives no response.
Exception message: test adapter withheld the completed handler result
Profiler adapter return=None during unwind is not a normal product reply.
After setup and every attempt, a NEW observer connection reads both
complete declared tables. Profiles do not establish branch coverage.

PRIMARY ENVIRONMENT AND COMMAND
CPython 3.14.7; SQLite 3.53.4;
platform macOS-26.5-arm64-arm-64bit-Mach-O; __debug__=true.
Connection: isolation_level=None;
autocommit=LEGACY_TRANSACTION_CONTROL(-1);
journal_mode=delete; synchronous=2 (FULL);
in_transaction=false at captured connection return.
Explicit BEGIN IMMEDIATE/COMMIT; finally rolls back an open transaction.
No injected storage-error, process-restart or power-loss campaign.

Recorded cwd:
/Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/11-ai4sdlc-requirements-and-testing/research/fixture

Recorded argv, in order:
[
  "/opt/homebrew/opt/python@3.14/bin/python3.14",
  "/Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/11-ai4sdlc-requirements-and-testing/research/fixture/reproduce.py",
  "--output",
  "/Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/11-ai4sdlc-requirements-and-testing/research/captured/primary"
]
Primary interval UTC:
  2026-10-29T00:53:44.885441+00:00
  to 2026-10-29T00:53:45.057822+00:00
Child exits: baseline=1; corrected=0. Wrapper exit=0.
Wrapper zero means the expected failed-baseline/corrected-pass contrast.

PORTABLE REPLAY AND RETAINED ARTIFACTS
ZIP:
https://reqproof.com/assets/ai4sdlc-requirements-and-testing/ai4sdlc-requirements-and-testing-evidence-kit.zip
ZIP SHA-256:
  6d50f00c9250697d0823c7ab3f8cf1f88613707703aeffc760dc520a79927dd0
ZIP: 28 regular members; 39,021 bytes.
Prerequisites: extracted kit; CPython 3.12+ with stdlib sqlite3;
  writable local directory; NEW output directory.
Run from extracted kit:
  python3 -B reproduce.py --output replay-output
No Proof, solver, pip, network, account or credential required.
Keep this new replay separate from captured/primary.
Public member base URL:
https://reqproof.com/assets/ai4sdlc-requirements-and-testing/research-rerun/
Append these exact member paths to that base:
  captured/primary-command.json
  captured/primary/summary.json
  captured/primary/baseline/observations.json
  captured/primary/baseline/profile.jsonl
  captured/primary/baseline/report.json
  captured/primary/corrected/observations.json
  captured/primary/corrected/profile.jsonl
  captured/primary/corrected/report.json
  EVIDENCE-HANDOFF.json
  EXECUTION-REVIEW.json
  PROVENANCE.json
  MANIFEST.json
  SHA256SUMS
Primary summary SHA-256:
  75166c9cf374a0aead3561a58cf14c0b0b1724a50973a44d46fa9f2f29d4f14e
Derived handoff SHA-256:
  7ac45530a25daeec5443939479f60584c8a747b4d7605c38d5fc089ecb102fc6
Original binary databases: retained internally, not public downloads.
Public text states reconstruct fresh databases.
Separate extracted replay: CPython 3.12.14 / SQLite 3.53.1;
  review provenance only, not primary evidence or a runtime matrix.

EXACT INPUTS
first-withheld: key="key-A", payload={"sku":"part-A","quantity":1},
  now_hours=0, withhold=true
retry: key="key-A", payload={"sku":"part-A","quantity":1},
  now_hours=1, withhold=false
conflict: key="key-A", payload={"sku":"part-A","quantity":2},
  now_hours=2, withhold=false
new-key: key="key-B", payload={"sku":"part-A","quantity":1},
  now_hours=2, withhold=false

LITERAL OUTCOMES
These aliases are fully defined here; numeric values are exact integers.
R2 = {"kind":"reserved","reservation_id":2}
R3 = {"kind":"reserved","reservation_id":3}
R4 = {"kind":"reserved","reservation_id":4}
C = {"kind":"conflict","code":"KEY_PAYLOAD_MISMATCH","reservation_id":null}
L = {"received":false,"response":null,"exception_type":"ResponseLost"}
P2 = {"received":true,"response":{"kind":"reserved","reservation_id":2},"exception_type":null}
P3 = {"received":true,"response":{"kind":"reserved","reservation_id":3},"exception_type":null}
P4 = {"received":true,"response":{"kind":"reserved","reservation_id":4},"exception_type":null}
PC = {"received":true,"response":{"kind":"conflict","code":"KEY_PAYLOAD_MISMATCH","reservation_id":null},"exception_type":null}

phase           expected handler/caller   baseline actual   corrected actual
first-withheld  R2 / L                    R2 / L            R2 / L
retry           R2 / P2                   R2 / P2           R2 / P2
conflict        C / PC                    C / PC            C / PC
new-key         R3 / P3                   R4 / P4           R3 / P3

COMPLETE DECLARED APPLICATION STATES
reservations columns:
  [reservation_id,reservation_key,sku,quantity], ORDER BY reservation_id
ledger columns:
  [reservation_key,payload_json,reservation_id,created_at_hours],
  ORDER BY reservation_key
payload_json is a STRING containing JSON, not a nested object.
The unrelated seed row is included. sqlite_sequence is excluded.

S0 = {
  "reservations":[[1,"seed-key","seed",1]],
  "ledger":[["seed-key","{\"quantity\":1,\"sku\":\"seed\"}",1,0]]
}
S1 = {
  "reservations":[[1,"seed-key","seed",1],[2,"key-A","part-A",1]],
  "ledger":[
    ["key-A","{\"quantity\":1,\"sku\":\"part-A\"}",2,0],
    ["seed-key","{\"quantity\":1,\"sku\":\"seed\"}",1,0]
  ]
}
S2 = {
  "reservations":[
    [1,"seed-key","seed",1],[2,"key-A","part-A",1],[3,"key-B","part-A",1]
  ],
  "ledger":[
    ["key-A","{\"quantity\":1,\"sku\":\"part-A\"}",2,0],
    ["key-B","{\"quantity\":1,\"sku\":\"part-A\"}",3,2],
    ["seed-key","{\"quantity\":1,\"sku\":\"seed\"}",1,0]
  ]
}
B1 = {
  "reservations":[
    [1,"seed-key","seed",1],[2,"key-A","part-A",1],[3,"key-A","part-A",1]
  ],
  "ledger":[
    ["key-A","{\"quantity\":1,\"sku\":\"part-A\"}",2,0],
    ["seed-key","{\"quantity\":1,\"sku\":\"seed\"}",1,0]
  ]
}
B2 = {
  "reservations":[
    [1,"seed-key","seed",1],[2,"key-A","part-A",1],
    [3,"key-A","part-A",1],[4,"key-B","part-A",1]
  ],
  "ledger":[
    ["key-A","{\"quantity\":1,\"sku\":\"part-A\"}",2,0],
    ["key-B","{\"quantity\":1,\"sku\":\"part-A\"}",4,2],
    ["seed-key","{\"quantity\":1,\"sku\":\"seed\"}",1,0]
  ]
}

observation     expected   baseline actual   corrected actual
setup           S0         S0                S0
first-withheld  S1         S1                S1
retry           S1         B1                S1
conflict        S1         B1                S1
new-key         S2         B2                S2

FAILURE, CORRECTION AND CONTROLS
Failure: baseline repeat commits reservation 3 for key-A while returning 2.
Correction: corrected_reserve disables the deliberate replay insert and
returns the existing ID before another row is created.
Both variants already use transactions for new reservation+ledger writes.
Correction replay uses a separate fresh DB; no duplicate cleanup/migration.
Conflict: B1 remains B1; S1 remains S1. No conflict-side write.
New key: useful creation retained; baseline ID4 follows prior duplication;
  corrected ID3 follows this seed, not a universal ID-order promise.
Weak authored fragment checks received kinds ["reserved","conflict","reserved"]
and exact integer retry ID2; it uses the SAME observations, no extra calls.
Whole comparisons require matching types, dictionary keys, list lengths,
ordering and values. No coercion of true into integer 1.

Baseline weak: PASS 2/2. Full: 11/16 pass, 5 fail.
Corrected weak: PASS 2/2. Full: PASS 16/16.
Baseline failed checks:
  state:retry; state:conflict; state:new-key;
  handler:new-key; caller:new-key.
state:conflict fails from carried-forward retry damage.

Full gate per variant:
  5 complete state checks;
  4 complete handler-outcome checks;
  4 complete caller-outcome checks;
  1 handler-entry count; 1 adapter-entry count;
  1 actual conflict before/after state relation.
Total: 16 checks per variant, 32 across variants, 5 baseline failures.
Other totals:
  8 logical attempts;
  8 handler + 8 adapter entries = 16 selected public entries;
  8 normal handler returns;
  2 withheld completed results; 6 received caller replies;
  10 fresh-connection complete declared-state observations.
Internal helper events are a separate census.
No requirements-coverage, all-input or all-branch percentage is claimed.

OPEN OBLIGATIONS AND ACCOUNTABILITY
All actual owners below are UNASSIGNED. Roles name assignments to obtain,
not people who have already accepted responsibility.
- Intent and project/model/environment authority:
  status UNPERFORMED; proposed role project/intent owner;
  validate actual need and permission basis before product acceptance.
- Full retention window, at/after 24, cleanup, over-retention and clock:
  status OPEN; proposed role requirement/retention owner;
  settle policy and obtain boundary/full-scope evidence before closing it.
- Concurrency and replicas:
  status NOT RUN; proposed role service/integration owner;
  agree competing-call behavior and test actual topology before that claim.
- Real transport, caller recovery and protocol:
  status NOT RUN; proposed role interface/integration owner;
  local withholding cannot establish production transport behavior.
- Storage errors, restart/power loss and external stock effects:
  status NOT RUN; proposed role storage/service owner;
  select relevant failure/effect checks before relying on those guarantees.
- Input, key or payload semantics and time validation:
  status NOT RUN; proposed role interface owner;
  establish/enforce boundaries before widening caller preconditions.
- Existing duplicated data or storage migration:
  status NOT RUN; proposed role data owner;
  define reconciliation before claiming an upgrade repairs old state.
No scope amendment, waiver or exception has been authorized.

SEPARATE DECISIONS
Evidence-review material: EXECUTION-REVIEW.json, retained raw captures
  and the separately identified extracted replay.
Project-appointed independent reviewer/independence arrangement:
  NOT RECORDED. Project evidence-review decision: NOT ASSESSED.
The execution review file is not a signed human validation or IV&V record.
Intended-behavior validation: UNPERFORMED; human validator UNASSIGNED.
Requirement approval: UNPERFORMED.
Local evidence criterion: corrected selected typed checks pass;
  broader product acceptance criteria and policy remain UNKNOWN.
Native Proof workflow: NOT RUN.
Change acceptance: NOT ASSESSED; authority UNASSIGNED.
Merge: NOT ASSESSED.
Deployment: NOT ASSESSED.
Release: NOT ASSESSED.
No automatic promotion from generated, executed or reviewed to approved.

STALE TRIGGERS AND NEXT ACTIONS
Revisit on changes to guidance/adoption policy, source request/requirement,
key equality/payload semantics, time/retention, schema/storage, source code,
adapter/loss point, harness/oracle/inputs, runtime/tool/model/prompt/context,
environment, reviewers or acceptance authority.
Intent/policy changes need the actual owner's revalidation.
Implementation/evidence changes need impact assessment and affected reruns.
Current evidence remains bound to the listed frozen basis; no unqualified
freshness or reuse approval is recorded.
Next: assign the actual intent/decision owner and validate intended scope.
Then assign each open obligation and its required evidence before the
corresponding product claim or acceptance decision.
Actual assignees/due dates: UNASSIGNED; no invented commitments.
Retain immutable primary files; store each replay under a new identity.
Project evidence-retention owner/policy: UNASSIGNED/UNKNOWN.

Follow the change record in six steps

Download the complete video transcript.

Read the complete video transcript

Start with one change and the decision it needs. Keep the source request, requirement revision, actual authorship, evidence and open questions together. Identify the person who can validate intent and the authority who can accept the change. In this teaching record, those real owners remain unassigned and human validation is unperformed.

The teaching contract and literal expected results were fixed before execution. A repeated key with the same payload must preserve the original reservation. A changed payload must conflict, while a distinct key must create useful work. The selected clock values are supplied inputs, so these checks do not establish a full retention window.

On the first attempt, the local handler commits a reservation and returns its identifier. The adapter then deliberately discards that completed result and raises a response-loss exception. The harness retains the handler return, but the caller receives no response. This is a local withholding seam, not an observed network outage.

The baseline retry returns the original identifier but commits an extra reservation. Its two response-only checks still pass. The full gate finds five failed checks because it retains exact outcomes and committed state. The later conflict makes no additional write; its state mismatch carries forward the duplicate already created by the retry.

The correction removes the extra write from the replay path. In its fresh database, the repeat preserves the original reservation, the conflict leaves state unchanged, and a distinct key creates a new reservation. All sixteen selected full checks pass. This execution does not clean duplicates from an existing database or test concurrent callers.

Carry the passing observations and the remaining work into the assurance record. Human intent validation, project authorization and broader retention, transport and storage checks remain open. Evidence review does not approve the product promise. Assign accountable owners, renew affected evidence when its basis changes, and record acceptance separately from merge, deployment and release.

Read the text walkthrough

1. Frame one change

Start with one change and the decision it needs. Keep the source request, requirement revision, actual authorship, evidence and open questions together. Identify the person who can validate intent and the authority who can accept the change. In this teaching record, those real owners remain unassigned and human validation is unperformed.

2. Fix the expected behavior

The teaching contract and literal expected results were fixed before execution. A repeated key with the same payload must preserve the original reservation. A changed payload must conflict, while a distinct key must create useful work. The selected clock values are supplied inputs, so these checks do not establish a full retention window.

3. Separate completion from receipt

On the first attempt, the local handler commits a reservation and returns its identifier. The adapter then deliberately discards that completed result and raises a response-loss exception. The harness retains the handler return, but the caller receives no response. This is a local withholding seam, not an observed network outage.

4. Inspect the extra effect

The baseline retry returns the original identifier but commits an extra reservation. Its two response-only checks still pass. The full gate finds five failed checks because it retains exact outcomes and committed state. The later conflict makes no additional write; its state mismatch carries forward the duplicate already created by the retry.

5. Follow the implemented correction

The correction removes the extra write from the replay path. In its fresh database, the repeat preserves the original reservation, the conflict leaves state unchanged, and a distinct key creates a new reservation. All sixteen selected full checks pass. This execution does not clean duplicates from an existing database or test concurrent callers.

6. Keep the decision open

Carry the passing observations and the remaining work into the assurance record. Human intent validation, project authorization and broader retention, transport and storage checks remain open. Evidence review does not approve the product promise. Assign accountable owners, renew affected evidence when its basis changes, and record acceptance separately from merge, deployment and release.

04 / The working method

How to build a reviewable record for your change

  1. Recover the authoritative intent. Pin the request and related interface or policy revisions. Ask the actual stakeholder or delegated human validator to resolve conflicting meanings. Record the reviewed text and disposition; until then, keep the requirement a candidate.

  2. Define the decision and its evidence. State the behavior, input domain, relevant effects and completion boundary. Derive expected observations before using implementation output as an answer. Record why each selected case challenges the promise and which wider obligations remain.

  3. Preserve actual contribution provenance. For each draft, code change and test, identify the author and tools actually used. If AI contributed, retain the model/version, relevant context, prompt/output and human edits under the applicable handling policy. Do not fill missing provenance with a plausible model name.

  4. Review the path that will run. Check the real entrypoint, adapter, dependencies, state initialization and observation code. Make loss injection and caller receipt explicit. Include a useful positive operation and a negative or sensitivity check that can expose a misleading pass.

  5. Execute and retain the contradiction. Run at identifiable revisions. Preserve commands, settings, raw results, failures and incomplete work. After a correction, replay the witness and affected controls. Keep the original failed evidence and label the new run with its own identity.

  6. Obtain separate reviews and decisions. Review evidence adequacy and currency, complete intended-behavior validation, and present unresolved work to the authorized change decision owner. Record acceptance separately from merge, deployment and release. Assign rechecks when the basis changes.

05 / Check the handoff

Before running, reviewing and deciding

  • Intent: The source revision, contradictions and actual human validation status are visible.
  • Expectation: Required responses and effects have an independent basis and literal comparison rules.
  • Provenance: Drafts, code, tests and summaries name their actual authors/tools and separate artifact states.
  • Execution: The intended implementation ran; capture includes caller outcomes and relevant effects.
  • Sensitivity: Positive, conflict, repeat and applicable failure controls do meaningful work.
  • Currency: Evidence matches the reviewed basis, or reuse has an explicit assessment.
  • Open work: Missing, failed, stale and unperformed obligations retain an owner and decision impact.
  • Authority: Requirement approval, evidence review, Change acceptance and release actions have separate records.

06 / Avoid a misleading record

Mistakes that break the link between intent and evidence

Mistake / Consequence / Repair
Mistake Consequence Repair
Treat the newest message as the approved requirement. An informal request silently overrides an existing promise. Record both revisions and obtain the responsible owner's precedence decision.
Supply an assumed model or reviewer identity. The record asserts provenance or authority that never existed. Mark the field unknown and recover the actual record where possible.
Change expected output to match the corrected code. The repair can move the acceptance criterion without authorization. Review any requirement or oracle amendment separately and preserve its prior revision.
Describe a captured service result as a received reply. The record hides where delivery failed. Identify each observer and retain receipt, result and exception separately.
Report a fresh database as an upgrade repair. Existing damaged state has no demonstrated recovery path. Plan and execute a separate migration or reconciliation check where required.
Treat an evidence-review pass as stakeholder agreement. Technical consistency substitutes for deciding whether the behavior is wanted. Keep the validator, authority and validation artifact explicit.
Delete an obligation because it is difficult to execute. The acceptance basis becomes narrower without an accountable decision. Retain the gap or obtain an authorized scope amendment or exception.

07 / Connect intent, checks and decisions

How Proof can support this change record

Proof's requirements, implementation links, test evidence, configured checks and Change decisions can keep the record connected. Use them to preserve the reason a check exists and the basis for a decision. The teaching fixture contains no native Proof execution, and its worksheet is not a native import schema. The capability statements below come from the implementation basis.

Reader action / Supported workflow / Boundary to inspect
Reader action Supported workflow Boundary to inspect
Connect the reviewed requirement to implementation and checks. Requirement implementation links and supported Verifies test annotations connect records. A path or annotation does not establish execution or a meaningful assertion.
Attach results from the real test run. proof test link consumes a supported existing report and linked tests, persisting derived state unless dry-run. It does not run tests or judge the oracle. The teaching JSON is not claimed to be an accepted report format.
Plan affected checks. proof test affected plans by default; execution is conditional on --run and selected commands. An empty plan or successful planning command is not an executed campaign.
Assess the evidence supporting the change. Configured evidence and grounding checks examine declared obligations and witnesses. Completeness is scoped; grounding may use static references or runtime evidence. Inspect the actual result and mode.
Record the change decision. Effective Change acceptance requires a current package, authenticated sufficient authority, approved policy and acceptable readiness. An external auditor's assessment is advisory. Acceptance does not itself execute merge, deployment or release.

Two qualifications matter before relying on a green status. Evidence checks can pass when no evidence cells are declared, and configured exemptions or accepted known-issue debt can affect the result. Static grounding, evidence carriers and generated tests do not establish independently justified expectations or complete behavioral support.

Approval checks enforce recorded policy conditions. A disabled policy can pass, and a configured policy can delegate approval to agents. Review-disposition checks and wording heuristics do not perform human semantic validation or establish unqualified freshness. Retain the actual human validation required by your process rather than inferring it from a check name.

08 / Choose what fits the decision

Which workflow should hold the assurance record?

Choose the lightest arrangement that preserves the required identities, observations and decisions. These are engineering tradeoffs, not a vendor benchmark.

Approach / Choose it when / Evidence basis and remaining work
Approach Choose it when Evidence basis and remaining work
Versioned issue or document One change has a small, known set of contributors and reviewers. Fits the Requirements play's versioned-source discipline. Your team maintains links, status and review history.
Repository record plus existing CI Requirement, harness and implementation revisions need to be reviewed together. The local fixture demonstrates an executable record with retained outputs. CI still needs the correct observations, retention and decision policy.
Approved AI assistance alongside the record Drafting or test suggestions are useful and the project permits the tool/environment. The plays support reviewed assistance. Preserve actual provenance and examine assertions; generated content does not establish acceptance.
Proof project records Several linked requirements, checks or contributors make manual change-impact tracking difficult. The source-supported primitives above connect the work. Execution adequacy, intended meaning and authority still need explicit records.

The Requirements and Testing plays support the cited practices; the choice between arrangements is this guide's application. Before expanding a workflow, take one real change through it and check whether another reviewer can reconstruct the decision from retained evidence.

09 / Evidence behind the guide

Primary sources and reproducibility

Guidance read and applicability

Primary source / Visible edition/status and read extent / Use and limit
Primary source Visible edition/status and read extent Use and limit
AI-Augmented Requirements Engineering GA; updated 2025-12-31. Main substantive body read. Human validation, source traceability and versioned requirements. Does not prescribe this worksheet or approve its teaching contract.
AI-Augmented Testing GA; updated 2025-12-26. Scope, §§3–4, §5.1 and code-driven anti-pattern, plus targeted §§6–7. Requirements-derived tests, assertion review and provenance. The full play and linked subplays were not read; no empirical benefit figures are adopted.
Guidance Lifecycle GA; updated 2025-09-18. Complete substantive description read. Status describes content maturity, not project or release authorization.
Python 3.14 sqlite3 transaction control Targeted transaction-control documentation; displayed version 3.14.10. Explains explicit SQL control with legacy mode and isolation_level=None. Recorded primary runtime remains 3.14.7; documentation is not execution or durability evidence.

No IV&V, accreditation, ATO, compliance assessment or statistical benefit study was performed. Applicable program requirements must be established from the actual governing sources and responsible authorities.

Inspect or reproduce the retained teaching campaign

Runnable ZIP · ZIP checksum · README · Manifest · File checksums

The ZIP contains 28 regular files, 39,021 bytes. Its SHA-256 is:

6d50f00c9250697d0823c7ab3f8cf1f88613707703aeffc760dc520a79927dd0

The kit includes source, contract, literal expectations, input schedule, raw observations, profiles, reports and commands. Provenance records the primary environment and settings; the command capture retains exact arguments, working directory, timestamps and exit. The derived handoff connects the results to the initially unexecuted assurance record.

The primary campaign used CPython 3.14.7, SQLite 3.53.4 and macOS arm64. All seven source/input files remained unchanged through it. A separately identified extracted replay used CPython 3.12.14 and SQLite 3.53.1; it is separate review provenance, not the primary capture or a runtime-matrix claim. No new fixture run is added by this article.

The original binary databases are not included in the public kit. Complete text state observations are included, and the portable command reconstructs fresh databases. Keep replay metadata separate: timestamps, absolute paths, runtimes and database bytes can differ. Compare the declared typed observations and count units against the fixed source and oracle.

Current Proof source basis

The following repository locators identify the implementation behind the workflow claims. Digests are SHA-256 prefixes of the inspected files. This is source inspection, not an executed Proof audit.

Mechanism / Source locator / Digest prefix
Mechanism Source locator Digest prefix
Existing-report linking and affected-test planning cmd/proof/testlink.go 6fb6d53c13f6
Configured requirement approvals pkg/workflow/workflow_approval_checks.go 2379b8ffad03
Acceptance-review disposition heuristic pkg/lint/acceptance_review_current.go a60a8399c2a3
Declared obligation evidence pkg/workflow/workflow_obligation_evidence.go 422640fb0ba0
Static and execution-based witness grounding pkg/workflow/workflow_obligation_witness_grounded.go 8fda2f867100
Effective Change decisions pkg/evidencepkg/change_decision.go a969e3b27c11
Editable audit intake website/demo.html; website/assets/engagement-intake.js 902a9dc2a5f7; 72df4637e1ad

10 / Put the record under pressure

Two more decisions the record should expose

These are proposed, unexecuted examples. They add no calls or results to the teaching campaign.

1. Two source promises disagree about retention

Suppose an interface agreement permits a repeat for 24 hours, but an operations document says to delete every key at midnight. A key created just before midnight could disappear long before the promised interval ends.

Record both exact source revisions and the contradiction. Ask the responsible intent and retention owners to settle the policy, including the time source and boundary. Then derive the corresponding cleanup and replay checks. A model-generated test that selects one interpretation cannot decide which source has authority.

2. A regenerated test uses an old interface revision

Suppose a reviewed requirement changes a quantity from items to packs, but a later AI-generated test uses an older context document. The test can still pass while checking the wrong meaning.

Retain the model's actual input context and generated output, identify the stale source, and require review of the changed expectation. Preserve the old execution as historical evidence; inspect the regenerated test and obtain a new run against the correct basis. If model or environment authorization also changed, that permission question needs its own decision before further use.

11 / Questions at review

AI4SDLC requirements and testing questions, answered

Must the change contain AI-generated code?

No. AI may contribute only a requirement draft, candidate test or summary. Identify the actual contribution. The local fixture here is author-created teaching work with no retained named-model generation experiment; it cannot measure a model's effectiveness.

Can the same author write the code and the tests?

Authorship alone does not settle whether an expectation is justified. Preserve its source and rationale, examine the assertions independently, and apply the separation of responsibilities required by your project. An implementation-independent oracle is not, by itself, a claim of organizational IV&V.

What if nobody can validate the original request?

Keep the interpretation as a candidate, mark the validator unassigned and identify who must resolve that ownership. Bounded experiments can expose consequences, but they cannot create missing stakeholder authority. Do not record an approved product requirement until the applicable validation and approval actually occur.

Why does the downloadable authoring record still say NOT RUN?

It preserves what was true when the input was fixed before execution. The later EVIDENCE-HANDOFF.json points to the actual run. Keeping both prevents a later result from rewriting the original planning history.

How should an exception appear?

Retain the failed or missing obligation and the actual observation. Separately record who authorized the exception, under which policy, for what scope and duration, with what conditions and revisit trigger. An exception changes the permitted decision; it does not turn the evidence into a pass.