@linimin/pi-letscook 0.1.32 → 0.1.35

package/scripts/evaluator-calibration-test.sh

@@ -0,0 +1,363 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+node <<'NODE'
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  parseReportFields,
+  transcribeCanonicalRoleReport,
+} = require('./extensions/completion/role-reporting.js');
+
+const read = (file) => fs.readFileSync(file, 'utf8');
+const assertIncludes = (file, snippet) => {
+  const text = read(file);
+  if (!text.includes(snippet)) {
+    throw new Error(`${file} is missing required evaluator-calibration text: ${snippet}`);
+  }
+};
+
+assertIncludes('package.json', '"evaluator-calibration-test": "bash ./scripts/evaluator-calibration-test.sh"');
+assertIncludes('scripts/release-check.sh', 'npm run evaluator-calibration-test');
+assertIncludes('.agent/verify_completion_stop.sh', 'npm run evaluator-calibration-test >/dev/null');
+assertIncludes('README.md', 'Evaluator calibration now also fails closed on semantically lenient but well-formed reports.');
+assertIncludes('README.md', '`npm run evaluator-calibration-test` drives the packaged transcription path through reviewer yes-with-follow-up, auditor open-contracts-with-`Next mandatory slice: none`, and stop-judge yes-with-open-contracts fixtures while still accepting truthful passing reports.');
+assertIncludes('README.md', 'It also rejects the reproducible `none; ...` bypass family for reviewer follow-up, auditor worktree blockers, and stop-judge open-contract reporting, while still accepting only the exact reviewer routing text `Smallest follow-up slice: none; proceed to completion-auditor.` with terminal punctuation or whitespace only.');
+assertIncludes('README.md', 'includes deterministic active-slice contract coverage plus observability coverage, evaluator calibration, and the rubric-contract regression');
+assertIncludes('CHANGELOG.md', 'added evaluator calibration fixtures for semantically lenient but well-formed reviewer/auditor/stop-judge reports');
+assertIncludes('CHANGELOG.md', 'tightened the reproducible `none; ...` reviewer/auditor/stop-judge bypass checks while still accepting only the exact reviewer `none; proceed to completion-auditor` routing allowance with terminal punctuation or whitespace only');
+assertIncludes('CHANGELOG.md', 'wired `npm run evaluator-calibration-test` into `npm run release-check` and `.agent/verify_completion_stop.sh`');
+assertIncludes('CHANGELOG.md', 'fixed the smoke auto-resume prompt regression');
+assertIncludes('extensions/completion/role-reporting.js', 'Reviewer output cannot mark \'Acceptable as-is: yes\' while naming a follow-up slice other than none.');
+assertIncludes('extensions/completion/role-reporting.js', 'Auditor output cannot mark \'Tracked and unignored worktree is clean: yes\' while listing worktree blockers.');
+assertIncludes('extensions/completion/role-reporting.js', 'Auditor output cannot leave \'Next mandatory slice\' as none while open contracts, blockers, or high-value gaps remain.');
+assertIncludes('extensions/completion/role-reporting.js', 'Stop-judge output cannot mark \'Can the project stop now: yes\' while naming remaining open top-level contract IDs.');
+assertIncludes('extensions/completion/role-reporting.js', 'Stop-judge output cannot mark \'Can the project stop now: yes\' when Blocker count is greater than 0.');
+
+const tempRootBase = path.join(process.cwd(), '.agent', 'tmp');
+fs.mkdirSync(tempRootBase, { recursive: true });
+const tempRoot = fs.mkdtempSync(path.join(tempRootBase, 'evaluator-calibration-'));
+const snapshotFiles = {
+  sliceHistoryPath: path.join(tempRoot, 'slice-history.jsonl'),
+  stopHistoryPath: path.join(tempRoot, 'stop-check-history.jsonl'),
+};
+fs.writeFileSync(snapshotFiles.sliceHistoryPath, '');
+fs.writeFileSync(snapshotFiles.stopHistoryPath, '');
+
+const readJsonl = (file) =>
+  fs
+    .readFileSync(file, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+const assert = (condition, message) => {
+  if (!condition) throw new Error(message);
+};
+
+const reviewerPass = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - Locked acceptance criteria match the committed slice.
+- Correctness risk: pass - No blocking regression is evident.
+- Verification evidence: pass - Deterministic proof was rerun successfully.
+- Docs/state parity: pass - Docs and canonical state are aligned.
+Findings: none.
+Acceptable as-is: yes
+Smallest follow-up slice: none; proceed to completion-auditor.`;
+
+const reviewerLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - Locked acceptance criteria match the committed slice.
+- Correctness risk: pass - No blocking regression is evident.
+- Verification evidence: pass - Deterministic proof was rerun successfully.
+- Docs/state parity: pass - Docs and canonical state are aligned.
+Findings: none.
+Acceptable as-is: yes
+Smallest follow-up slice: tighten docs before audit.`;
+
+const reviewerNonePrefixedLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - Locked acceptance criteria match the committed slice.
+- Correctness risk: pass - No blocking regression is evident.
+- Verification evidence: pass - Deterministic proof was rerun successfully.
+- Docs/state parity: pass - Docs and canonical state are aligned.
+Findings: none.
+Acceptable as-is: yes
+Smallest follow-up slice: none; tighten docs before audit.`;
+
+const reviewerTrailingTextAfterRoutingLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - Locked acceptance criteria match the committed slice.
+- Correctness risk: pass - No blocking regression is evident.
+- Verification evidence: pass - Deterministic proof was rerun successfully.
+- Docs/state parity: pass - Docs and canonical state are aligned.
+Findings: none.
+Acceptable as-is: yes
+Smallest follow-up slice: none; proceed to completion-auditor; tighten docs before audit.`;
+
+const auditorPass = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - The accepted slice remains satisfied on HEAD.
+- Correctness risk: concern - One planned contract still keeps the project open.
+- Verification evidence: pass - Verification was rerun for the accepted slice.
+- Docs/state parity: pass - Canonical state can be reconciled truthfully.
+Why the project is still not done: One planned contract remains after this accepted slice.
+Open top-level contract IDs: TEST-CONTRACT
+Blocker count: 0
+High-value gap count: 1
+Tracked and unignored worktree is clean: yes
+Worktree blockers: none
+Next mandatory slice: next-slice
+Stale or conflicting canonical state: no
+Plan truthfully captures remaining slice backlog: yes - one planned slice remains.`;
+
+const auditorLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - The accepted slice remains satisfied on HEAD.
+- Correctness risk: concern - One planned contract still keeps the project open.
+- Verification evidence: pass - Verification was rerun for the accepted slice.
+- Docs/state parity: pass - Canonical state can be reconciled truthfully.
+Why the project is still not done: One planned contract remains after this accepted slice.
+Open top-level contract IDs: TEST-CONTRACT
+Blocker count: 0
+High-value gap count: 1
+Tracked and unignored worktree is clean: yes
+Worktree blockers: modified README.md
+Next mandatory slice: none.
+Stale or conflicting canonical state: no
+Plan truthfully captures remaining slice backlog: yes - one planned slice remains.`;
+
+const auditorNonePrefixedLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: TEST-CONTRACT
+Rubric:
+- Contract coverage: pass - The accepted slice remains satisfied on HEAD.
+- Correctness risk: concern - One planned contract still keeps the project open.
+- Verification evidence: pass - Verification was rerun for the accepted slice.
+- Docs/state parity: pass - Canonical state can be reconciled truthfully.
+Why the project is still not done: One planned contract remains after this accepted slice.
+Open top-level contract IDs: TEST-CONTRACT
+Blocker count: 0
+High-value gap count: 1
+Tracked and unignored worktree is clean: yes
+Worktree blockers: none; modified README.md
+Next mandatory slice: next-slice
+Stale or conflicting canonical state: no
+Plan truthfully captures remaining slice backlog: yes - one planned slice remains.`;
+
+const stopJudgePass = `MISSION ANCHOR: test mission
+Remaining contract IDs: none
+Rubric:
+- Contract coverage: pass - All implementation slices are accepted on HEAD.
+- Correctness risk: pass - No remaining blocker or high-value gap is evident.
+- Verification evidence: pass - Final verification passes for the current head.
+- Docs/state parity: pass - Docs, config, and canonical state match shipped behavior.
+Can the project stop now: yes
+Exact remaining open top-level contract IDs: none
+Blocker count: 0
+High-value gap count: 0
+Latest completed slice commit: abcdef1234567890abcdef1234567890abcdef12
+Docs/config/runbooks match shipped behavior: yes
+Tracked and unignored worktree is clean: yes
+Brief justification: Current HEAD satisfies the stop criteria.`;
+
+const stopJudgeLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: none
+Rubric:
+- Contract coverage: pass - All implementation slices are accepted on HEAD.
+- Correctness risk: pass - No additional risk was found.
+- Verification evidence: pass - Final verification passes for the current head.
+- Docs/state parity: pass - Docs, config, and canonical state match shipped behavior.
+Can the project stop now: yes
+Exact remaining open top-level contract IDs: TEST-CONTRACT
+Blocker count: 1
+High-value gap count: 0
+Latest completed slice commit: abcdef1234567890abcdef1234567890abcdef12
+Docs/config/runbooks match shipped behavior: yes
+Tracked and unignored worktree is clean: yes
+Brief justification: This should be rejected because remaining contracts and blockers still exist.`;
+
+const stopJudgeNonePrefixedLenient = `MISSION ANCHOR: test mission
+Remaining contract IDs: none
+Rubric:
+- Contract coverage: pass - All implementation slices are accepted on HEAD.
+- Correctness risk: pass - No additional risk was found.
+- Verification evidence: pass - Final verification passes for the current head.
+- Docs/state parity: pass - Docs, config, and canonical state match shipped behavior.
+Can the project stop now: yes
+Exact remaining open top-level contract IDs: none; TEST-CONTRACT
+Blocker count: 0
+High-value gap count: 0
+Latest completed slice commit: abcdef1234567890abcdef1234567890abcdef12
+Docs/config/runbooks match shipped behavior: yes
+Tracked and unignored worktree is clean: yes
+Brief justification: This should be rejected because remaining contracts still exist behind a none-prefixed field.`;
+
+(async () => {
+  const reviewed = await transcribeCanonicalRoleReport({
+    role: 'completion-reviewer',
+    output: reviewerPass,
+    reportFields: parseReportFields(reviewerPass),
+    snapshotFiles,
+    headSha: '1111111111111111111111111111111111111111',
+    sliceId: 'slice-review',
+    recordedAt: 1,
+  });
+  assert(reviewed.errors.length === 0, `reviewer passing fixture should transcribe cleanly: ${reviewed.errors.join(' | ')}`);
+  assert(reviewed.appended.includes('reviewed:slice-review'), 'reviewer passing fixture should append a reviewed record');
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 1, 'reviewer passing fixture should create one slice-history record');
+
+  const reviewerRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-reviewer',
+    output: reviewerLenient,
+    reportFields: parseReportFields(reviewerLenient),
+    snapshotFiles,
+    headSha: '2222222222222222222222222222222222222222',
+    sliceId: 'slice-review',
+    recordedAt: 2,
+  });
+  assert(
+    reviewerRejected.errors.some((error) => error.includes('follow-up slice other than none')),
+    `reviewer lenient fixture should be rejected for a yes verdict with a follow-up slice: ${reviewerRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 1, 'rejected reviewer fixture must not append history');
+
+  const reviewerNonePrefixedRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-reviewer',
+    output: reviewerNonePrefixedLenient,
+    reportFields: parseReportFields(reviewerNonePrefixedLenient),
+    snapshotFiles,
+    headSha: '7777777777777777777777777777777777777777',
+    sliceId: 'slice-review',
+    recordedAt: 7,
+  });
+  assert(
+    reviewerNonePrefixedRejected.errors.some((error) => error.includes('follow-up slice other than none')),
+    `reviewer none-prefixed lenient fixture should be rejected for a yes verdict with contradictory routing text: ${reviewerNonePrefixedRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 1, 'rejected none-prefixed reviewer fixture must not append history');
+
+  const reviewerTrailingTextAfterRoutingRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-reviewer',
+    output: reviewerTrailingTextAfterRoutingLenient,
+    reportFields: parseReportFields(reviewerTrailingTextAfterRoutingLenient),
+    snapshotFiles,
+    headSha: '1010101010101010101010101010101010101010',
+    sliceId: 'slice-review',
+    recordedAt: 10,
+  });
+  assert(
+    reviewerTrailingTextAfterRoutingRejected.errors.some((error) => error.includes('follow-up slice other than none')),
+    `reviewer routing-trailing-text fixture should be rejected for extra text after the exact completion-auditor allowance: ${reviewerTrailingTextAfterRoutingRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 1, 'rejected reviewer routing-trailing-text fixture must not append history');
+
+  const audited = await transcribeCanonicalRoleReport({
+    role: 'completion-auditor',
+    output: auditorPass,
+    reportFields: parseReportFields(auditorPass),
+    snapshotFiles,
+    headSha: '3333333333333333333333333333333333333333',
+    sliceId: 'slice-audit',
+    recordedAt: 3,
+  });
+  assert(audited.errors.length === 0, `auditor passing fixture should transcribe cleanly: ${audited.errors.join(' | ')}`);
+  assert(audited.appended.includes('audited:slice-audit'), 'auditor passing fixture should append an audited record');
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 2, 'auditor passing fixture should append a second slice-history record');
+
+  const auditorRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-auditor',
+    output: auditorLenient,
+    reportFields: parseReportFields(auditorLenient),
+    snapshotFiles,
+    headSha: '4444444444444444444444444444444444444444',
+    sliceId: 'slice-audit',
+    recordedAt: 4,
+  });
+  assert(
+    auditorRejected.errors.some((error) => error.includes('listing worktree blockers')),
+    `auditor lenient fixture should reject clean-yes reports that still list worktree blockers: ${auditorRejected.errors.join(' | ')}`,
+  );
+  assert(
+    auditorRejected.errors.some((error) => error.includes("Next mandatory slice") && error.includes('none')),
+    `auditor lenient fixture should reject open-work reports with no next mandatory slice: ${auditorRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 2, 'rejected auditor fixture must not append history');
+
+  const auditorNonePrefixedRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-auditor',
+    output: auditorNonePrefixedLenient,
+    reportFields: parseReportFields(auditorNonePrefixedLenient),
+    snapshotFiles,
+    headSha: '8888888888888888888888888888888888888888',
+    sliceId: 'slice-audit',
+    recordedAt: 8,
+  });
+  assert(
+    auditorNonePrefixedRejected.errors.some((error) => error.includes('listing worktree blockers')),
+    `auditor none-prefixed lenient fixture should reject clean-yes reports that smuggle blockers behind none: ${auditorNonePrefixedRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.sliceHistoryPath).length === 2, 'rejected none-prefixed auditor fixture must not append history');
+
+  const judged = await transcribeCanonicalRoleReport({
+    role: 'completion-stop-judge',
+    output: stopJudgePass,
+    reportFields: parseReportFields(stopJudgePass),
+    snapshotFiles,
+    headSha: '5555555555555555555555555555555555555555',
+    recordedAt: 5,
+  });
+  assert(judged.errors.length === 0, `stop-judge passing fixture should transcribe cleanly: ${judged.errors.join(' | ')}`);
+  assert(judged.appended.includes('judgment:555555555555'), 'stop-judge passing fixture should append a judgment record');
+  assert(readJsonl(snapshotFiles.stopHistoryPath).length === 1, 'stop-judge passing fixture should create one judgment record');
+
+  const judgeRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-stop-judge',
+    output: stopJudgeLenient,
+    reportFields: parseReportFields(stopJudgeLenient),
+    snapshotFiles,
+    headSha: '6666666666666666666666666666666666666666',
+    recordedAt: 6,
+  });
+  assert(
+    judgeRejected.errors.some((error) => error.includes('remaining open top-level contract IDs')),
+    `stop-judge lenient fixture should reject yes verdicts with open contracts: ${judgeRejected.errors.join(' | ')}`,
+  );
+  assert(
+    judgeRejected.errors.some((error) => error.includes('Blocker count is greater than 0')),
+    `stop-judge lenient fixture should reject yes verdicts with blockers: ${judgeRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.stopHistoryPath).length === 1, 'rejected stop-judge fixture must not append judgment history');
+
+  const judgeNonePrefixedRejected = await transcribeCanonicalRoleReport({
+    role: 'completion-stop-judge',
+    output: stopJudgeNonePrefixedLenient,
+    reportFields: parseReportFields(stopJudgeNonePrefixedLenient),
+    snapshotFiles,
+    headSha: '9999999999999999999999999999999999999999',
+    recordedAt: 9,
+  });
+  assert(
+    judgeNonePrefixedRejected.errors.some((error) => error.includes('remaining open top-level contract IDs')),
+    `stop-judge none-prefixed lenient fixture should reject yes verdicts with none-prefixed open contracts: ${judgeNonePrefixedRejected.errors.join(' | ')}`,
+  );
+  assert(readJsonl(snapshotFiles.stopHistoryPath).length === 1, 'rejected none-prefixed stop-judge fixture must not append judgment history');
+
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+})().catch((error) => {
+  try {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  } catch {}
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+NODE
+
+echo "evaluator calibration test passed"

package/scripts/refocus-test.sh

@@ -34,6 +34,37 @@ print(state['mission_anchor'])
 PY
 )"
 
+CHOOSER_SNAPSHOT="$TMPDIR/existing-workflow-chooser.json"
+PI_COMPLETION_EXISTING_WORKFLOW_ACTION=cancel \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_SNAPSHOT" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi -e "$PKG_ROOT" -p "/cook replacement mission that should stay in the main chat" \
+  >/tmp/pi-completion-refocus-cancel.out 2>/tmp/pi-completion-refocus-cancel.err
+
+python3 - "$CHOOSER_SNAPSHOT" "/tmp/pi-completion-refocus-cancel.out" "/tmp/pi-completion-refocus-cancel.err" "$INITIAL_MISSION" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+chooser = json.loads(Path(sys.argv[1]).read_text())
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+initial_mission = sys.argv[4]
+state = json.loads(Path('.agent/state.json').read_text())
+plan = json.loads(Path('.agent/plan.json').read_text())
+active = json.loads(Path('.agent/active-slice.json').read_text())
+
+assert state['mission_anchor'] == initial_mission, 'cancelled chooser should keep the current mission anchor'
+assert plan['mission_anchor'] == initial_mission, 'cancelled chooser should keep plan.json unchanged'
+assert active['mission_anchor'] == initial_mission, 'cancelled chooser should keep active-slice.json unchanged'
+assert chooser['title'].startswith('Existing completion workflow found'), 'chooser snapshot should describe the existing-workflow prompt'
+assert chooser['choices'][0].startswith('Continue current workflow'), 'chooser should keep the continue option'
+assert chooser['choices'][1].startswith('Abandon current workflow and start this new one'), 'chooser should keep the refocus option'
+assert 'Start/Cancel confirmation' in chooser['choices'][1], 'chooser should mention the approval-only replacement confirmation'
+assert chooser['choices'][2].startswith('Cancel'), 'chooser should keep the cancel option'
+assert 'Discuss changes in the main chat and rerun /cook.' in chooser['choices'][2], 'chooser cancel copy should redirect users back to the main chat and rerun /cook'
+assert 'Discuss changes in the main chat and rerun /cook.' in output, 'chooser cancel output should redirect users back to the main chat and rerun /cook'
+PY
+
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi -e "$PKG_ROOT" -p "/cook refocused smoke-test mission with tests and docs" \

package/scripts/release-check.sh

@@ -4,11 +4,15 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT"
 
-echo "[release-check] running startup/refocus/context regressions, including critique-aware /cook confirmation coverage"
+echo "[release-check] running control-plane validation, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, evaluator calibration, and rubric contract coverage"
+bash .agent/verify_completion_control_plane.sh
 npm run smoke-test
 npm run refocus-test
 npm run context-proposal-test
+bash ./scripts/canonical-evidence-artifact-test.sh
+bash ./scripts/active-slice-contract-test.sh
 npm run observability-status-test
+npm run evaluator-calibration-test
 npm run rubric-contract-test
 npm pack --dry-run >/dev/null
 

package/scripts/smoke-test.sh

@@ -19,7 +19,7 @@ PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$KICKOFF_PROMPT" \
 pi -e "$PKG_ROOT" -p "/cook smoke-test mission" \
   >"$TMPDIR/pi-completion-smoke-bootstrap.out" 2>"$TMPDIR/pi-completion-smoke-bootstrap.err"
 
-for file in .agent/profile.json .agent/state.json .agent/plan.json .agent/active-slice.json; do
+for file in .agent/profile.json .agent/state.json .agent/plan.json .agent/active-slice.json .agent/verification-evidence.json; do
   [[ -f "$file" ]] || { echo "missing canonical bootstrap file: $file" >&2; exit 1; }
 done
 
@@ -38,6 +38,7 @@ profile = json.loads(Path('.agent/profile.json').read_text())
 state = json.loads(Path('.agent/state.json').read_text())
 plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
+evidence = json.loads(Path('.agent/verification-evidence.json').read_text())
 kickoff = Path(sys.argv[1]).read_text()
 
 assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after bootstrap'
@@ -50,6 +51,10 @@ assert active['task_type'] == expected_task_type, 'active-slice.json task_type m
 assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after bootstrap'
 assert active['implementation_surfaces'] == [], 'active-slice.json should scaffold empty implementation_surfaces'
 assert active['verification_commands'] == [], 'active-slice.json should scaffold empty verification_commands'
+assert evidence['artifact_type'] == 'completion-verification-evidence', 'verification-evidence.json artifact_type mismatch after bootstrap'
+assert evidence['subject_type'] == 'none', 'verification-evidence.json should scaffold idle subject_type'
+assert evidence['verification_commands'] == [], 'verification-evidence.json should scaffold empty verification_commands'
+assert evidence['outcome'] == 'not_recorded', 'verification-evidence.json should scaffold not_recorded outcome'
 assert 'Canonical routing profile:' in kickoff, 'kickoff prompt should expose canonical routing profile'
 assert f'- task_type: {expected_task_type}' in kickoff, 'kickoff prompt missing canonical task_type'
 assert f'- evaluation_profile: {expected_eval_profile}' in kickoff, 'kickoff prompt missing canonical evaluation_profile'
@@ -167,6 +172,56 @@ active.pop('why_now', None)
 path.write_text(json.dumps(active, indent=2) + '\n')
 PY
 
+python3 - <<'PY'
+import json
+from pathlib import Path
+active = json.loads(Path('.agent/active-slice.json').read_text())
+plan_path = Path('.agent/plan.json')
+plan = json.loads(plan_path.read_text())
+plan['candidate_slices'] = [{
+    'slice_id': active['slice_id'],
+    'goal': active['goal'],
+    'acceptance_criteria': active['acceptance_criteria'],
+    'contract_ids': active['contract_ids'],
+    'priority': 1,
+    'status': 'selected',
+    'why_now': 'smoke test exact handoff',
+    'blocked_on': active['blocked_on'],
+    'evidence': [],
+    'locked_notes': active['locked_notes'],
+    'must_fix_findings': active['must_fix_findings'],
+    'implementation_surfaces': ['extensions/completion/index.ts', '.agent/verify_completion_control_plane.sh'],
+    'verification_commands': ['bash .agent/verify_completion_control_plane.sh', 'npm run smoke-test'],
+    'basis_commit': active['basis_commit'],
+    'remaining_contract_ids_before': active['remaining_contract_ids_before'],
+    'release_blocker_count_before': active['release_blocker_count_before'],
+    'high_value_gap_count_before': active['high_value_gap_count_before'],
+}]
+plan_path.write_text(json.dumps(plan, indent=2) + '\n')
+PY
+
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+active = json.loads(Path('.agent/active-slice.json').read_text())
+evidence = {
+    'schema_version': 1,
+    'artifact_type': 'completion-verification-evidence',
+    'subject_type': 'selected_slice',
+    'slice_id': active['slice_id'],
+    'goal': active['goal'],
+    'contract_ids': active['contract_ids'],
+    'basis_commit': active['basis_commit'],
+    'head_sha': active['basis_commit'],
+    'verification_commands': ['bash .agent/verify_completion_control_plane.sh', 'npm run smoke-test'],
+    'outcome': 'passed',
+    'recorded_at': '2026-05-03T00:00:00Z',
+    'summary': 'Smoke selected-slice evidence matches the temporary active-slice fixture.',
+}
+Path('.agent/verification-evidence.json').write_text(json.dumps(evidence, indent=2) + '\n')
+PY
+
 if bash .agent/verify_completion_control_plane.sh >/dev/null 2>&1; then
   echo "expected control-plane verification to fail when selected active-slice omits priority/why_now" >&2
   exit 1

package/skills/completion-protocol/SKILL.md

@@ -101,6 +101,7 @@ Ignored canonical execution-state files:
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
 - `.agent/stop-check-history.jsonl`
+- `.agent/verification-evidence.json`
 - `.agent/*.log`
 
 ## Canonical Inputs
@@ -115,6 +116,7 @@ Read these when making completion decisions:
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
 - `.agent/stop-check-history.jsonl`
+- `.agent/verification-evidence.json`
 
 Optional context only:
 
@@ -138,6 +140,7 @@ After context compaction, suspected memory loss, stalled-role recovery, or any a
 - `.agent/state.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
+- `.agent/verification-evidence.json`
 
 The workflow driver must invoke `completion-regrounder` before continuing whenever any of the following is true:
 
@@ -152,7 +155,7 @@ The exact implementer handoff now includes implementation-scope surfaces and exp
 
 The workflow driver must not continue implementation, review, audit, or stop evaluation from compacted conversation memory alone.
 
-After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
+After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
 
 ## Shared Report Header
 

package/skills/completion-protocol/references/completion.md

@@ -17,8 +17,29 @@
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
 - `.agent/stop-check-history.jsonl`
+- `.agent/verification-evidence.json`
 - `.agent/*.log`
 
+## Canonical Inputs
+
+Read these when making completion decisions:
+
+- `.agent/mission.md`
+- `.agent/README.md`
+- `.agent/profile.json`
+- `.agent/state.json`
+- `.agent/plan.json`
+- `.agent/active-slice.json`
+- `.agent/slice-history.jsonl`
+- `.agent/stop-check-history.jsonl`
+- `.agent/verification-evidence.json`
+
+Optional context only:
+
+- `.agent/backlog.md`
+- `.agent/handoff.md`
+- `.agent/compact.md`
+
 ## Scratch Space
 
 - Use repo-local `.agent/tmp/` as the default temporary workspace for completion.
@@ -332,6 +353,7 @@ After context compaction, suspected memory loss, stalled-role recovery, or any a
 - `.agent/state.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
+- `.agent/verification-evidence.json`
 
 The workflow root must invoke `completion-regrounder` before continuing whenever any of the following is true:
 
@@ -344,6 +366,8 @@ The workflow root must invoke `completion-regrounder` before continuing whenever
 
 The workflow root must not continue implementation, review, audit, or stop evaluation from compacted conversation memory alone.
 
+After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
+
 ## Default Priority Policy
 
 `completion-default` ranks candidate slices in this order: