Observation / Recorded value
Observation Recorded value
Native check PASS, warning severity, exit 0; one declared cancellation cell.
Cancellation reply {'status': 'cancelled', 'published_bytes': 0}
Target after return b'A'; the independent expectation is b'KEEP'.
Witness comparison Weak status check passes; strong reply-and-file comparison fails.

The native snapshot and the separately executed baseline are connected by an explicit source-byte mapping. The native audit did not run the Python witness. Its structural pass is expected checker behavior.

Inspect the baseline observation · Inspect S1's native row.

01 / Know what the check establishes

What does documented_claim_verified check?

The check runs at the spec stage with warning severity. It becomes applicable when loaded active requirements explicitly declare documented_behaviors. Requirements marked retired, superseded or rejected are excluded. A draft requirement remains eligible; eligibility supplies no approval.

The denominator is the number of eligible declared cells. It is not a count of all documentation sentences, requirement files, witness functions or behavioral calls. An optional cell id gives findings a label such as SYS-REQ-001:cancellation_preserves_target; without it, the label uses the zero-based position, such as SYS-REQ-001:claim[0]. A cell can produce several findings, while issue_count counts affected cells. Checker and requirement model.

Fields and verification modes

Field / Implemented requirement / Interpretation
Field Implemented requirement Interpretation
id Optional. Identifies a cell in findings; use a stable value when maintaining the record.
claim Nonempty after trimming. Presence does not validate the promise or its authority.
documented_in Nonempty after trimming; stripped path must pass os.Stat. No documentation-content or anchor validation.
implementing_symbol Nonempty after trimming. The symbol is not resolved.
verify_by After trimming, exactly signal_present, test_reference or manual_review. Selects the required evidence field below.
signal_id Nonempty after trimming when mode is signal_present. No signal lookup, execution or applicability check.
test_ref Nonempty after trimming when mode is test_reference; stripped path must pass os.Stat. No function resolution, assertion inspection or test execution.
review_note When mode is manual_review, trimmed text must contain at least 16 Unicode runes. This is a length floor, not a byte count, authenticated review or evidence-quality judgment.

The three native snapshots exercise only test_reference. Manual and signal rules are established by source inspection.

How path suffixes are handled

  • Documentation: remove the first #fragment and everything after it, then an optional trailing colon followed only by ASCII digits. docs/render.md#cancel therefore checks docs/render.md.
  • Test reference: remove the final colon suffix only when it starts with Test, test, Fuzz or Benchmark. witness.py:TestNoPartialOutput checks witness.py. A generic witness.py:42 suffix is not stripped.
  • Filesystem presence: relative paths are joined to the project root; absolute paths are used directly. Success from os.Stat is sufficient. Existing directories, followed symlink targets and parent-relative paths can also pass. The helpers do not enforce regular-file type or confinement to the project root.

Those path shapes are source-reviewed possibilities; the retained snapshots use ordinary relative regular files. Inspect the intended document and witness contents separately. Path helpers.

Status, severity and exit answer different questions

Condition / Check row / Basis here / Remediation or interpretation
Condition Check row Basis here Remediation or interpretation
Nil project or manifest passed to the checker SKIP Source inspection. No check work occurred. This does not specify CLI behavior when project loading fails.
No eligible declared cells SKIP Source inspection. Inspect the intended population and declarations before claiming coverage.
Generic disabled-list policy suppresses the check SKIP Source inspection. Retain the policy decision and its scope.
Required field or checked path is missing WARN S0 executes the missing-test-path case. Repair the declaration or useful reference, then rerun.
All eligible cells meet the presence checks PASS S1 and S2. Assess the referenced evidence separately.
Requirement loading returns an error inside the checker FAIL, still warning severity Source inspection. Resolve loading and rerun; no completed cell assessment follows.

The check's severity remains warning, including on a PASS or loader-error FAIL row. Stage aggregation counts a warning-severity FAIL as a warning. With --fail-level warn, aggregate errors produce exit 1; otherwise warnings produce exit 2; otherwise the exit is 0. At an error threshold, warnings alone do not produce a nonzero exit. The audit default is warn unless configured otherwise; the retained commands explicitly pin warn. A row's word FAIL therefore does not by itself imply exit 1. Stage aggregation and CLI policy.

Keep this reference's scope intact

This check establishes a declared linkage floor. Deriving requirements-based tests, assessing requirements completeness and assuring an agent-proposed change are separate tasks. The broader documented_contract_tested obligation asks for an inventory of applicable shipped behavior claims and adequate executable witnesses. A checker that permits manual and signal declarations overlaps only partly with that obligation. It is also distinct from the audit-process label documented_behavior_verified. One selected witness does not complete either broader task. Catalog distinction.

02 / Start with the evidence record

Free documented-claim evidence worksheet

Copy the complete blank record into an issue, repository document or review. Use one record per claim and a population list for the wider scope. The filled record preserves the actual teaching evidence in the same terms.

Before running anything, obtain the authoritative promise, an identifiable implementation and documentation revision, a usable observation method and an isolated environment for effects. If intent is unresolved, record the question and its decision owner. You can complete this record without Proof; mark native fields NOT RUN or NOT APPLICABLE with a reason.

Blank record

DOCUMENTED-CLAIM EVIDENCE RECORD / BLANK

Proof is optional. If unused, mark native execution NOT RUN with a reason;
complete the intent, implementation, witness and decision sections independently.

IDENTITY AND AUTHORITY
Record ID, revision, author and reviewer:
Requirement ID, revision, lifecycle status and exact cell ID/index:
Claim text and authoritative source/revision:
Intended users, conditions, exceptions and affected behavior:
Intent validator and evidence that the promise is suitable:
Validation status: UNRESOLVED / VALIDATED / REJECTED, with basis:
Authority who may approve or amend the promise; approval record/status:
Authority who may accept the Change or release; separate decision record:

ELIGIBILITY AND POPULATION
Selected requirement roots/IDs and checker/stage:
Loaded requirements included; excluded IDs/statuses and reasons:
Eligible documented_behaviors cells, enumerated by requirement and cell:
Eligible cell count; affected-cell count; individual finding count:
Eligibility rule: skip nil requirements and retired/superseded/rejected;
draft remains eligible, without supplying approval.
Other shipped prose inventoried, undeclared claims and unassessed scope:
No-work or suppression reason, if any:
Eligibility is not approval; SKIP is not demonstrated coverage.

EXACT DECLARATION TO COMPLETE
documented_behaviors:
  - id: [optional stable cell ID]
    claim: [exact documented behavioral assertion]
    documented_in: [documentation path and supported suffix, if used]
    implementing_symbol: [intended implementation reference]
    verify_by: [signal_present OR test_reference OR manual_review]
    signal_id: [required only for signal_present]
    test_ref: [required only for test_reference]
    review_note: [required only for manual_review]
Omit unused mode-specific fields. Required strings must be nonempty after trim.
The checker does not resolve the implementing symbol or signal identifier.
Manual mode: trimmed review_note needs at least 16 Unicode runes, not bytes.
Doc interpretation: remove #fragment, then trailing colon + ASCII digits.
Test interpretation: remove only final suffix starting Test/test/Fuzz/Benchmark.
Resolved paths and what those paths actually contain:
Symbol/signal/test-name applicability reviewed by whom, against which source:
os.Stat presence is not content, anchor, function or assertion validation.
It can accept directories, followed symlinks and paths outside project root.

SOFTWARE, CONFIGURATION AND ORACLE
Baseline/candidate source revision, dirty changes and file hashes:
Documentation, requirement, witness, driver and oracle file hashes:
Native checker binary/build/source/dependency identities, if used:
Tool/runtime versions, build flags, environment and configuration:
Prerequisites, controlled destinations and initial state:
Exact input domain and selected cases; exclusions:
Independent source of expected behavior, fixed before execution:
Expected whole response, keys/types and permitted variation:
Expected complete relevant effects and observation point:
Required-success control and deliberately wrong control, if appropriate:
Actual entrypoint and driver-to-implementation-to-observer call path:
Evidence that the intended implementation was invoked:

STRUCTURAL CHECK / PLAN AND ACTUAL RESULT
Planned executable/argv, cwd, selected check/stage, cache policy and threshold:
Planned expected row and denominator:
Actual executable/argv, cwd, environment and invocation time:
Actual row status; row severity; summary; cell IDs and findings:
Aggregate selected checks/errors/warnings/skips/passes; effective fail level:
Actual process exit; stdout/stderr and persisted-result identities:
Which branches were executed; which conclusions came only from source review:
Input bytes before/after; generated metadata; provenance limitations:
Keep status, severity, threshold and exit separate. No witness run is implied.

BEHAVIORAL WITNESS / PLAN AND ACTUAL RESULT
Planned execution command, cwd, cases, observations and expected child exits:
Actual command/runtime/cwd and retained result identities:
For each actual call:
  Case ID, implementation identity and exact arguments:
  Initial state; expected typed response and effects:
  Actual complete response and effects after the specified observation point:
  Comparison result, discrepancy and raw evidence reference:
Call/return counts, case counts and observation-map units:
Weak/strong comparisons: same observation or separate call, explicitly stated:
Child exit(s); wrapper exit and the meaning of each:
Structural meaning versus behavioral adequacy and currency:
Failure retained; cause; implemented correction or proposed work:
Correction revision; unchanged or authorized revised oracle; replay result:

LIMITATIONS, CURRENCY AND ACCOUNTABLE ACTION
Unperformed conditions, methods, interfaces and reviews:
Evidence status: NOT RUN / PARTIAL / FAILED / BLOCKED / STALE / SUPPORTED:
Scope for which that status is justified:
Stale triggers: claim/authority, doc, code, witness, harness, oracle, runtime,
dependencies, configuration, paths, input conditions or effect boundary changes.
Impact assessment; required rerun or justified reuse and reviewer:
Next action, named accountable owner, due point and required evidence:
Intent approval decision/status:
Change/release decision/status, authority, conditions and unresolved work:

03 / Inspect the failure and its correction

Cancellation says zero published bytes. The target contains A.

The original cancellation paragraph was an unexecuted illustration. The following work is a newly authored teaching implementation with a fictional contract fixed before execution. It is not a recovered incident, customer-approved rule or observed agent-generated change. Contract · Fixed input identities.

Fix the expectation before reading the result

The synchronous interface is render(chunks, cancel_after, destination). Each selected call receives [b'A', b'B'] and starts with fresh regular files: target.bin contains b'KEEP'; unrelated.bin contains b'OTHER'.

Selected condition / Exact expected reply / Complete target bytes after return / Complete unrelated bytes after return
Selected condition Exact expected reply Complete target bytes after return Complete unrelated bytes after return
cancel_after=1 {'status': 'cancelled', 'published_bytes': 0} b'KEEP' b'OTHER'
cancel_after=None {'status': 'completed', 'published_bytes': 2} b'AB' b'OTHER'

The two-key dictionaries, value types and complete selected file bytes are literal expectations. Integer values exclude booleans. They were authored independently of the implementation and retained in cases.json and the strong witness.

The cancellation argument is a cooperative observation point after the first chunk. It does not exercise an asynchronous task, OS signal or network interruption. Only the two stated calls are admitted by this fixture; no input validator or broader input domain was exercised.

First read the native presence result

Each fresh project snapshot declares the same single draft cancellation cell. Only the renderer and witness-file presence or contents differ.

Snapshot / Renderer and referenced witness / Actual native row / severity / Aggregate errors / warnings / Actual exit at warn threshold
Snapshot Renderer and referenced witness Actual native row / severity Aggregate errors / warnings Actual exit at warn threshold
S0 Baseline; witness.py absent. WARN / warning 0 / 1 2
S1 Baseline; weak witness exists. PASS / warning 0 / 0 0
S2 Corrected; strong witness exists. PASS / warning 0 / 0 0

S0 reports test_ref path "witness.py" does not exist for SYS-REQ-001:cancellation_preserves_target. S1 and S2 report all 1 documented claim(s) have evidence present. These are three separate selected-check invocations, with no Python witness execution. S0 JSONL · S1 JSONL · S2 JSONL.

Then inspect what actually ran

The separate behavior driver imports each variant's render function and calls it twice. A profile hook records entries and returns for that exact imported code object. After each return, the driver reads both named files and passes the observation to the witness functions. This is not pytest or unittest execution, and the native snapshot's renderer.py is not being run by the structural audit.

The baseline opens the destination in wb mode, writes the first chunk and then notices cancellation. It returns the required cancellation dictionary, but the target contains b'A'. The response's published_bytes: 0 is a returned claim, not a measurement proving that no write occurred.

The deliberately weak witness only asks:

def TestNoPartialOutput(observation):
    return observation['reply']['status'] == 'cancelled'

That check passes on all three variants' cancellation observations. It makes no new renderer calls and cannot distinguish the baseline's changed target. The stronger witness checks the whole typed reply and both complete file contents.

The implemented correction delays the destination write

The recorded corrected implementation is:

"""Teaching correction: stage in memory before the final selected write."""
from io import BytesIO


def render(chunks, cancel_after, destination):
    buffer = BytesIO()
    for number, chunk in enumerate(chunks, 1):
        buffer.write(chunk)
        if cancel_after == number:
            return {'status': 'cancelled', 'published_bytes': 0}
    complete = buffer.getvalue()
    destination.write_bytes(complete)
    return {'status': 'completed', 'published_bytes': len(complete)}

BytesIO provides an in-memory binary buffer; getvalue() obtains its complete bytes. Path.write_bytes() performs an ordinary write that overwrites an existing file. The correction postpones that write beyond the selected cancellation decision. It creates no staging file and establishes no atomic replacement, failed-write rollback or durability guarantee. Python BytesIO · Python Path.write_bytes.

Variant / Cancellation observation / Normal-completion observation / Strong matches / child exit
Variant Cancellation observation Normal-completion observation Strong matches / child exit
Baseline Expected reply; target is A, so the case fails. Expected reply and AB; case passes. 1/2, exit 1
Corrected Expected reply and KEEP; case passes. Expected reply and AB; case passes. 2/2, exit 0
Deliberately seeded always-cancel control Expected reply and KEEP; case passes. Returns cancelled and leaves KEEP; case fails. 1/2, exit 1

OTHER remains unchanged in all six calls. Normal completion is the required-success control that rejects a blanket early return. It is not a second native claim cell. The wrapper's exit 0 means this expected contrast occurred, including the failing baseline and control children. It does not accept those implementations. All three child results and commands.

Inspect the failed baseline, compare the corrected result, or get the runnable evidence kit and use the reproduction instructions.

Filled record: structural PASS with inadequate evidence, then a bounded repair

This complete selectable record retains the failure, corrected behavior and open decisions. Paths beneath its public artifact base are also files in the extracted kit.

DOCUMENTED-CLAIM EVIDENCE RECORD / FILLED

IDENTITY, AUTHORITY AND ELIGIBILITY
Subject: newly authored synchronous cancellation teaching contract.
Requirement/cell: SYS-REQ-001 version 1 / cancellation_preserves_target.
Lifecycle: draft. Intent basis: CONTRACT.md, authored before execution.
Validation: fixed fictional teaching policy; real-project suitability UNVALIDATED.
Authority/approval: no customer approval or real-project release permission.
Reader adoption requires a named intent validator, promise authority and
Change/release approver. Those real-project roles are not assigned by this record.
Original cancellation paragraph: illustrative and unexecuted; no inherited incident.
No actual agent-generation run is claimed.

Each S0/S1/S2 snapshot loads the one draft requirement below: one eligible cell,
one selected native check. No excluded requirements in this selected fixture.
The authored normal-completion promise and strong witness function are a
behavioral positive control, not a second declared cell or all-prose inventory.

EXACT REQUIREMENT FILE
specs/system/requirements/SYS-REQ-001.req.yaml:
id: SYS-REQ-001
version: 1
status: draft
priority: shall
category: functional
req_type: guarantee
component: renderer
description: Newly authored teaching cancellation promise, with no customer approval.
documented_behaviors:
  - id: cancellation_preserves_target
    claim: "When selected cooperative cancellation is observed after the first chunk, return cancelled and leave the preexisting final target unchanged."
    documented_in: docs/render.md#cancel
    implementing_symbol: renderer.render
    verify_by: test_reference
    test_ref: witness.py:TestNoPartialOutput
EXACT PROJECT CONFIGURATION / proof.yaml
project:
  name: documented-claim-teaching
  specs:
    - path: specs/system
      prefix: SYS-REQ
      type: system
LINK INTERPRETATION
Mode: test_reference. No signal_id or review_note is declared.
docs/render.md#cancel checks existence of docs/render.md, not the anchor/content.
witness.py:TestNoPartialOutput checks witness.py, not the function/assertions.
renderer.render is a nonempty implementing_symbol, not a resolved call.
Doc suffix rule: strip #fragment, then trailing colon + ASCII digits.
Test suffix rule: strip only a final suffix beginning Test/test/Fuzz/Benchmark.
These helpers use os.Stat; regular files, directories and followed symlink
targets can pass, including existing absolute or parent-relative outside paths.
Signal mode would check a nonempty signal_id, not its resolution/execution.
Manual mode would require a trimmed review_note of at least 16 Unicode runes,
not bytes, verified review identity or adequate review. Neither mode was run here.

ARTIFACT BASE AND IDENTITY
Public base: https://reqproof.com/assets/documented-claim-verified/research-rerun/
Relative artifact paths below resolve from that base or the extracted kit root.
manifest.json and SHA256SUMS identify members; provenance.json supplies receipts.
snapshot-source-mapping.json byte-maps native renderer.py/witness.py copies:
  S0 = baseline.py; witness absent.
  S1 = baseline.py + weak_witness.py.
  S2 = corrected.py + strong_witness.py.
SHA256 identities:
  baseline.py: 3d5a3c0545d912293cbb11a786a96ea25d5aebe133e057c53be7230b74ef29cb
  corrected.py: bd963e5875d0067ff611a43df6382f101940332ad26712c1a75010ab13b7d8c1
  always_cancel.py: 04cc1d1ccc93ad2067c6405bdef1c96db6bea82e57ebd35dea49f94907d19a3f
  weak_witness.py: d01a0285c1852ddf52ecc2ecca3084ea4f587230604f06d79c5916786c61d186
  strong_witness.py: 7fb3f67a9c6a2e8f5678be8d1fb3b628c99c465a7a2e7d92cf05e1d1baa3e616
  cases.json: 99d6b98e9eda2eeb5288d2ea1875d7ea2c959263330c2f0db0b604fc81897fb2
  run_behavior.py: c5631e2944527951bf253747502684bef4920b09be82e46bdb9be0d624dd0435
  reproduce.py: 020db207bc1a9dd1f0a82a3f735ac82d6029daa07c251d88ee115dca9af4e276
The exact common requirement, documentation and configuration hashes are in
snapshot-source-mapping.json and each captured/native/S*/command-before.json.

NATIVE BUILD / ACTUAL RETAINED EXECUTION
One offline current-source build, not an installed historical binary.
Go 1.26.3, darwin/arm64; CGO_ENABLED=1; -trimpath.
Selected environment: GOTOOLCHAIN=local, GOPROXY=off, GOSUMDB=off.
Git revision: b566a01085f0233c0be2c71508a2d3caac0cf47a; trackedDirty=true.
4,033 local compiled/embedded input identities; 578 dependency packages.
Full internal input-ledger SHA256:
  11ca8414cc498b2bb0301ee5572096f8528db4d6f37981757a8613d25e0dd6b2
Binary SHA256:
  89c2dfbe34ab2d228b9847a3eca326644d2acce02e614b8dbab630baf83759d2
Build/dependency receipt: captured/build/compiled-source-identity-summary.json
Build flags/module versions: captured/build/binary-buildinfo.stdout
Build cwd:
/Users/buger/.codex/worktrees/verification-plan-guide/reqforge
Actual build argv:
/opt/homebrew/bin/go build -trimpath -o /Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/bin/proof ./cmd/proof
Build exit: 0. The compact kit omits the 165,387,170-byte binary, entire dirty
checkout and full 4,033-file ledger. A Git SHA or arbitrary installed Proof is
insufficient for exact native reproduction; matching source/build inputs are needed.

NATIVE CHECK / PLANNED VERSUS ACTUAL
Before execution, native-expectations.json predicts S0 WARN and S1/S2 PASS,
all warning severity, with one selected check/cell and explicit warn threshold.
Actual common argv, executed separately once in each cwd below:
/Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/bin/proof audit --check documented_claim_verified --stage spec --no-cache --format json --fail-level warn
S0 cwd: /var/folders/23/b655p2x11752nwll58p_zs4c0000gn/T/documented-native-S0-jx7op27i/project
S1 cwd: /var/folders/23/b655p2x11752nwll58p_zs4c0000gn/T/documented-native-S1-z4y75fhp/project
S2 cwd: /var/folders/23/b655p2x11752nwll58p_zs4c0000gn/T/documented-native-S2-3bkjxv8x/project
Actual results:
  S0: WARN / warning; issue_count=1; one finding; errors=0, warnings=1,
      passed=0, skipped=0, selected checks=1, fail_level=warn, process exit=2.
      SYS-REQ-001:cancellation_preserves_target: test_ref path "witness.py" does not exist
  S1: PASS / warning; errors=0, warnings=0, passed=1, skipped=0,
      selected checks=1, fail_level=warn, process exit=0.
  S2: PASS / warning; errors=0, warnings=0, passed=1, skipped=0,
      selected checks=1, fail_level=warn, process exit=0.
  S1/S2 summary: all 1 documented claim(s) have evidence present
Each capture: captured/native/S0, S1 or S2, containing command-before.json,
command-result.json, stdout.jsonl, stderr.txt and persisted-run-result.json.
--format json emitted JSONL. Exact invocation times/hashes are in those receipts.
Authored snapshot inputs remained unchanged. --no-cache bypassed lookup;
the CLI still refreshed trace/index metadata and wrote run/cache artifacts.
S1 PASS with a weak witness is expected presence-check behavior, not a Proof defect.
The selected check did not execute the Python witnesses or inspect their assertions;
S2 PASS alone does not
establish the corrected effect, authority, evidence currency or Change approval.

Status/exit rules from source, beyond the executed rows:
  No eligible cells, nil project/manifest at checker entry, or generic disable:
    SKIP. These branches were not executed in this campaign.
  Incomplete cells: WARN. Only the missing test path was executed here.
  Requirement loader error: FAIL row with warning severity, unexecuted here.
  At warn threshold: aggregate errors -> exit 1; otherwise warnings -> exit 2;
    otherwise exit 0. A warning-severity FAIL contributes a warning, not an error.
  At error threshold, warnings alone allow exit 0. That threshold was not run.
Wider manual/signal, suffix/path and validation branches are source-reviewed only.

PROVENANCE LIMITS
S0 work_units.requirements=2 is telemetry, not the one-cell denominator.
S1/S2 persisted content-addressed run IDs coincide despite separate commands and
changed source/witness bytes:
  run-81e7e858161a7d36d2643562da5b4aa05706caceb04aed7dd7dfc0c539c2124d
Retain source/witness and command-receipt hashes, not that ID alone, to distinguish
the inputs/invocations. No unique revision binding is inferred from the shared ID.
The fresh fixture's clean context does not make the checker build source clean.

BEHAVIOR CONTRACT / FIXED EXPECTATIONS
Entrypoint: render(chunks, cancel_after, destination).
Domain exercised: exact chunks [b'A', b'B']; cancel_after is exact integer 1 or
None; a fresh existing regular target.bin and unrelated.bin for each call.
No other inputs, positions or input-validation behavior were exercised.
Before EVERY call: target.bin=b'KEEP' (hex 4b454550);
                   unrelated.bin=b'OTHER' (hex 4f54484552).
cancel_after=1: expect exactly {'status': 'cancelled', 'published_bytes': 0};
  after return expect target.bin=b'KEEP', unrelated.bin=b'OTHER'.
cancel_after=None: expect exactly {'status': 'completed', 'published_bytes': 2};
  after return expect target.bin=b'AB' (hex 4142), unrelated.bin=b'OTHER'.
Whole dictionary keys/types and full selected file bytes are independently
authored literals in cases.json/strong_witness.py; integer fields exclude bool.
Observe both named files completely after synchronous return.
Cooperative caller cancellation after the first chunk is not async/OS/network
cancellation. Normal completion is a required-success control; always_cancel.py
is a deliberately seeded sensitivity control, not a discovered product defect.

BEHAVIOR INVOCATION / PLANNED VERSUS ACTUAL
Planned contrasts: strong matches baseline 1/2, corrected 2/2, always_cancel 1/2;
child exits 1, 0, 1. Weak cancellation status passes on the same observations.
Actual runtime: CPython 3.14.7, sys.flags.optimize=0, __debug__=true.
Driver path: reproduce.py -> three run_behavior.py children ->
importlib.import_module(variant).render -> two calls per variant -> observations
consumed by TestNoPartialOutput/TestNormalCompletion and fixed cases.json gates.
The weak TestNoPartialOutput then consumes the SAME cancellation observation.
No pytest/unittest invocation; witness functions do not drive extra renderer calls.
Behavior imports the public variants, not the native snapshots' renderer.py paths.
Profile matching: frame.f_code is the exact imported variant.render.__code__.
Captured function identities:
  baseline.render, first line 2, function-source SHA256 9b312cdae03870eae391a71b966dbb9d5126f0a2d4f9219470abaf4c83033ffe
  corrected.render, first line 5, function-source SHA256 7ddc8192ba5ea5530958688598359a9eaa864cec850c4f541744b1451ff76ff7
  always_cancel.render, first line 2, function-source SHA256 3f24bb7d82e8ae4b46949761e6abd0fe3bbd661efcc0e38db77290d0c3d27103
Actual child cwd (all three):
/Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/public-ready
Actual child argv, in order:
/opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/public-ready/run_behavior.py --variant baseline
/opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/public-ready/run_behavior.py --variant corrected
/opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/buger/.codex/worktrees/verification-plan-guide/reqforge/docs/research/remaining-library-refinement-2026-10-28/14-documented-claim-verified/research/public-ready/run_behavior.py --variant always_cancel
ACTUAL SIX OBSERVATIONS / FULL RESPONSES AND SELECTED FILE BYTES
baseline / cancel_after_first / cancel_after=1:
  reply={'status': 'cancelled', 'published_bytes': 0}
  target.bin=b'A'; unrelated.bin=b'OTHER'
  strong_case_passed=False; weak_cancel_status_passed=True
baseline / normal_completion / cancel_after=None:
  reply={'status': 'completed', 'published_bytes': 2}
  target.bin=b'AB'; unrelated.bin=b'OTHER'
  strong_case_passed=True; weak cancellation comparison not applicable.
corrected / cancel_after_first / cancel_after=1:
  reply={'status': 'cancelled', 'published_bytes': 0}
  target.bin=b'KEEP'; unrelated.bin=b'OTHER'
  strong_case_passed=True; weak_cancel_status_passed=True
corrected / normal_completion / cancel_after=None:
  reply={'status': 'completed', 'published_bytes': 2}
  target.bin=b'AB'; unrelated.bin=b'OTHER'
  strong_case_passed=True; weak cancellation comparison not applicable.
always_cancel / cancel_after_first / cancel_after=1:
  reply={'status': 'cancelled', 'published_bytes': 0}
  target.bin=b'KEEP'; unrelated.bin=b'OTHER'
  strong_case_passed=True; weak_cancel_status_passed=True
always_cancel / normal_completion / cancel_after=None:
  reply={'status': 'cancelled', 'published_bytes': 0}
  target.bin=b'KEEP'; unrelated.bin=b'OTHER'
  strong_case_passed=False; weak cancellation comparison not applicable.
Strong matches/actual child exits: baseline 1/2 and 1; corrected 2/2 and 0;
always_cancel 1/2 and 1. Wrapper exit 0 means expected contrast, not acceptance
of the failing baseline/control. Three weak checks pass with zero extra calls.
Units: six render entries/returns, six cases, six before maps plus six after maps;
each map holds two named files: 12 maps/24 individual file states. The six after
maps alone contain 12 after-return states. None of these counts is a native cell count.
Raw evidence: captured/behavior/{baseline,corrected,always_cancel}.stdout.json;
exact commands/exits: captured/behavior/commands.json and summary.json.

FAILURE, IMPLEMENTED CORRECTION AND REPLAY
Baseline opened/truncated the final target in wb mode and wrote A before checking
cancellation. Its returned published_bytes=0 did not measure its actual writes.
Implemented correction: BytesIO staging and the same cancellation seam, then
complete = buffer.getvalue() and destination.write_bytes(complete) on normal completion.
Observed corrected replay matched both fixed cases; expectations did not change.
Always-cancel preserved KEEP but failed required normal completion, so no-write
behavior cannot satisfy this fixture merely by avoiding the cancellation effect.

PORTABLE REPLAY / READER ACTION, NOT AN ADDITIONAL RECORDED RUN
Download: https://reqproof.com/assets/documented-claim-verified/documented-claim-verified-evidence-kit.zip
ZIP: 92,449 bytes; 64 safe regular members; SHA256:
  1ad7673d18b381c2c64b74aebc398c9a7894f2b3a090cb9fdccd045b7051d156
Extract into a new directory. Use Python 3.10+ and the standard library;
use an unprofiled interpreter and select an output directory that does not exist.
From the extracted root:
python3 -B reproduce.py --output /tmp/documented-claim-behavior-rerun
This reruns only the six behavioral calls, with no Proof/network/credentials or
third-party dependency. Record your runtime and new outputs; times/paths can differ.
Optional member verification, where shasum is available:
shasum -a 256 -c SHA256SUMS
Native reproduction is separate and needs the matching build prerequisites above.

LIMITATIONS, CURRENCY AND ACCOUNTABLE NEXT ACTIONS
Evidence status: selected teaching contrast observed; corrected two-case behavior
supported on this recorded basis. Real-project intent/release approval NOT PERFORMED.
Unperformed: async cancellation; I/O/permission failures and rollback; atomic final
publication; crashes, fsync/durability and recovery; concurrency; arbitrary inputs,
resources or cancellation positions; symlink behavior; general file-tree effects.
In-memory staging and selected successful writes establish none of those guarantees.
No production/deployment, certification or full documented_contract_tested claim.
Stale triggers: promise/authority, doc, code, witness, driver, oracle, runtime,
dependencies, configuration, paths, input conditions or effect boundary changes.
Retain impact analysis and a new execution or justified reuse decision.
On real-project adoption, assign named people before using this for acceptance:
  Intent validator/promise owner: approve or amend scope and authoritative wording.
  Implementation owner: retain the failing observation and correction revision.
  Verification owner: run the relevant effect checks and resolve missing conditions.
  Change/release authority: decide acceptance separately after reviewing remaining gaps.
Until assigned and performed, these are proposed responsibilities, not completed reviews.
Hashes identify retained bytes; they do not authenticate intent or confer approval.

Follow the claim and its evidence in six steps

Download the complete video transcript.

Read the complete video transcript

Start with one documented promise and its owner. In this teaching record, cancellation after the first chunk must preserve the existing target. The requirement is a draft, with no real-project approval. Eligibility for the structural check does not make that promise approved for a real project.

Three separate native snapshots each declare one cancellation cell. A missing witness file produces a warning and exit two. An existing weak witness and an existing strong witness both produce a structural pass and exit zero. These commands check the record and paths; they do not execute either witness.

The separate behavior driver calls three renderer variants under two selected conditions, making six synchronous calls. Each begins with target bytes spelling KEEP and an unrelated file spelling OTHER. Independently authored expectations require unchanged files after cancellation, and target bytes A B after normal completion, with exact replies.

The baseline returns cancelled with a published byte count of zero, yet the target contains A. Its normal case succeeds. The weak status check passes on that same cancellation observation. The stronger witness catches the changed target by comparing the complete reply and both selected files.

The correction buffers in memory before an ordinary final write and matches both selected cases. A deliberately seeded always-cancel control preserves cancellation state but fails normal completion. Strong matches are one of two, two of two, and one of two. The successful wrapper records that expected contrast.

Copy the free record and retain the exact source, commands, observations and limitations. For your project, assign the missing review or effect check and obtain the required approval. Asynchronous cancellation, failed writes, atomic publication, concurrency and general file-tree behavior were not tested. Those claims need their own evidence.

Read the text walkthrough

1. Declare one promise

Start with one documented promise and its owner. In this teaching record, cancellation after the first chunk must preserve the existing target. The requirement is a draft, with no real-project approval. Eligibility for the structural check does not make that promise approved for a real project.

2. Read the structural result

Three separate native snapshots each declare one cancellation cell. A missing witness file produces a warning and exit two. An existing weak witness and an existing strong witness both produce a structural pass and exit zero. These commands check the record and paths; they do not execute either witness.

3. Execute the selected behavior

The separate behavior driver calls three renderer variants under two selected conditions, making six synchronous calls. Each begins with target bytes spelling KEEP and an unrelated file spelling OTHER. Independently authored expectations require unchanged files after cancellation, and target bytes A B after normal completion, with exact replies.

4. Inspect the changed target

The baseline returns cancelled with a published byte count of zero, yet the target contains A. Its normal case succeeds. The weak status check passes on that same cancellation observation. The stronger witness catches the changed target by comparing the complete reply and both selected files.

5. Keep the normal completion control

The correction buffers in memory before an ordinary final write and matches both selected cases. A deliberately seeded always-cancel control preserves cancellation state but fails normal completion. Strong matches are one of two, two of two, and one of two. The successful wrapper records that expected contrast.

6. Assign the open work

Copy the free record and retain the exact source, commands, observations and limitations. For your project, assign the missing review or effect check and obtain the required approval. Asynchronous cancellation, failed writes, atomic publication, concurrency and general file-tree behavior were not tested. Those claims need their own evidence.

04 / Turn the record into a repeatable check

A practical sequence for one documented promise

  1. Establish intent. Copy the exact promise and its conditions. Name the person who can validate its usefulness and the authority who can approve or amend it. Resolve contradictions before using a document as an oracle.
  2. Declare the population. Identify the loaded requirement roots, lifecycle states and eligible cells. Record undeclared prose separately. A zero-cell result calls for a scope decision, not a coverage percentage.
  3. Choose the evidence mode. Use the field rules to make the declaration structurally valid. Open the intended document and evidence yourself; check that the references mean what the claim requires.
  4. Pin and run the structural check. Record the actual checker build, software/configuration inputs, exact command and threshold. Retain the row, aggregate result and process exit together.
  5. Obtain the behavioral observation separately. Fix the input domain, independent expected response and relevant effects before execution. Identify the actual implementation entrypoint and use an observation method that can detect the failure you care about.
  6. Retain failure and replay. Preserve the failed observation, implement the justified correction and rerun the same oracle. If intent changes instead, retain the authorized change to the expectation. Include required successful behavior so that doing nothing cannot look correct.
  7. Close the right decision. Assess evidence adequacy and currency, assign remaining work and obtain intent and Change/release decisions separately. Reassess the record when its listed stale triggers occur.

05 / Review the gates

Before calling the record complete

  • The promise has a named validator, authoritative source and approval status.
  • Eligible cells are enumerated; exclusions and undeclared scope are visible.
  • Documentation and evidence references point to the intended content.
  • The actual implementation, runtime, configuration and call path are identified.
  • Expected replies and effects were fixed independently before execution.
  • Structural status, severity, threshold and exit are recorded separately.
  • Raw failure, correction, replay and useful controls are retained.
  • Open effects, stale triggers and accountable next decisions remain explicit.

06 / Repair misleading records

Common mistakes and precise repairs

Mistake / Repair
Mistake Repair
Creating an empty file solely to clear a missing-path warning. Supply and inspect useful evidence, then execute it where execution is the selected method. A path can satisfy the checker without testing the promise.
Retiring a requirement to make the warning disappear. Resolve whether the promise is still shipped. Record the authorized lifecycle decision and any replacement requirement; exclusion alone supplies no evidence for the behavior.
Copying expected values from the implementation being checked. Derive the oracle from the approved promise and inspect its ability to reject a plausible wrong implementation.
Recording only exit 0. Preserve the eligible population, selected row, severity and effective threshold. Exit policy can permit warnings, and no-work results require their own interpretation.
Treating a source or evidence link as a run receipt. Retain actual commands, implementation identity, observations and comparison results. A link can identify planned or unexecuted work.

The checker-specific repairs follow the implemented presence and exit rules. The worked evidence shows why the oracle must inspect effects as well as returned status.

07 / Use Proof for the supported part

Proof workflow: structural linkage, then evidence review

Resolve structural findings with the selected native audit, then retain your repository's application-verification results against the exact requirement/cell and software revision.

Keep four decisions visible:

Decision / What supports it
Decision What supports it
Structural result The native row, eligible population and actual command receipt.
Executed evidence adequacy and currency Relevant observations, independent oracle, implementation linkage and change assessment.
Intent authority The responsible validator and an authorized promise or amendment.
Change/release approval The applicable approver's decision, conditions and unresolved work.

These decisions do not advance automatically when a row becomes PASS.

Configuration and suppression

The source-supported generic disabled list can suppress this check:

project:
  checks:
    disabled:
      - documented_claim_verified

This optional policy example is source-inspected, not one of the three executed snapshots. Suppression produces SKIP; it does not discharge the promise. The dedicated per-check enabled: false recipe in current help has no matching typed configuration support; use the generic list above. Configuration, help and selection source.

Take unresolved effects to the promise owner with the filled record; retain the decision beside the application evidence.

08 / Choose evidence that answers the question

Which method fits the missing evidence?

Need / Useful choice / What still needs judgment or execution
Need Useful choice What still needs judgment or execution
Detect incomplete declared cells or missing referenced paths. The selected documented_claim_verified structural check. Meaning, applicability and contents of the referenced evidence.
Establish a software response and its effects for selected conditions. An executed witness with independently fixed expectations and implementation-call evidence. Domain coverage, environmental fidelity and evidence currency. The supplied Python driver illustrates this method.
Record a review-based disposition. manual_review, with a meaningful note and separately retained reviewer/decision evidence. The check enforces only the trimmed 16-rune floor; it does not authenticate or evaluate the review.
Link a separately managed evidence signal. signal_present, with independent verification that the named signal exists and applies. The checker only requires a nonempty identifier. It does not retrieve or validate the signal.

The mode rules come from the current model and checker; the executable comparison comes from the teaching driver and results. Choose the method that addresses the missing evidence.

09 / Inspect the basis and reproduce the right campaign

Primary sources and reproducibility

Current implementation sources

The source receipt embeds the inspected regions and their file identities:

Source / Supports
Source Supports
pkg/workflow/workflow_documented_claim_verified.go; pkg/model/requirement.go Eligibility, cell validation, modes, path helpers and row results.
pkg/workflow/workflow.go; pkg/workflow/config.go; pkg/workflow/check_descriptors.go Check selection, spec stage, severity and aggregation.
pkg/repo/manifest_checks_access.go; cmd/proof/config.go Generic disabled-list policy and configuration shape.
cmd/proof/audit.go; pkg/audit/audit.go Threshold handling, process exit and retained audit output.
docs/help/checks/documented_claim_verified.md; catalog and intake source in the same receipt The help/configuration discrepancy, partial broader-target fit and audit route.

The included checker test source was inspected as source, not executed in this campaign. The selected native executions are documented by the build receipt, build information and provenance record. The standalone filled record preserves the actual commands and key identities.

Portable behavioral replay

The actual evidence kit ZIP is 92,449 bytes with 64 safe regular members. Its ZIP checksum is:

1ad7673d18b381c2c64b74aebc398c9a7894f2b3a090cb9fdccd045b7051d156

Extract it into a new directory. With an unprofiled Python 3.10 or later interpreter and the standard library, run from the extracted root, choosing an output directory that does not exist:

python3 -B reproduce.py --output /tmp/documented-claim-behavior-rerun

This command reruns only the six behavior calls. It requires no Proof installation, network, credentials or third-party packages. Preserve your runtime and new output alongside the retained observations; the primary campaign used CPython 3.14.7, optimization disabled. The README, content manifest and member checksums explain the supplied files and optional byte verification.

Exact native reproduction has additional prerequisites. The compact kit omits the native binary, complete dirty source checkout and full 4,033-file compilation ledger. Use the captured binary, build, source and dependency identities to assess a matching environment. An installed historical binary or the Git revision alone is not an equivalent current-source build. The portable command performs no native audit.

Official API semantics

Python's BytesIO documentation supports the in-memory buffer and getvalue() interpretation; Path.write_bytes documents writing bytes and overwriting an existing file. The inspected official pages display 3.14.10, not the campaign's 3.14.7 runtime. These sources explain the APIs only. They do not define this teaching cancellation contract or establish atomic publication, durability or asynchronous safety.

10 / Handle two other edge cases

Two source-derived examples, not additional runs

A manual note can meet the length rule without settling the review

Suppose a team chooses manual_review for a claim whose applicability needs human judgment. Count the trimmed note in Unicode runes, not encoded bytes. A multibyte note can reach sixteen bytes while still falling short of sixteen runes. Passing that length check would still leave the reviewer, reviewed revision, reasoning and authority to establish separately. This is a mode-selection example from the model rule, not an executed boundary test.

A retired-only declaration can leave no eligible work

Suppose the only declared cell belongs to a retired requirement, while a user-facing page still promises the behavior. The checker excludes the retired requirement and can return no-work SKIP; it does not inventory that page and create a replacement cell. Decide whether the promise should be withdrawn or assigned to an active authoritative requirement, then obtain appropriate evidence. This is a source-derived scope decision, not a fourth native snapshot. Eligibility and no-work rules.

11 / Resolve the remaining questions

Frequently asked questions

Does --no-cache leave the project untouched?

No. In the retained native campaign it bypassed cache lookup, while the CLI refreshed trace/index metadata and wrote run/cache artifacts. The authored snapshot input bytes were checked and remained unchanged. Use an appropriate isolated copy when retaining comparable evidence. Invocation provenance.

Why do S1 and S2 have the same persisted run ID?

Their content-addressed persisted IDs coincide despite separate commands and changed source/witness bytes. The receipt does not establish a unique invocation or revision binding from that ID. Use the command receipts, input hashes and source mapping together; no cause beyond the captured evidence is inferred. Native provenance and recorded limitation.

Which source wins when documentation and the approved requirement disagree?

The checker cannot decide. Record both versions and ask the responsible authority to resolve the intended behavior. Do not silently change the oracle to match current code or treat the newer timestamp as approval. Keep any interim result scoped to the expectation actually checked.