@linimin/pi-letscook 0.1.68 → 0.1.70

package/scripts/context-proposal-test.sh

@@ -90,22 +90,6 @@ with session_path.open('w', encoding='utf-8') as fh:
 PY
 }
 
-bootstrap_workflow() {
-  local repo_root="$1"
-  local session_path="$2"
-  local discussion="$3"
-  local generated_handoff="$4"
-  mkdir -p "$repo_root"
-  cd "$repo_root"
-  git init -q
-  write_session "$session_path" "$repo_root" "$discussion"
-  PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-  PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$generated_handoff" \
-  PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-  pi --session "$session_path" -e "$PKG_ROOT" -p "/cook" \
-    >"$TMPDIR/bootstrap.out" 2>"$TMPDIR/bootstrap.err"
-}
-
 mark_done() {
   python3 - <<'PY'
 import json
@@ -158,29 +142,25 @@ active_path.write_text(json.dumps(active, indent=2) + '\n')
 PY
 }
 
-snapshot_tracked() {
-  local baseline_path="$1"
-  python3 - "$baseline_path" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-tracked = [
-    Path('.agent/mission.md'),
-    Path('.agent/profile.json'),
-    Path('.agent/state.json'),
-    Path('.agent/startup-plan.json'),
-    Path('.agent/startup-plan.md'),
-    Path('.agent/plan.json'),
-    Path('.agent/active-slice.json'),
-    Path('.agent/verification-evidence.json'),
-]
-Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in tracked}, indent=2) + '\n')
-PY
-}
+ROOT="$TMPDIR/repo"
+mkdir -p "$ROOT"
+cd "$ROOT"
+git init -q
 
-STARTUP_DISCUSSION=$'Remove the completion status line while keeping the completion widget and keep the startup confirm-first.'
-STARTUP_HANDOFF="$(python3 - <<'PY'
+# No workflow yet: bare /cook should be able to generate a primary-agent handoff in the same entry,
+# then continue directly to startup confirmation.
+SESSION_ZERO="$TMPDIR/session-zero.jsonl"
+DISCUSSION_ZERO=$'Mission: Remove the completion status line while keeping the completion widget.
+Scope:
+- Keep the non-running completion widget.
+- Suppress the widget while a completion role is active.
+Constraints:
+- Do not reintroduce any other completion status surface.
+Acceptance:
+- Update README to match the shipped behavior.
+- Keep observability regression coverage truthful.'
+DISCUSSION_SNAPSHOT_ZERO="$TMPDIR/context-proposal-structured-fallback.json"
+GENERATED_HANDOFF_ZERO="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
@@ -191,382 +171,1522 @@ capsule = {
         "Suppress the widget while a completion role is active."
     ],
     "constraints": [
-        "Do not reintroduce another completion status surface."
+        "Do not reintroduce any other completion status surface."
     ],
     "acceptance": [
         "Update README to match the shipped behavior.",
         "Keep observability regression coverage truthful."
     ],
     "risks": [],
-    "notes": ["Generated by same-entry primary-agent startup-plan synthesis."],
+    "notes": ["Generated by the primary-agent handoff step triggered from /cook."],
     "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Remove the completion status line while preserving widget behavior.",
-    "first_slice_non_goals": ["Do not add a replacement status surface."],
+    "first_slice_goal": "Remove the completion status line while preserving the widget behavior.",
+    "first_slice_non_goals": ["Do not reintroduce another status surface."],
     "implementation_surfaces": ["extensions/completion/index.ts", "README.md"],
     "verification_commands": ["npm run smoke-test"],
-    "why_this_slice_first": "The startup mission is already concrete and bounded enough to begin workflow planning.",
+    "why_this_slice_first": "This slice is already concrete and bounded enough to start workflow safely.",
     "task_type": "completion-workflow",
     "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The user explicitly chose workflow mode for this bounded implementation mission."
+    "why_cook_now": "The user explicitly chose workflow mode for this bounded implementation slice."
 }
 print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
 PY
 )"
-MATCHING_HANDOFF="$(python3 - <<'PY'
+write_session "$SESSION_ZERO" "$ROOT" "$DISCUSSION_ZERO"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$GENERATED_HANDOFF_ZERO" PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_ZERO" PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 pi --session "$SESSION_ZERO" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-structured-fallback.out" 2>"$TMPDIR/pi-completion-context-proposal-structured-fallback.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-structured-fallback.out" "$TMPDIR/pi-completion-context-proposal-structured-fallback.err" "$DISCUSSION_SNAPSHOT_ZERO" <<'PY'
 import json
-capsule = {
-    "kind": "cook_handoff",
-    "source": "primary_agent",
-    "mission": "Remove the completion status line while keeping the completion widget.",
-    "scope": ["Keep the widget behavior aligned with the current mission."],
-    "constraints": ["Do not replace the current mission."],
-    "acceptance": [
-        "Keep the non-running completion widget visible while no role is active.",
-        "Verify with npm run smoke-test that active-role suppression still works."
-    ],
-    "risks": [],
-    "notes": [],
-    "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Continue the current mission without changing it.",
-    "first_slice_non_goals": [],
-    "implementation_surfaces": ["extensions/completion/index.ts"],
-    "verification_commands": ["npm run smoke-test"],
-    "why_this_slice_first": "The current mission already matches the latest startup plan.",
-    "task_type": "completion-workflow",
-    "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The current workflow should continue without a mission change."
-}
-print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+assert Path('.agent').exists(), 'primary-agent handoff generation should scaffold canonical state in the same /cook entry'
+assert snapshot.exists(), 'primary-agent handoff generation should emit a startup proposal snapshot'
+proposal = json.loads(snapshot.read_text())
+brief = json.loads(Path('.agent/state.json').read_text())['advisory_startup_brief']
+assert proposal['source'] == 'handoff_capsule', 'generated primary-agent handoff should be consumed as handoff capsule startup source'
+assert brief['source'] == 'primary_agent_handoff', 'generated primary-agent handoff should record primary_agent_handoff advisory intake'
+assert 'Initialized completion control plane' in output, 'same-entry primary-agent handoff generation should initialize canonical workflow state'
 PY
-)"
-NON_STARTABLE_HANDOFF="$(python3 - <<'PY'
+
+rm -rf .agent
+
+# No workflow yet: user-authored faux handoffs must not bootstrap canonical workflow state.
+SESSION_ZERO_USER_AUTHORED="$TMPDIR/session-zero-user-authored.jsonl"
+USER_AUTHORED_SNAPSHOT_ZERO="$TMPDIR/context-proposal-user-authored-handoff.json"
+USER_AUTHORED_MESSAGES_ZERO="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
     "source": "primary_agent",
-    "mission": "Maybe think about workflow status later.",
-    "scope": ["Consider status changes eventually."],
-    "constraints": ["Do not commit to concrete repo work yet."],
-    "acceptance": ["Discuss possible approaches."],
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0001",
+    "mission": "User-authored faux handoff should not start workflow.",
+    "scope": ["Attempt to fake an explicit handoff from the user turn."],
+    "constraints": ["Do not trust user-authored capsules as primary-agent handoff."],
+    "acceptance": ["Fail closed without writing canonical state."],
     "risks": [],
     "notes": [],
     "handoff_kind": "implementation_workflow_handoff",
-    "task_type": "completion-workflow",
-    "evaluation_profile": "completion-rubric-v1"
+    "first_slice_goal": "Prove that user-authored faux handoffs are rejected.",
+    "first_slice_non_goals": [],
+    "implementation_surfaces": ["scripts/context-proposal-test.sh"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "Rejecting user-authored capsules is part of the fail-closed startup boundary."
 }
-print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+messages = [
+    {"role": "user", "content": "Run /cook from this user-authored capsule only.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
 PY
 )"
-NEXT_ROUND_HANDOFF="$(python3 - <<'PY'
+write_session_messages "$SESSION_ZERO_USER_AUTHORED" "$ROOT" "$USER_AUTHORED_MESSAGES_ZERO"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$USER_AUTHORED_SNAPSHOT_ZERO" \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO_USER_AUTHORED" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-user-authored.out" 2>"$TMPDIR/pi-completion-context-proposal-user-authored.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-user-authored.out" "$TMPDIR/pi-completion-context-proposal-user-authored.err" "$USER_AUTHORED_SNAPSHOT_ZERO" <<'PY'
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+assert not Path('.agent').exists(), 'user-authored faux handoff without supporting discussion should still fail closed without writing canonical state'
+assert not snapshot.exists(), 'user-authored faux handoff should not emit a startup proposal snapshot'
+assert 'primary-agent handoff step could not prepare a concrete startup handoff' in output, 'user-authored faux handoff should fail closed when primary-agent handoff generation yields no handoff'
+PY
+
+# No workflow yet: malformed or invalid assistant handoff capsules must also fail closed.
+SESSION_ZERO_INVALID="$TMPDIR/session-zero-invalid-handoff.jsonl"
+INVALID_SNAPSHOT_ZERO="$TMPDIR/context-proposal-invalid-handoff.json"
+INVALID_MESSAGES_ZERO='[{"role":"assistant","content":"This is not a valid startup capsule.\n\n```cook_handoff\n{\"kind\":\"cook_handoff\",\"source\":\"primary_agent\",\"mission\":\"Broken JSON handoff\"\n```"}]'
+write_session_messages "$SESSION_ZERO_INVALID" "$ROOT" "$INVALID_MESSAGES_ZERO"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$INVALID_SNAPSHOT_ZERO" \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO_INVALID" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-invalid-handoff.out" 2>"$TMPDIR/pi-completion-context-proposal-invalid-handoff.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-invalid-handoff.out" "$TMPDIR/pi-completion-context-proposal-invalid-handoff.err" "$INVALID_SNAPSHOT_ZERO" <<'PY'
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+assert not Path('.agent').exists(), 'invalid assistant handoff without supporting discussion should fail closed without writing canonical state'
+assert not snapshot.exists(), 'invalid assistant handoff should not emit a startup proposal snapshot'
+assert 'primary-agent handoff step could not prepare a concrete startup handoff' in output, 'invalid assistant handoff should fail closed when no valid handoff can be prepared'
+PY
+
+# No workflow yet: a fresh explicit primary-agent handoff should still bootstrap canonical startup state.
+SESSION_ONE="$TMPDIR/session-one.jsonl"
+HANDOFF_SNAPSHOT_ONE="$TMPDIR/context-proposal-explicit-startup.json"
+HANDOFF_MESSAGES_ONE="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
     "source": "primary_agent",
-    "mission": "Start the next workflow round for widget follow-up docs.",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Remove the completion status line while keeping the completion widget.",
     "scope": [
-        "Document the widget-only status behavior for the next round.",
-        "Keep the next round confirm-first."
+        "Keep the non-running completion widget.",
+        "Suppress the widget while a completion role is active."
+    ],
+    "constraints": [
+        "Do not reintroduce any other completion status surface."
     ],
-    "constraints": ["Do not reopen the previous mission."],
     "acceptance": [
-        "Record the next round as a new canonical mission.",
-        "Keep startup-plan persistence truthful for the next round."
+        "Update README to match the shipped behavior.",
+        "Keep observability regression coverage truthful."
+    ],
+    "risks": [
+        "Stale widget-removal discussion could broaden the startup plan if the handoff is ignored."
+    ],
+    "notes": [
+        "Keep the startup brief aligned with the explicit primary-agent plan."
     ],
-    "risks": [],
-    "notes": [],
     "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Reset canonical state for the next widget-docs mission.",
-    "first_slice_non_goals": [],
-    "implementation_surfaces": ["README.md", ".agent/startup-plan.json"],
-    "verification_commands": ["npm run context-proposal-test"],
-    "why_this_slice_first": "The next round must be anchored before later slice derivation.",
+    "first_slice_goal": "Land the completion-status removal and keep the completion widget coverage truthful.",
+    "first_slice_non_goals": [
+        "Do not reintroduce any other completion status surface."
+    ],
+    "implementation_surfaces": [
+        "extensions/completion/index.ts",
+        "scripts/context-proposal-test.sh"
+    ],
+    "verification_commands": [
+        "npm run context-proposal-test"
+    ],
+    "why_this_slice_first": "The startup boundary regression is already bounded enough to implement safely.",
     "task_type": "completion-workflow",
     "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The previous workflow is done and the next round is concrete enough to start."
+    "why_cook_now": "The explicit startup brief is concrete and ready for repo changes."
 }
-print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+messages = [
+    {"role": "user", "content": "Please think through the completion widget startup boundary and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "This task is now ready for /cook. Run /cook to confirm the startup brief.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
 PY
 )"
+write_session_messages "$SESSION_ONE" "$ROOT" "$HANDOFF_MESSAGES_ONE"
 
-# Case 1: startup succeeds only through same-entry primary-agent synthesis.
-ROOT_ONE="$TMPDIR/repo-one"
-SESSION_ONE="$TMPDIR/session-one.jsonl"
-PROPOSAL_ONE="$TMPDIR/proposal-one.json"
-mkdir -p "$ROOT_ONE"
-cd "$ROOT_ONE"
-git init -q
-write_session "$SESSION_ONE" "$ROOT_ONE" "$STARTUP_DISCUSSION"
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$STARTUP_HANDOFF" \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_ONE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_ONE" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/startup-success.out" 2>"$TMPDIR/startup-success.err"
+pi --session "$SESSION_ONE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-explicit-startup.out" 2>"$TMPDIR/pi-completion-context-proposal-explicit-startup.err"
 
-python3 - "$PROPOSAL_ONE" "$TMPDIR/startup-success.out" "$TMPDIR/startup-success.err" <<'PY'
+python3 - "$HANDOFF_SNAPSHOT_ONE" <<'PY'
 import json
 import sys
 from pathlib import Path
 
+mission = 'Remove the completion status line while keeping the completion widget.'
+expected_task_type = 'completion-workflow'
+expected_eval_profile = 'completion-rubric-v1'
+mission_text = Path('.agent/mission.md').read_text()
+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())
 proposal = json.loads(Path(sys.argv[1]).read_text())
-output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+
+assert mission in mission_text, '.agent/mission.md did not record the explicit-handoff mission anchor'
+assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after explicit-handoff bootstrap'
+assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after explicit-handoff bootstrap'
+assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after explicit-handoff bootstrap'
+assert state['task_type'] == expected_task_type, 'state.json task_type mismatch after explicit-handoff bootstrap'
+assert state['evaluation_profile'] == expected_eval_profile, 'state.json evaluation_profile mismatch after explicit-handoff bootstrap'
+assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after explicit-handoff bootstrap'
+assert plan['task_type'] == expected_task_type, 'plan.json task_type mismatch after explicit-handoff bootstrap'
+assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluation_profile mismatch after explicit-handoff bootstrap'
+assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after explicit-handoff bootstrap'
+assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after explicit-handoff bootstrap'
+assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after explicit-handoff bootstrap'
+brief = state['advisory_startup_brief']
+assert brief['kind'] == 'startup_brief', 'state.json should preserve the confirmed startup brief as advisory intake'
+assert brief['source'] == 'primary_agent_handoff', 'explicit startup should record the handoff source in advisory intake'
+assert brief['mission'] == mission, 'advisory startup brief mission should match the accepted mission anchor'
+assert brief['scope'] == ['Keep the non-running completion widget.', 'Suppress the widget while a completion role is active.'], 'advisory startup brief should preserve scope items separately from canonical planning state'
+assert brief['constraints'] == ['Do not reintroduce any other completion status surface.'], 'advisory startup brief should preserve constraints separately from canonical planning state'
+assert brief['acceptance'] == ['Update README to match the shipped behavior.', 'Keep observability regression coverage truthful.'], 'advisory startup brief should preserve acceptance separately from canonical planning state'
+assert brief['risks'] == ['Stale widget-removal discussion could broaden the startup plan if the handoff is ignored.'], 'advisory startup brief should preserve handoff risks'
+assert 'First slice goal: Land the completion-status removal and keep the completion widget coverage truthful.' in brief['notes'], 'advisory startup brief should preserve first_slice_goal in notes'
+assert 'Verification commands: npm run context-proposal-test' in brief['notes'], 'advisory startup brief should preserve verification_commands in notes'
+assert plan['candidate_slices'] == [], 'startup brief should remain advisory intake only until regrounder owns plan selection'
+assert active['status'] == 'idle', 'startup brief should not become the active-slice source before regrounder runs'
+assert proposal['mission'] == mission, 'explicit startup proposal snapshot should keep the handoff mission anchor'
+assert proposal['source'] == 'handoff_capsule', 'explicit startup proposal snapshot should expose the handoff capsule source'
+assert proposal['analysis']['taskType'] == expected_task_type, 'explicit startup proposal snapshot should expose task_type hints separately'
+assert proposal['analysis']['evaluationProfile'] == expected_eval_profile, 'explicit startup proposal snapshot should expose evaluation_profile hints separately'
+assert state['current_phase'] == 'reground', 'state.json current_phase should start at reground after explicit-handoff bootstrap'
+assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should start at completion-regrounder after explicit-handoff bootstrap'
+assert state['continuation_reason'].startswith('User started workflow via /cook:'), 'initial startup should record the accepted startup routing in continuation_reason'
+assert 'task_type=completion-workflow' in state['continuation_reason'], 'initial startup should persist the selected task_type in continuation_reason'
+assert 'evaluation_profile=completion-rubric-v1' in state['continuation_reason'], 'initial startup should persist the selected evaluation_profile in continuation_reason'
+PY
+
+# Active workflow: bare /cook should resume from canonical state when no fresh explicit handoff exists,
+# even if recent discussion restates the current mission in a structured way.
+SESSION_ONE_CONTINUE="$TMPDIR/session-one-continue.jsonl"
+DISCUSSION_ONE_CONTINUE=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the current mission focused on the non-running completion widget.\nConstraints:\n- Do not start a different workflow from this discussion.\nAcceptance:\n- Resume the current workflow from canonical state without rewriting it.'
+CONTINUE_ROUTING_ONE="$TMPDIR/active-continue-routing.json"
+CONTINUE_RESUME_PROMPT_ONE="$TMPDIR/active-continue-resume.txt"
+CONTINUE_CHOOSER_ONE="$TMPDIR/unexpected-active-continue-chooser.json"
+CONTINUE_PROPOSAL_ONE="$TMPDIR/unexpected-active-continue-proposal.json"
+write_session "$SESSION_ONE_CONTINUE" "$ROOT" "$DISCUSSION_ONE_CONTINUE"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$CONTINUE_ROUTING_ONE" \
+PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$CONTINUE_RESUME_PROMPT_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CONTINUE_CHOOSER_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$CONTINUE_PROPOSAL_ONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ONE_CONTINUE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-continue.out" 2>"$TMPDIR/pi-completion-context-proposal-active-continue.err"
+
+python3 - "$CONTINUE_ROUTING_ONE" "$CONTINUE_RESUME_PROMPT_ONE" "$CONTINUE_CHOOSER_ONE" "$CONTINUE_PROPOSAL_ONE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Remove the completion status line while keeping the completion widget.'
+routing = json.loads(Path(sys.argv[1]).read_text())
+resume = Path(sys.argv[2]).read_text()
+chooser_path = Path(sys.argv[3])
+proposal_path = Path(sys.argv[4])
 state = json.loads(Path('.agent/state.json').read_text())
-startup_plan = json.loads(Path('.agent/startup-plan.json').read_text())
+plan = json.loads(Path('.agent/plan.json').read_text())
+active = json.loads(Path('.agent/active-slice.json').read_text())
 
-assert Path('.agent').exists(), 'same-entry primary-agent synthesis should scaffold canonical workflow state'
-assert proposal['source'] == 'deferred_primary_agent_handoff', proposal
-assert state['advisory_startup_brief']['source'] == 'deferred_primary_agent_handoff', state
-assert startup_plan['source'] == 'deferred_primary_agent_handoff', startup_plan
-assert 'Initialized completion control plane' in output, output
+assert routing['mode'] == 'bare', 'active bare /cook resume regression should snapshot bare routing mode'
+assert 'explicitGoal' not in routing, 'active bare /cook resume routing should not expose removed explicit-goal shim fields'
+assert 'explicitGoalProvided' not in routing, 'active bare /cook resume routing should not expose removed explicit-goal shim fields'
+assert routing['action'] == 'continue', 'active bare /cook should resume when no fresh explicit handoff exists'
+assert routing['reason'] == 'missing_explicit_handoff', 'active bare /cook should explain that resume happened because no fresh explicit handoff existed'
+assert routing['currentMissionAnchor'] == mission, 'resume routing should preserve the current mission anchor'
+assert routing['proposedMissionAnchor'] is None, 'resume routing should not derive a replacement mission from recent discussion'
+assert 'Resume the completion workflow from canonical state.' in resume, 'active bare /cook resume should still use the canonical resume prompt'
+assert not chooser_path.exists(), 'active bare /cook resume should not open the replacement chooser without a fresh explicit handoff'
+assert not proposal_path.exists(), 'active bare /cook resume should not open replacement proposal confirmation without a fresh explicit handoff'
+assert state['mission_anchor'] == mission, 'active bare /cook resume should keep state.json unchanged'
+assert plan['mission_anchor'] == mission, 'active bare /cook resume should keep plan.json unchanged'
+assert active['mission_anchor'] == mission, 'active bare /cook resume should keep active-slice.json unchanged'
 PY
 
-# Case 2: assistant preview alone is ignored when same-entry synthesis is unavailable.
-ROOT_TWO="$TMPDIR/repo-two"
-SESSION_TWO="$TMPDIR/session-two.jsonl"
-PROPOSAL_TWO="$TMPDIR/proposal-two.json"
-mkdir -p "$ROOT_TWO"
-cd "$ROOT_TWO"
-git init -q
-PREVIEW_MESSAGES="$(python3 - <<'PY'
+# Active workflow: even strongly different recent discussion should no longer open chooser/refocus startup
+# when no fresh valid explicit handoff is present.
+SESSION_ONE_DISCUSSION_REFOCUS="$TMPDIR/session-one-discussion-refocus.jsonl"
+DISCUSSION_ONE_DISCUSSION_REFOCUS=$'Mission: Normalize bare /cook planning phrasing into implementation-result missions.\nScope:\n- Replace the current workflow from recent discussion only.\n- Keep the approval-only Start/Cancel gate before rewriting canonical state.\nConstraints:\n- Do not require a fresh explicit handoff.\nAcceptance:\n- Rewrite canonical state from recent discussion.'
+DISCUSSION_REFOCUS_ROUTING_ONE="$TMPDIR/active-discussion-refocus-routing.json"
+DISCUSSION_REFOCUS_RESUME_ONE="$TMPDIR/active-discussion-refocus-resume.txt"
+DISCUSSION_REFOCUS_CHOOSER_ONE="$TMPDIR/unexpected-active-discussion-refocus-chooser.json"
+DISCUSSION_REFOCUS_PROPOSAL_ONE="$TMPDIR/unexpected-active-discussion-refocus-proposal.json"
+write_session "$SESSION_ONE_DISCUSSION_REFOCUS" "$ROOT" "$DISCUSSION_ONE_DISCUSSION_REFOCUS"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$DISCUSSION_REFOCUS_ROUTING_ONE" \
+PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$DISCUSSION_REFOCUS_RESUME_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$DISCUSSION_REFOCUS_CHOOSER_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_REFOCUS_PROPOSAL_ONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ONE_DISCUSSION_REFOCUS" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-discussion-refocus.out" 2>"$TMPDIR/pi-completion-context-proposal-active-discussion-refocus.err"
+
+python3 - "$DISCUSSION_REFOCUS_ROUTING_ONE" "$DISCUSSION_REFOCUS_RESUME_ONE" "$DISCUSSION_REFOCUS_CHOOSER_ONE" "$DISCUSSION_REFOCUS_PROPOSAL_ONE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Remove the completion status line while keeping the completion widget.'
+routing = json.loads(Path(sys.argv[1]).read_text())
+resume = Path(sys.argv[2]).read_text()
+chooser_path = Path(sys.argv[3])
+proposal_path = Path(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 routing['mode'] == 'bare', 'discussion-driven refocus removal should snapshot bare routing mode'
+assert routing['action'] == 'continue', 'bare /cook should resume instead of deriving a replacement workflow from recent discussion'
+assert routing['reason'] == 'missing_explicit_handoff', 'discussion-driven refocus removal should explain that no fresh explicit handoff existed'
+assert routing['currentMissionAnchor'] == mission, 'discussion-driven refocus removal should preserve the current mission anchor'
+assert routing['proposedMissionAnchor'] is None, 'discussion-driven refocus removal should not preserve a replacement mission from recent discussion'
+assert 'Resume the completion workflow from canonical state.' in resume, 'discussion-driven refocus removal should still queue the canonical resume prompt'
+assert not chooser_path.exists(), 'discussion-driven refocus removal should not open the chooser'
+assert not proposal_path.exists(), 'discussion-driven refocus removal should not open final proposal confirmation'
+assert state['mission_anchor'] == mission, 'discussion-driven refocus removal should keep state.json unchanged'
+assert plan['mission_anchor'] == mission, 'discussion-driven refocus removal should keep plan.json unchanged'
+assert active['mission_anchor'] == mission, 'discussion-driven refocus removal should keep active-slice.json unchanged'
+PY
+
+# Active workflow: summary-only replacement artifacts should also resume the current workflow when no fresh
+# explicit handoff exists.
+SESSION_ONE_SUMMARY_ONLY="$TMPDIR/session-one-summary-only.jsonl"
+SUMMARY_ROUTING_ONE="$TMPDIR/active-summary-only-routing.json"
+SUMMARY_RESUME_PROMPT_ONE="$TMPDIR/active-summary-only-resume.txt"
+SUMMARY_CHOOSER_ONE="$TMPDIR/unexpected-active-summary-only-chooser.json"
+SUMMARY_PROPOSAL_ONE="$TMPDIR/unexpected-active-summary-only-proposal.json"
+python3 - "$SESSION_ONE_SUMMARY_ONLY" "$ROOT" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+session_path = Path(sys.argv[1])
+cwd = sys.argv[2]
+session_path.parent.mkdir(parents=True, exist_ok=True)
+entries = [
+    {
+        "type": "session",
+        "version": 3,
+        "id": "11111111-1111-4111-8111-111111111111",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "cwd": cwd,
+    },
+    {
+        "type": "message",
+        "id": "c3d4e5f6",
+        "parentId": None,
+        "timestamp": "2026-01-01T00:00:03.000Z",
+        "message": {
+            "role": "branchSummary",
+            "summary": "Mission: Replace the current workflow from the completed plan summary.\nScope:\n- Refocus to a different mission from this summary artifact alone.\nConstraints:\n- Keep the approval-only Start/Cancel gate unchanged.\nAcceptance:\n- Rewrite canonical state from the summary without new user discussion.",
+        },
+    },
+]
+with session_path.open('w', encoding='utf-8') as fh:
+    for entry in entries:
+        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+PY
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$SUMMARY_ROUTING_ONE" \
+PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$SUMMARY_RESUME_PROMPT_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$SUMMARY_CHOOSER_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$SUMMARY_PROPOSAL_ONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ONE_SUMMARY_ONLY" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-summary-only.out" 2>"$TMPDIR/pi-completion-context-proposal-active-summary-only.err"
+
+python3 - "$SUMMARY_ROUTING_ONE" "$SUMMARY_RESUME_PROMPT_ONE" "$SUMMARY_CHOOSER_ONE" "$SUMMARY_PROPOSAL_ONE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Remove the completion status line while keeping the completion widget.'
+routing = json.loads(Path(sys.argv[1]).read_text())
+resume = Path(sys.argv[2]).read_text()
+chooser_path = Path(sys.argv[3])
+proposal_path = Path(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 routing['mode'] == 'bare', 'summary-only active bare /cook regression should snapshot bare routing mode'
+assert routing['action'] == 'continue', 'summary-only active bare /cook should resume rather than derive replacement startup'
+assert routing['reason'] == 'missing_explicit_handoff', 'summary-only active bare /cook should explain that no fresh explicit handoff existed'
+assert routing['currentMissionAnchor'] == mission, 'summary-only active bare /cook should preserve the current mission anchor'
+assert routing['proposedMissionAnchor'] is None, 'summary-only active bare /cook should not derive a replacement mission from summary artifacts alone'
+assert 'Resume the completion workflow from canonical state.' in resume, 'summary-only active bare /cook should still resume the canonical workflow'
+assert not chooser_path.exists(), 'summary-only active bare /cook should not open the refocus chooser'
+assert not proposal_path.exists(), 'summary-only active bare /cook should not open replacement proposal confirmation'
+assert state['mission_anchor'] == mission, 'summary-only active bare /cook should keep state.json unchanged'
+assert plan['mission_anchor'] == mission, 'summary-only active bare /cook should keep plan.json unchanged'
+assert active['mission_anchor'] == mission, 'summary-only active bare /cook should keep active-slice.json unchanged'
+PY
+
+# Active workflow: a fresh explicit handoff that is not implementation-startable should still fail closed
+# without rewriting canonical state.
+SESSION_ONE_NON_STARTABLE_ACTIVE="$TMPDIR/session-one-non-startable-active.jsonl"
+NON_STARTABLE_ACTIVE_ROUTING="$TMPDIR/active-non-startable-routing.json"
+NON_STARTABLE_ACTIVE_RESUME="$TMPDIR/unexpected-active-non-startable-resume.txt"
+NON_STARTABLE_ACTIVE_CHOOSER="$TMPDIR/unexpected-active-non-startable-chooser.json"
+NON_STARTABLE_ACTIVE_PROPOSAL="$TMPDIR/unexpected-active-non-startable-proposal.json"
+NON_STARTABLE_ACTIVE_MESSAGES="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
     "source": "primary_agent",
     "captured_at": "2026-01-01T00:00:02.000Z",
     "source_turn_id": "m0002",
-    "mission": "Assistant preview should not start workflow by itself.",
-    "scope": ["Do not trust the old preview as approval-ready startup state."],
-    "constraints": ["Require same-entry synthesis."],
-    "acceptance": ["Fail closed without canonical state."],
+    "mission": "Replace the current widget mission from a vague explicit handoff.",
+    "scope": [
+        "Replace the active workflow from a fresh explicit handoff."
+    ],
+    "constraints": [
+        "Do not rely on recent discussion to fill in missing implementation details."
+    ],
+    "acceptance": [
+        "Current behavior stays understandable."
+    ],
     "risks": [],
-    "notes": [],
+    "notes": [
+        "This capsule is intentionally non-startable for active-workflow fail-closed coverage."
+    ],
     "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Prove preview-only startup is ignored.",
+    "first_slice_goal": "Attempt to replace the active workflow from a vague capsule.",
     "first_slice_non_goals": [],
-    "implementation_surfaces": ["scripts/context-proposal-test.sh"],
-    "verification_commands": ["npm run context-proposal-test"],
-    "why_this_slice_first": "Preview-only startup should no longer bootstrap workflow by itself."
+    "implementation_surfaces": [
+        "extensions/completion/driver.ts"
+    ],
+    "verification_commands": [
+        "npm run context-proposal-test"
+    ],
+    "why_this_slice_first": "Active-workflow replacement should fail closed when the capsule is fresh but not startable.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1"
 }
 messages = [
-    {"role": "user", "content": "Should this preview be enough to start workflow on its own?"},
-    {"role": "assistant", "content": "Preview only.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+    {"role": "user", "content": "We may need a different active workflow, but only if there is a fresh explicit handoff."},
+    {"role": "assistant", "content": "Only use this capsule if it is concrete enough.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
 ]
 print(json.dumps(messages, ensure_ascii=False))
 PY
 )"
-write_session_messages "$SESSION_TWO" "$ROOT_TWO" "$PREVIEW_MESSAGES"
-PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_TWO" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_TWO" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/preview-ignored.out" 2>"$TMPDIR/preview-ignored.err"
+write_session_messages "$SESSION_ONE_NON_STARTABLE_ACTIVE" "$ROOT" "$NON_STARTABLE_ACTIVE_MESSAGES"
 
-python3 - "$PROPOSAL_TWO" "$TMPDIR/preview-ignored.out" "$TMPDIR/preview-ignored.err" <<'PY'
+python3 - "$TMPDIR/active-non-startable-before.json" <<'PY'
+import json
 import sys
 from pathlib import Path
-
-proposal = Path(sys.argv[1])
-output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
-
-assert not Path('.agent').exists(), 'preview-only startup must fail closed without same-entry synthesis'
-assert not proposal.exists(), 'preview-only startup must not emit a proposal snapshot'
-assert '/cook failed closed because the startup-plan step could not prepare a concrete workflow startup plan from the current task context.' in output, output
+tracked = {
+    'mission.md': Path('.agent/mission.md').read_text(),
+    'profile.json': Path('.agent/profile.json').read_text(),
+    'state.json': Path('.agent/state.json').read_text(),
+    'plan.json': Path('.agent/plan.json').read_text(),
+    'active-slice.json': Path('.agent/active-slice.json').read_text(),
+    'verification-evidence.json': Path('.agent/verification-evidence.json').read_text(),
+}
+Path(sys.argv[1]).write_text(json.dumps(tracked, indent=2) + '\n')
 PY
 
-# Case 3: structured discussion alone no longer falls back when synthesis is unavailable.
-ROOT_THREE="$TMPDIR/repo-three"
-SESSION_THREE="$TMPDIR/session-three.jsonl"
-PROPOSAL_THREE="$TMPDIR/proposal-three.json"
-mkdir -p "$ROOT_THREE"
-cd "$ROOT_THREE"
-git init -q
-DISCUSSION_THREE=$'Mission: Rewrite startup flow from structured discussion only.\nScope:\n- Do not run same-entry synthesis.\nAcceptance:\n- Pretend transcript inference is enough.'
-write_session "$SESSION_THREE" "$ROOT_THREE" "$DISCUSSION_THREE"
-PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_THREE" \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$NON_STARTABLE_ACTIVE_ROUTING" \
+PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$NON_STARTABLE_ACTIVE_RESUME" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$NON_STARTABLE_ACTIVE_CHOOSER" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$NON_STARTABLE_ACTIVE_PROPOSAL" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_THREE" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/discussion-ignored.out" 2>"$TMPDIR/discussion-ignored.err"
+pi --session "$SESSION_ONE_NON_STARTABLE_ACTIVE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-non-startable.out" 2>"$TMPDIR/pi-completion-context-proposal-active-non-startable.err"
 
-python3 - "$PROPOSAL_THREE" "$TMPDIR/discussion-ignored.out" "$TMPDIR/discussion-ignored.err" <<'PY'
+python3 - "$NON_STARTABLE_ACTIVE_ROUTING" "$NON_STARTABLE_ACTIVE_RESUME" "$NON_STARTABLE_ACTIVE_CHOOSER" "$NON_STARTABLE_ACTIVE_PROPOSAL" "$TMPDIR/pi-completion-context-proposal-active-non-startable.out" "$TMPDIR/pi-completion-context-proposal-active-non-startable.err" "$TMPDIR/active-non-startable-before.json" <<'PY'
+import json
 import sys
 from pathlib import Path
 
-proposal = Path(sys.argv[1])
-output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+routing = json.loads(Path(sys.argv[1]).read_text())
+resume_path = Path(sys.argv[2])
+chooser_path = Path(sys.argv[3])
+proposal_path = Path(sys.argv[4])
+output = Path(sys.argv[5]).read_text() + Path(sys.argv[6]).read_text()
+before = json.loads(Path(sys.argv[7]).read_text())
+after = {
+    'mission.md': Path('.agent/mission.md').read_text(),
+    'profile.json': Path('.agent/profile.json').read_text(),
+    'state.json': Path('.agent/state.json').read_text(),
+    'plan.json': Path('.agent/plan.json').read_text(),
+    'active-slice.json': Path('.agent/active-slice.json').read_text(),
+    'verification-evidence.json': Path('.agent/verification-evidence.json').read_text(),
+}
 
-assert not Path('.agent').exists(), 'structured discussion alone must fail closed without same-entry synthesis'
-assert not proposal.exists(), 'structured discussion alone must not emit a proposal snapshot'
-assert '/cook failed closed because the startup-plan step could not prepare a concrete workflow startup plan from the current task context.' in output, output
+assert routing['mode'] == 'bare', 'fresh non-startable explicit handoff should snapshot bare routing mode'
+assert routing['action'] == 'blocked', 'fresh non-startable explicit handoff should fail closed for active bare /cook'
+assert routing['reason'] == 'fresh_explicit_handoff_not_startable', 'fresh non-startable explicit handoff should keep the dedicated explicit-handoff fail-closed reason'
+assert 'fresh explicit primary-agent handoff exists' in routing['blockedFailureMessage'], 'fresh non-startable explicit handoff should surface the dedicated fail-closed message'
+assert 'acceptance is not anchored to concrete repo changes or verification' in routing['blockedFailureMessage'], 'fresh non-startable explicit handoff should explain why the capsule is not startable'
+assert not resume_path.exists(), 'fresh non-startable explicit handoff should not queue a resume prompt'
+assert not chooser_path.exists(), 'fresh non-startable explicit handoff should not open the replacement chooser'
+assert not proposal_path.exists(), 'fresh non-startable explicit handoff should not open final proposal confirmation'
+assert 'fresh explicit primary-agent handoff exists' in output, 'fresh non-startable explicit handoff should explain that the explicit capsule blocked active-workflow replacement'
+assert before == after, 'fresh non-startable explicit handoff should leave canonical state unchanged'
 PY
 
-# Case 4: non-startable synthesized startup plans fail closed with the dedicated same-entry message.
-ROOT_FOUR="$TMPDIR/repo-four"
-SESSION_FOUR="$TMPDIR/session-four.jsonl"
-PROPOSAL_FOUR="$TMPDIR/proposal-four.json"
-mkdir -p "$ROOT_FOUR"
-cd "$ROOT_FOUR"
-git init -q
-write_session "$SESSION_FOUR" "$ROOT_FOUR" "$STARTUP_DISCUSSION"
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$NON_STARTABLE_HANDOFF" \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_FOUR" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_FOUR" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/non-startable-startup.out" 2>"$TMPDIR/non-startable-startup.err"
+# Completed workflow: bare /cook should suppress proposals that simply restate the completed mission
+# without a clear reopen or next-round signal.
+mark_done
 
-python3 - "$PROPOSAL_FOUR" "$TMPDIR/non-startable-startup.out" "$TMPDIR/non-startable-startup.err" <<'PY'
-import sys
+SESSION_TWO_COMPLETED_SUPPRESS="$TMPDIR/session-two-completed-suppress.jsonl"
+CURRENT_DONE_MISSION="$(python3 - <<'PY'
+import json
 from pathlib import Path
+print(json.loads(Path('.agent/state.json').read_text())['mission_anchor'])
+PY
+)"
+DISCUSSION_TWO_COMPLETED_SUPPRESS="Mission: ${CURRENT_DONE_MISSION}
+Scope:
+- Keep the current completed mission exactly as-is.
+Constraints:
+- Do not start a different workflow from this discussion.
+Acceptance:
+- Keep the finished mission closed and unchanged."
+DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS="$TMPDIR/context-proposal-next-round-completed-suppress.json"
+write_session "$SESSION_TWO_COMPLETED_SUPPRESS" "$ROOT" "$DISCUSSION_TWO_COMPLETED_SUPPRESS"
 
-proposal = Path(sys.argv[1])
-output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
-
-assert not Path('.agent').exists(), 'non-startable synthesized startup must fail closed'
-assert not proposal.exists(), 'non-startable synthesized startup must not emit a proposal snapshot'
-assert 'same-entry primary-agent startup-plan synthesis step returned a startup plan that is still not concrete enough' in output, output
-assert 'acceptance is not anchored to concrete repo changes or verification' in output, output
-PY
-
-# Case 5: active workflow resumes when same-entry synthesis matches the current mission.
-ROOT_FIVE="$TMPDIR/repo-five"
-SESSION_FIVE_BOOTSTRAP="$TMPDIR/session-five-bootstrap.jsonl"
-SESSION_FIVE_MATCHING="$TMPDIR/session-five-matching.jsonl"
-ROUTING_FIVE="$TMPDIR/routing-five.json"
-CHOOSER_FIVE="$TMPDIR/chooser-five.json"
-BASELINE_FIVE="$TMPDIR/baseline-five.json"
-bootstrap_workflow "$ROOT_FIVE" "$SESSION_FIVE_BOOTSTRAP" "$STARTUP_DISCUSSION" "$STARTUP_HANDOFF"
-cd "$ROOT_FIVE"
-snapshot_tracked "$BASELINE_FIVE"
-write_session "$SESSION_FIVE_MATCHING" "$ROOT_FIVE" $'Continue the widget mission and keep the workflow aligned.'
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$MATCHING_HANDOFF" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_FIVE" \
-PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_FIVE" \
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_FIVE_MATCHING" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/matching-active.out" 2>"$TMPDIR/matching-active.err"
+pi --session "$SESSION_TWO_COMPLETED_SUPPRESS" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.err"
 
-python3 - "$ROUTING_FIVE" "$CHOOSER_FIVE" "$BASELINE_FIVE" <<'PY'
+python3 - "$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.out" "$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.err" "$DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS" "$CURRENT_DONE_MISSION" <<'PY'
 import json
 import sys
 from pathlib import Path
 
-routing = json.loads(Path(sys.argv[1]).read_text())
-chooser = Path(sys.argv[2])
-before = json.loads(Path(sys.argv[3]).read_text())
-tracked = [
-    Path('.agent/mission.md'),
-    Path('.agent/profile.json'),
-    Path('.agent/state.json'),
-    Path('.agent/startup-plan.json'),
-    Path('.agent/startup-plan.md'),
-    Path('.agent/plan.json'),
-    Path('.agent/active-slice.json'),
-    Path('.agent/verification-evidence.json'),
-]
-after = {path.name: path.read_text() for path in tracked}
-state = json.loads(after['state.json'])
-
-assert routing['action'] == 'continue', routing
-assert routing['reason'] == 'matching_generated_startup_plan', routing
-assert routing['currentMissionAnchor'] == state['mission_anchor'], routing
-assert routing['proposedMissionAnchor'] == state['mission_anchor'], routing
-assert not chooser.exists(), 'matching synthesized mission should not open the chooser'
-assert before == after, 'matching synthesized mission should leave canonical state unchanged before resume'
-PY
-
-# Case 6: non-startable synthesized active replacement blocks without rewriting canonical state.
-ROOT_SIX="$TMPDIR/repo-six"
-SESSION_SIX_BOOTSTRAP="$TMPDIR/session-six-bootstrap.jsonl"
-SESSION_SIX_BLOCKED="$TMPDIR/session-six-blocked.jsonl"
-ROUTING_SIX="$TMPDIR/routing-six.json"
-CHOOSER_SIX="$TMPDIR/chooser-six.json"
-PROPOSAL_SIX="$TMPDIR/proposal-six.json"
-BASELINE_SIX="$TMPDIR/baseline-six.json"
-bootstrap_workflow "$ROOT_SIX" "$SESSION_SIX_BOOTSTRAP" "$STARTUP_DISCUSSION" "$STARTUP_HANDOFF"
-cd "$ROOT_SIX"
-snapshot_tracked "$BASELINE_SIX"
-write_session "$SESSION_SIX_BLOCKED" "$ROOT_SIX" $'Maybe replace the current mission, but the new intent is still vague.'
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$NON_STARTABLE_HANDOFF" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_SIX" \
-PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_SIX" \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_SIX" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_SIX_BLOCKED" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/blocked-active.out" 2>"$TMPDIR/blocked-active.err"
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+expected = sys.argv[4]
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert state['mission_anchor'] == expected, 'completed-topic suppression should keep the done workflow mission anchor unchanged'
+assert state['continuation_policy'] == 'done', 'completed-topic suppression should keep the workflow closed'
+assert not snapshot.exists(), 'completed-topic suppression should not emit a proposal snapshot when the latest discussion only repeats finished work'
+assert 'primary-agent handoff step could not prepare a concrete startup handoff' in output, 'completed-topic suppression should fail closed when no concrete primary-agent handoff can be prepared'
+PY
 
-python3 - "$ROUTING_SIX" "$CHOOSER_SIX" "$PROPOSAL_SIX" "$BASELINE_SIX" "$TMPDIR/blocked-active.out" "$TMPDIR/blocked-active.err" <<'PY'
+# Completed workflow: bare /cook should also suppress proposals that merely restate canonical
+# verification evidence for already verified work.
+python3 - <<'PY'
 import json
-import sys
 from pathlib import Path
 
-routing = json.loads(Path(sys.argv[1]).read_text())
-chooser = Path(sys.argv[2])
-proposal = Path(sys.argv[3])
-before = json.loads(Path(sys.argv[4]).read_text())
-output = Path(sys.argv[5]).read_text() + Path(sys.argv[6]).read_text()
-tracked = [
-    Path('.agent/mission.md'),
-    Path('.agent/profile.json'),
-    Path('.agent/state.json'),
-    Path('.agent/startup-plan.json'),
-    Path('.agent/startup-plan.md'),
-    Path('.agent/plan.json'),
-    Path('.agent/active-slice.json'),
-    Path('.agent/verification-evidence.json'),
-]
-after = {path.name: path.read_text() for path in tracked}
+state = json.loads(Path('.agent/state.json').read_text())
+state['latest_verified_slice'] = 'verified-logout-redirect'
+Path('.agent/state.json').write_text(json.dumps(state, indent=2) + '\n')
+
+evidence = json.loads(Path('.agent/verification-evidence.json').read_text())
+evidence.update({
+    'subject_type': 'selected_slice',
+    'slice_id': 'verified-logout-redirect',
+    'goal': 'Add logout redirect regression coverage.',
+    'summary': 'Verified logout redirect regression coverage already matches the selected slice and current HEAD.',
+    'outcome': 'pass',
+})
+Path('.agent/verification-evidence.json').write_text(json.dumps(evidence, indent=2) + '\n')
+PY
+
+SESSION_TWO_VERIFIED_SUPPRESS="$TMPDIR/session-two-verified-suppress.jsonl"
+DISCUSSION_TWO_VERIFIED_SUPPRESS=$'Mission: Add logout redirect regression coverage.\nScope:\n- Add coverage for logout redirect behavior.\nConstraints:\n- Do not change the verified logout redirect work.\nAcceptance:\n- Keep the verified logout redirect regression coverage unchanged.'
+DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS="$TMPDIR/context-proposal-next-round-verified-suppress.json"
+write_session "$SESSION_TWO_VERIFIED_SUPPRESS" "$ROOT" "$DISCUSSION_TWO_VERIFIED_SUPPRESS"
 
-assert routing['action'] == 'blocked', routing
-assert routing['reason'] == 'generated_startup_plan_not_startable', routing
-assert 'same-entry primary-agent startup-plan synthesis step returned a startup plan that is still not concrete enough' in routing['blockedFailureMessage'], routing
-assert not chooser.exists(), 'blocked replacement should not open the chooser'
-assert not proposal.exists(), 'blocked replacement should not open final proposal confirmation'
-assert before == after, 'blocked replacement should leave canonical state unchanged'
-assert 'same-entry primary-agent startup-plan synthesis step returned a startup plan that is still not concrete enough' in output, output
-PY
-
-# Case 7: done workflow starts the next round from same-entry synthesis.
-ROOT_SEVEN="$TMPDIR/repo-seven"
-SESSION_SEVEN_BOOTSTRAP="$TMPDIR/session-seven-bootstrap.jsonl"
-SESSION_SEVEN_NEXT="$TMPDIR/session-seven-next.jsonl"
-PROPOSAL_SEVEN="$TMPDIR/proposal-seven.json"
-bootstrap_workflow "$ROOT_SEVEN" "$SESSION_SEVEN_BOOTSTRAP" "$STARTUP_DISCUSSION" "$STARTUP_HANDOFF"
-cd "$ROOT_SEVEN"
-mark_done
-write_session "$SESSION_SEVEN_NEXT" "$ROOT_SEVEN" $'Start the next workflow round for widget follow-up docs.'
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$NEXT_ROUND_HANDOFF" \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_SEVEN" \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_SEVEN_NEXT" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/next-round.out" 2>"$TMPDIR/next-round.err"
+pi --session "$SESSION_TWO_VERIFIED_SUPPRESS" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.err"
 
-python3 - "$PROPOSAL_SEVEN" "$TMPDIR/next-round.out" "$TMPDIR/next-round.err" <<'PY'
-import json
+python3 - "$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.out" "$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.err" "$DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS" <<'PY'
 import sys
 from pathlib import Path
 
-proposal = json.loads(Path(sys.argv[1]).read_text())
-output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
-state = json.loads(Path('.agent/state.json').read_text())
-startup_plan = json.loads(Path('.agent/startup-plan.json').read_text())
-plan = json.loads(Path('.agent/plan.json').read_text())
-active = json.loads(Path('.agent/active-slice.json').read_text())
-mission = 'Start the next workflow round for widget follow-up docs.'
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+assert not snapshot.exists(), 'verification-evidence overlap suppression should not emit a proposal snapshot for already verified work'
+assert 'primary-agent handoff step could not prepare a concrete startup handoff' in output, 'verification-evidence overlap suppression should fail closed when no concrete primary-agent handoff can be prepared'
+PY
+
+# Completed workflow: bare /cook should fail closed for next-round discussion-only startup too,
+# even when the discussion is well structured.
+SESSION_TWO_NORMALIZED="$TMPDIR/session-two-normalized.jsonl"
+DISCUSSION_TWO_NORMALIZED=$'Mission: 開始實作這個方案\nScope:\n- Normalize bare /cook planning phrasing for the next workflow round.\n- Reset canonical state for the new implementation mission.\nConstraints:\n- Do not resume the completed workflow when the new round is clearly different.\nAcceptance:\n- Start a new round with the normalized mission anchor.'
+DISCUSSION_SNAPSHOT_TWO_NORMALIZED="$TMPDIR/context-proposal-next-round-normalized.json"
+write_session "$SESSION_TWO_NORMALIZED" "$ROOT" "$DISCUSSION_TWO_NORMALIZED"
+
+GENERATED_HANDOFF_TWO_NORMALIZED="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "mission": "Start the next workflow round with a normalized implementation mission.",
+    "scope": [
+        "Reset canonical state for the new implementation mission.",
+        "Keep the next round distinct from the completed workflow."
+    ],
+    "constraints": [
+        "Do not resume the completed workflow when the new round is clearly different."
+    ],
+    "acceptance": [
+        "Reset canonical state back to reground for the new mission.",
+        "Preserve the tracked completion control-plane files."
+    ],
+    "risks": [],
+    "notes": ["Generated by the primary-agent handoff step triggered from /cook."],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Bootstrap the next workflow round from the normalized implementation mission.",
+    "first_slice_non_goals": ["Do not reopen finished slices from the previous workflow."],
+    "implementation_surfaces": ["extensions/completion/driver.ts", "scripts/context-proposal-test.sh"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "The user explicitly chose workflow mode for a bounded next-round restart.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1"
+}
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+PY
+)"
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$GENERATED_HANDOFF_TWO_NORMALIZED" PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO_NORMALIZED" PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 pi --session "$SESSION_TWO_NORMALIZED" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round-normalized.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round-normalized.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-next-round-normalized.out" "$TMPDIR/pi-completion-context-proposal-next-round-normalized.err" "$DISCUSSION_SNAPSHOT_TWO_NORMALIZED" "$CURRENT_DONE_MISSION" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+previous = sys.argv[4]
+state = json.loads(Path('.agent/state.json').read_text())
+if snapshot.exists():
+    proposal = json.loads(snapshot.read_text())
+    assert proposal['source'] == 'handoff_capsule', 'done-workflow generated startup should snapshot the primary-agent handoff source'
+assert state['mission_anchor'] != previous, 'done-workflow discussion-only startup should advance to the new mission anchor'
+assert state['continuation_policy'] == 'continue', 'done-workflow discussion-only startup should reopen workflow state'
+assert 'Started a new completion workflow round from explicit primary-agent handoff' in output, 'done-workflow generated startup should report explicit primary-agent handoff startup'
+PY
+
+# Completed workflow: a fresh explicit primary-agent handoff should still start the next round.
+mark_done
+
+SESSION_TWO="$TMPDIR/session-two.jsonl"
+DISCUSSION_SNAPSHOT_TWO="$TMPDIR/context-proposal-next-round-explicit-handoff.json"
+HANDOFF_MESSAGES_TWO="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Ship the next workflow round from a fresh explicit handoff.",
+    "scope": [
+        "Reset canonical state back to reground for the fresh mission.",
+        "Preserve the tracked completion control-plane files."
+    ],
+    "constraints": [
+        "Do not resume the completed workflow when the new round is clearly different."
+    ],
+    "acceptance": [
+        "Reset canonical state back to reground for the new mission.",
+        "Preserve the tracked completion control-plane files."
+    ],
+    "risks": [
+        "Done-state history could override the fresh mission if the explicit handoff is ignored."
+    ],
+    "notes": [
+        "This next round must come from the fresh explicit handoff rather than recent discussion."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Start the next round from the fresh explicit handoff and preserve canonical control-plane files.",
+    "first_slice_non_goals": [
+        "Do not resume the completed workflow when the new round is clearly different."
+    ],
+    "implementation_surfaces": [
+        "extensions/completion/driver.ts",
+        "scripts/context-proposal-test.sh"
+    ],
+    "verification_commands": [
+        "npm run context-proposal-test"
+    ],
+    "why_this_slice_first": "The fresh explicit handoff is the smallest truthful next-round startup after the previous workflow closed.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "A new implementation-ready mission was identified after the previous round closed."
+}
+messages = [
+    {"role": "user", "content": "The previous round is done, but there is a fresh next round ready for /cook."},
+    {"role": "assistant", "content": "The next round is ready for /cook. Run /cook to confirm this fresh implementation mission.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$SESSION_TWO" "$ROOT" "$HANDOFF_MESSAGES_TWO"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_TWO" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round.err"
+
+python3 - "$DISCUSSION_SNAPSHOT_TWO" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Ship the next workflow round from a fresh explicit handoff.'
+expected_task_type = 'completion-workflow'
+expected_eval_profile = 'completion-rubric-v1'
+mission_text = Path('.agent/mission.md').read_text()
+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())
+proposal = json.loads(Path(sys.argv[1]).read_text())
+
+assert mission in mission_text, '.agent/mission.md did not update to the next-round explicit-handoff mission anchor'
+assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after next-round explicit handoff startup'
+assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after next-round explicit handoff startup'
+assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after starting the next workflow round from explicit handoff'
+assert state['task_type'] == expected_task_type, 'state.json task_type mismatch after starting the next workflow round from explicit handoff'
+assert state['evaluation_profile'] == expected_eval_profile, 'state.json evaluation_profile mismatch after starting the next workflow round from explicit handoff'
+assert state['advisory_startup_brief']['mission'] == mission, 'next-round explicit handoff should preserve the confirmed startup brief as advisory intake'
+assert state['advisory_startup_brief']['source'] == 'primary_agent_handoff', 'next-round explicit handoff should preserve the handoff advisory source'
+assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after starting the next workflow round from explicit handoff'
+assert plan['task_type'] == expected_task_type, 'plan.json task_type mismatch after starting the next workflow round from explicit handoff'
+assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluation_profile mismatch after starting the next workflow round from explicit handoff'
+assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after starting the next workflow round from explicit handoff'
+assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after starting the next workflow round from explicit handoff'
+assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after starting the next workflow round from explicit handoff'
+assert proposal['mission'] == mission, 'next-round explicit handoff proposal snapshot should preserve the handoff mission anchor'
+assert proposal['source'] == 'handoff_capsule', 'next-round explicit handoff proposal snapshot should record the handoff capsule source'
+assert state['current_phase'] == 'reground', 'state.json current_phase should reset to reground for the next workflow round'
+assert state['continuation_policy'] == 'continue', 'continuation_policy should reset to continue for the next workflow round'
+assert state['requires_reground'] is True, 'requires_reground should reset to true for the next workflow round'
+assert state['project_done'] is False, 'project_done should reset to false for the next workflow round'
+assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should reset to completion-regrounder for the next workflow round'
+assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'continuation_reason should record the next-round refocus'
+assert 'task_type=completion-workflow' in state['continuation_reason'], 'next-round refocus should persist the selected task_type'
+assert 'evaluation_profile=completion-rubric-v1' in state['continuation_reason'], 'next-round refocus should persist the selected evaluation_profile'
+assert plan['plan_basis'] == 'user_refocus', 'plan_basis should reset to user_refocus for the next workflow round'
+assert active['status'] == 'idle', 'active-slice should reset to idle for the next workflow round'
+PY
+
+# Active workflow: inline `/cook` arguments should fail closed immediately and leave canonical state unchanged.
+ACTIVE_INLINE_REJECTION_ROUTING="$TMPDIR/context-proposal-active-inline-arg-routing.json"
+ACTIVE_INLINE_REJECTION_PROPOSAL="$TMPDIR/context-proposal-active-inline-arg-proposal.json"
+ACTIVE_INLINE_REJECTION_CHOOSER="$TMPDIR/context-proposal-active-inline-arg-chooser.json"
+ACTIVE_INLINE_REJECTION_BASELINE="$TMPDIR/context-proposal-active-inline-before.json"
+python3 - "$ACTIVE_INLINE_REJECTION_BASELINE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+tracked = [
+    Path('.agent/mission.md'),
+    Path('.agent/profile.json'),
+    Path('.agent/state.json'),
+    Path('.agent/plan.json'),
+    Path('.agent/active-slice.json'),
+    Path('.agent/verification-evidence.json'),
+]
+Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in tracked}, indent=2) + '\n')
+PY
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$ACTIVE_INLINE_REJECTION_PROPOSAL" \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ACTIVE_INLINE_REJECTION_ROUTING" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$ACTIVE_INLINE_REJECTION_CHOOSER" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi -e "$PKG_ROOT" -p "/cook Replacement mission for the active workflow" >"$TMPDIR/pi-completion-context-proposal-active-inline-arg.out" 2>"$TMPDIR/pi-completion-context-proposal-active-inline-arg.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-active-inline-arg.out" "$TMPDIR/pi-completion-context-proposal-active-inline-arg.err" "$ACTIVE_INLINE_REJECTION_ROUTING" "$ACTIVE_INLINE_REJECTION_PROPOSAL" "$ACTIVE_INLINE_REJECTION_CHOOSER" "$ACTIVE_INLINE_REJECTION_BASELINE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+routing = Path(sys.argv[3])
+proposal = Path(sys.argv[4])
+chooser = Path(sys.argv[5])
+before = json.loads(Path(sys.argv[6]).read_text())
+tracked = [
+    Path('.agent/mission.md'),
+    Path('.agent/profile.json'),
+    Path('.agent/state.json'),
+    Path('.agent/plan.json'),
+    Path('.agent/active-slice.json'),
+    Path('.agent/verification-evidence.json'),
+]
+
+assert not routing.exists(), 'active /cook inline-args rejection should not run active-workflow routing'
+assert not proposal.exists(), 'active /cook inline-args rejection should not emit a replacement startup-brief proposal'
+assert not chooser.exists(), 'active /cook inline-args rejection should not open the existing-workflow chooser'
+assert '/cook no longer accepts inline arguments.' in output, 'active /cook inline-args rejection should explain the bare-only entry contract'
+after = {path.name: path.read_text() for path in tracked}
+assert before == after, 'active /cook inline-args rejection should leave canonical files unchanged'
+PY
+
+# Completed workflow: inline `/cook` arguments should also fail closed before any next-round proposal derivation.
+mark_done
+
+DONE_INLINE_REJECTION_ROUTING="$TMPDIR/context-proposal-done-inline-arg-routing.json"
+DONE_INLINE_REJECTION_PROPOSAL="$TMPDIR/context-proposal-done-inline-arg-proposal.json"
+DONE_INLINE_REJECTION_CHOOSER="$TMPDIR/context-proposal-done-inline-arg-chooser.json"
+DONE_INLINE_REJECTION_BASELINE="$TMPDIR/context-proposal-done-inline-before.json"
+python3 - "$DONE_INLINE_REJECTION_BASELINE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+tracked = [
+    Path('.agent/mission.md'),
+    Path('.agent/profile.json'),
+    Path('.agent/state.json'),
+    Path('.agent/plan.json'),
+    Path('.agent/active-slice.json'),
+    Path('.agent/verification-evidence.json'),
+]
+Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in tracked}, indent=2) + '\n')
+PY
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DONE_INLINE_REJECTION_PROPOSAL" \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$DONE_INLINE_REJECTION_ROUTING" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$DONE_INLINE_REJECTION_CHOOSER" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi -e "$PKG_ROOT" -p "/cook done-workflow replacement mission" >"$TMPDIR/pi-completion-context-proposal-done-inline-arg.out" 2>"$TMPDIR/pi-completion-context-proposal-done-inline-arg.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-done-inline-arg.out" "$TMPDIR/pi-completion-context-proposal-done-inline-arg.err" "$DONE_INLINE_REJECTION_ROUTING" "$DONE_INLINE_REJECTION_PROPOSAL" "$DONE_INLINE_REJECTION_CHOOSER" "$DONE_INLINE_REJECTION_BASELINE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+routing = Path(sys.argv[3])
+proposal = Path(sys.argv[4])
+chooser = Path(sys.argv[5])
+before = json.loads(Path(sys.argv[6]).read_text())
+tracked = [
+    Path('.agent/mission.md'),
+    Path('.agent/profile.json'),
+    Path('.agent/state.json'),
+    Path('.agent/plan.json'),
+    Path('.agent/active-slice.json'),
+    Path('.agent/verification-evidence.json'),
+]
+state_before = json.loads(before['state.json'])
+assert state_before['current_phase'] == 'done', 'done /cook inline-args rejection should start from a completed workflow'
+assert state_before['project_done'] is True, 'done /cook inline-args rejection should start from project_done=true'
+assert not routing.exists(), 'done /cook inline-args rejection should not run active-workflow routing while starting the next round'
+assert not proposal.exists(), 'done /cook inline-args rejection should not emit a next-round startup-brief proposal'
+assert not chooser.exists(), 'done /cook inline-args rejection should not open the existing-workflow chooser when starting the next round'
+assert '/cook no longer accepts inline arguments.' in output, 'done /cook inline-args rejection should explain the bare-only entry contract'
+after = {path.name: path.read_text() for path in tracked}
+assert before == after, 'done /cook inline-args rejection should leave canonical files unchanged'
+PY
+
+# Completed workflow again: model-assisted discussion analysis alone should still fail closed
+# without a fresh explicit primary-agent handoff.
+mark_done
+
+SESSION_FIVE="$TMPDIR/session-five.jsonl"
+DISCUSSION_FIVE=$'I do not want to rewrite the parser. The safer path is to let /cook analyze the discussion first, keep the discussion-derived mission anchored once it is clear, and ignore stale scope that drifted in from earlier turns. We should still prove it with a regression test before writing canonical state.'
+ANALYST_OUTPUT_FIVE='{"mission":"Use a proposal analyst to summarize natural discussion before /cook writes canonical state.","scope":["Keep the discussion-derived mission anchored once it is clear.","Drop stale scope from earlier turns."],"constraints":["Do not rewrite the parser."],"acceptance":["Add a regression test."],"confidence":0.91,"possible_noise":["old unrelated scope"]}'
+DISCUSSION_SNAPSHOT_FIVE="$TMPDIR/context-proposal-analyst-restart-rejected.json"
+write_session "$SESSION_FIVE" "$ROOT" "$DISCUSSION_FIVE"
+
+GENERATED_HANDOFF_FIVE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "mission": "Use the analyst-backed parser follow-up as the next workflow round.",
+    "scope": [
+        "Keep the discussion-derived mission anchored once it is clear.",
+        "Drop stale scope from earlier turns."
+    ],
+    "constraints": [
+        "Do not rewrite the parser."
+    ],
+    "acceptance": [
+        "Add a regression test."
+    ],
+    "risks": [],
+    "notes": ["Generated by the primary-agent handoff step triggered from /cook."],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the regression-test-backed parser follow-up without rewriting the parser.",
+    "first_slice_non_goals": ["Do not broaden the mission with stale scope."],
+    "implementation_surfaces": ["scripts/context-proposal-test.sh"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "The user explicitly chose workflow mode and the primary agent can already bound the first slice.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1"
+}
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+PY
+)"
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$ANALYST_OUTPUT_FIVE" PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$GENERATED_HANDOFF_FIVE" PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_FIVE" PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 pi --session "$SESSION_FIVE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-analyst.out" 2>"$TMPDIR/pi-completion-context-proposal-analyst.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-analyst.out" "$TMPDIR/pi-completion-context-proposal-analyst.err" "$DISCUSSION_SNAPSHOT_FIVE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+state = json.loads(Path('.agent/state.json').read_text())
+
+if snapshot.exists():
+    pass
+assert state['continuation_policy'] == 'continue', 'done-workflow analyst-backed primary-agent handoff should reopen the workflow'
+assert 'Started a new completion workflow round from explicit primary-agent handoff' in output, 'done-workflow analyst-backed startup should report explicit primary-agent handoff startup'
+PY
+
+# Custom confirmation UI: start should render proposal content separately from approval-only Start/Cancel actions.
+UI_ROOT_START="$TMPDIR/ui-root-start"
+mkdir -p "$UI_ROOT_START"
+cd "$UI_ROOT_START"
+git init -q
+
+UI_SESSION_START="$TMPDIR/ui-session-start.jsonl"
+UI_SNAPSHOT_START="$TMPDIR/context-proposal-ui-start.json"
+UI_MESSAGES_START="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Replace the crowded selector with a clearer action layout.",
+    "scope": ["Separate proposal text from actions."],
+    "constraints": ["Preserve approval-only Start/Cancel behavior."],
+    "acceptance": ["Add regression coverage."],
+    "risks": ["Bundling critique into the action list would make the confirmation harder to scan."],
+    "notes": ["Keep critique details separate from the approval-only proposal summary.", "Possible noise: old selector wording"],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Separate the proposal text from the approval-only Start/Cancel actions.",
+    "first_slice_non_goals": [],
+    "implementation_surfaces": ["extensions/completion/prompt-surfaces.ts"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "The confirmation layout regression is small and directly testable.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The explicit handoff is concrete enough to exercise the startup confirmation UI."
+}
+messages = [
+    {"role": "user", "content": "Prepare the confirmation-layout work and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "The confirmation-layout work is ready for /cook.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$UI_SESSION_START" "$UI_ROOT_START" "$UI_MESSAGES_START"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION=start \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH="$UI_SNAPSHOT_START" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$UI_SESSION_START" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ui-start.out" 2>"$TMPDIR/pi-completion-context-proposal-ui-start.err"
+
+python3 - "$UI_SNAPSHOT_START" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert snapshot['proposalHeading'] == 'Startup brief', 'custom confirmation snapshot should expose a dedicated startup-brief section'
+assert snapshot['critiqueHeading'] == 'Notes and risks', 'custom confirmation snapshot should expose notes separately from the startup-brief body'
+assert snapshot['routingHeading'] == 'Routing recommendations', 'custom confirmation snapshot should expose routing recommendations separately from the proposal body'
+assert 'approval-only' in snapshot['intro'], 'custom confirmation intro should explain the approval-only gate'
+assert state['task_type'] == 'completion-workflow', 'start action should preserve canonical task_type'
+assert state['evaluation_profile'] == 'completion-rubric-v1', 'start action should preserve canonical evaluation_profile'
+assert 'Mission\nReplace the crowded selector with a clearer action layout.' in snapshot['proposalBody'], 'proposal body should be captured separately from the action list'
+assert 'Keep critique details separate from the approval-only proposal summary.' not in snapshot['proposalBody'], 'critique notes should not be embedded in the startup-brief body'
+assert 'Critique\n- Keep critique details separate from the approval-only proposal summary.' in snapshot['critiqueBody'], 'notes section should render accepted critique notes separately'
+assert 'Risks\n- Bundling critique into the action list would make the confirmation harder to scan.' in snapshot['critiqueBody'], 'critique section should render risk notes separately'
+assert '- Possible noise: old selector wording' in snapshot['critiqueBody'], 'critique section should preserve additional operator notes separately from the startup-brief body'
+assert '- task_type: completion-workflow' in snapshot['routingBody'], 'routing section should render the recommended task_type'
+assert '- evaluation_profile: completion-rubric-v1' in snapshot['routingBody'], 'routing section should render the recommended evaluation_profile'
+assert [action['id'] for action in snapshot['actions']] == ['start', 'cancel'], 'custom confirmation actions should stay Start/Cancel only'
+assert [action['label'] for action in snapshot['actions']] == ['Start', 'Cancel'], 'custom confirmation action labels should be concise'
+assert 'Discuss changes in the main chat and rerun /cook.' in snapshot['actions'][1]['description'], 'cancel action should redirect users back to the main chat and rerun /cook'
+for action in snapshot['actions']:
+    assert 'Replace the crowded selector with a clearer action layout.' not in action['label'], 'proposal mission should not be embedded in action labels'
+    assert 'Separate proposal text from actions.' not in action['description'], 'proposal scope should not be embedded in action descriptions'
+assert state['mission_anchor'] == 'Replace the crowded selector with a clearer action layout.', 'start action should still accept the proposed mission'
+assert state['advisory_startup_brief']['mission'] == 'Replace the crowded selector with a clearer action layout.', 'start action should preserve the confirmed startup brief canonically'
+assert state['continuation_reason'].startswith('User started workflow via /cook:'), 'start action should persist the startup routing outcome in continuation_reason'
+assert 'Keep critique details separate from the approval-only proposal summary.' in state['continuation_reason'], 'start action should persist the accepted critique outcome canonically'
+PY
+
+# Custom confirmation UI: cancel should exit without writing canonical state and should tell the user
+# to discuss changes in the main chat before rerunning /cook.
+UI_ROOT_CANCEL="$TMPDIR/ui-root-cancel"
+mkdir -p "$UI_ROOT_CANCEL"
+cd "$UI_ROOT_CANCEL"
+git init -q
+
+UI_SESSION_CANCEL="$TMPDIR/ui-session-cancel.jsonl"
+UI_SNAPSHOT_CANCEL="$TMPDIR/context-proposal-ui-cancel.json"
+UI_MESSAGES_CANCEL="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Cancel from the custom confirmation UI without writing state.",
+    "scope": ["Show the proposal separately from the approval-only actions."],
+    "constraints": ["Keep cancellation side-effect free."],
+    "acceptance": ["Add regression coverage proving cancel leaves .agent absent."],
+    "risks": [],
+    "notes": [],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Exercise the cancel path without writing canonical state.",
+    "first_slice_non_goals": [],
+    "implementation_surfaces": ["extensions/completion/prompt-surfaces.ts"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "The cancel path is a direct regression around the startup confirmation UI.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The explicit handoff is concrete enough to exercise the cancel confirmation UI."
+}
+messages = [
+    {"role": "user", "content": "Prepare the cancel-path confirmation work and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "The cancel-path confirmation work is ready for /cook.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$UI_SESSION_CANCEL" "$UI_ROOT_CANCEL" "$UI_MESSAGES_CANCEL"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION=cancel \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH="$UI_SNAPSHOT_CANCEL" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$UI_SESSION_CANCEL" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ui-cancel.out" 2>"$TMPDIR/pi-completion-context-proposal-ui-cancel.err"
+
+python3 - "$UI_SNAPSHOT_CANCEL" "$TMPDIR/pi-completion-context-proposal-ui-cancel.out" "$TMPDIR/pi-completion-context-proposal-ui-cancel.err" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+assert 'approval-only' in snapshot['intro'], 'cancel snapshot should keep the approval-only intro'
+assert [action['id'] for action in snapshot['actions']] == ['start', 'cancel'], 'cancel snapshot should expose Start/Cancel actions only'
+assert [action['label'] for action in snapshot['actions']] == ['Start', 'Cancel'], 'cancel snapshot should keep concise Start/Cancel labels'
+assert 'Discuss changes in the main chat and rerun /cook.' in snapshot['actions'][1]['description'], 'cancel action copy should redirect users back to the main chat and rerun /cook'
+assert 'Discuss changes in the main chat and rerun /cook.' in output, 'cancel command output should redirect users back to the main chat and rerun /cook'
+assert not Path('.agent').exists(), 'cancel action should not write canonical workflow state'
+PY
+
+# Explicit primary-agent handoff: /cook should prefer the structured handoff capsule over broad context re-inference.
+HANDOFF_ROOT_START="$TMPDIR/handoff-root-start"
+mkdir -p "$HANDOFF_ROOT_START"
+cd "$HANDOFF_ROOT_START"
+git init -q
+
+HANDOFF_SESSION_START="$TMPDIR/handoff-session-start.jsonl"
+HANDOFF_SNAPSHOT_START="$TMPDIR/handoff-proposal-start.json"
+HANDOFF_MESSAGES_START="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Fix login redirect callback behavior.",
+    "scope": [
+        "Update the callback redirect decision logic.",
+        "Preserve the broader auth flow."
+    ],
+    "constraints": [
+        "Do not refactor the broader auth flow."
+    ],
+    "acceptance": [
+        "Add a regression test for returning to the requested page."
+    ],
+    "risks": [
+        "Stale auth discussion could broaden the startup brief if the handoff is ignored."
+    ],
+    "notes": [
+        "Keep the startup brief aligned with the explicit primary-agent plan."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the redirect callback fix and its regression coverage.",
+    "first_slice_non_goals": [
+        "Do not refactor the broader auth flow."
+    ],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect.spec.ts"
+    ],
+    "why_this_slice_first": "The redirect callback bug is already bounded enough to start implementation safely.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The implementation plan is concrete and ready for repo changes."
+}
+messages = [
+    {"role": "user", "content": "Please think through the login redirect fix and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "This task is now ready for /cook. Run /cook to confirm the startup brief.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_START" "$HANDOFF_ROOT_START" "$HANDOFF_MESSAGES_START"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_START" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_START" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-start.out" 2>"$TMPDIR/pi-completion-handoff-start.err"
+
+python3 - "$HANDOFF_SNAPSHOT_START" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert snapshot['source'] == 'handoff_capsule', 'explicit handoff startup should snapshot the handoff capsule as the proposal source'
+assert snapshot['mission'] == 'Fix login redirect callback behavior.', 'explicit handoff startup should preserve the primary-agent mission'
+assert state['mission_anchor'] == 'Fix login redirect callback behavior.', 'explicit handoff startup should use the handoff mission as canonical mission_anchor'
+assert state['advisory_startup_brief']['source'] == 'primary_agent_handoff', 'explicit handoff startup should preserve the advisory intake source'
+assert state['advisory_startup_brief']['risks'] == ['Stale auth discussion could broaden the startup brief if the handoff is ignored.'], 'explicit handoff startup should preserve handoff risks'
+assert 'First slice goal: Land the redirect callback fix and its regression coverage.' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve first_slice_goal in advisory notes'
+assert 'First slice non-goals: Do not refactor the broader auth flow.' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve first_slice_non_goals in advisory notes'
+assert 'Implementation surfaces: src/auth/redirect.ts | tests/auth/redirect.spec.ts' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve implementation_surfaces in advisory notes'
+assert 'Verification commands: npm test -- redirect.spec.ts' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve verification_commands in advisory notes'
+assert 'Why this slice first: The redirect callback bug is already bounded enough to start implementation safely.' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve why_this_slice_first in advisory notes'
+assert 'Primary-agent /cook handoff rationale: The implementation plan is concrete and ready for repo changes.' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve why_cook_now as notes'
+PY
+
+# Fresh but non-startable explicit handoff: /cook should fail closed instead of falling back
+# to a broad recent-discussion startup brief when the explicit capsule is still too vague.
+HANDOFF_ROOT_VAGUE="$TMPDIR/handoff-root-vague"
+mkdir -p "$HANDOFF_ROOT_VAGUE"
+cd "$HANDOFF_ROOT_VAGUE"
+git init -q
+
+HANDOFF_SESSION_VAGUE="$TMPDIR/handoff-session-vague.jsonl"
+HANDOFF_SNAPSHOT_VAGUE="$TMPDIR/handoff-proposal-vague.json"
+HANDOFF_MESSAGES_VAGUE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Fix login redirect callback behavior.",
+    "scope": [
+        "Update the callback redirect decision logic."
+    ],
+    "constraints": [
+        "Do not refactor the broader auth flow."
+    ],
+    "acceptance": [
+        "Confirm the final implementation breakdown before coding."
+    ],
+    "risks": [
+        "Broad recent context could be reused if the vague explicit handoff is ignored."
+    ],
+    "notes": [
+        "This handoff is still too vague to start implementation directly."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Patch the callback redirect decision logic.",
+    "first_slice_non_goals": [
+        "Do not refactor the broader auth flow."
+    ],
+    "implementation_surfaces": [],
+    "verification_commands": [],
+    "why_this_slice_first": "The callback redirect path is the likely first slice, but the handoff still lacks execution detail.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The task is workflow-worthy, but the implementation slice is not concrete enough yet."
+}
+recent_discussion = "Mission: Fix login redirect callback behavior.\nScope:\n- Update the callback redirect decision logic.\nConstraints:\n- Do not refactor the broader auth flow.\nAcceptance:\n- Add a regression test for returning to the requested page."
+messages = [
+    {"role": "user", "content": recent_discussion},
+    {"role": "assistant", "content": "This follow-up might soon be ready for /cook.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_VAGUE" "$HANDOFF_ROOT_VAGUE" "$HANDOFF_MESSAGES_VAGUE"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_VAGUE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_VAGUE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-vague.out" 2>"$TMPDIR/pi-completion-handoff-vague.err"
+
+python3 - "$HANDOFF_SNAPSHOT_VAGUE" "$TMPDIR/pi-completion-handoff-vague.out" "$TMPDIR/pi-completion-handoff-vague.err" <<'PY'
+import sys
+from pathlib import Path
+
+snapshot = Path(sys.argv[1])
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+
+assert not snapshot.exists(), 'fresh non-startable handoff should not emit a startup proposal snapshot'
+assert not Path('.agent').exists(), 'fresh non-startable handoff should fail closed without writing canonical state'
+assert 'fresh explicit primary-agent handoff exists' in output, 'fresh non-startable handoff should explain that the explicit capsule blocked startup'
+assert 'acceptance is not anchored to concrete repo changes or verification' in output, 'fresh non-startable handoff should explain the workflow-only acceptance failure'
+assert 'implementation_surfaces is empty' in output, 'fresh non-startable handoff should explain the missing implementation_surfaces requirement'
+assert 'verification_commands is empty' in output, 'fresh non-startable handoff should explain the missing verification_commands requirement'
+PY
+
+# Fresh explicit handoff with complete first-slice fields but vague acceptance: /cook should still fail closed
+# with the dedicated explicit-handoff message instead of bootstrapping canonical state.
+HANDOFF_ROOT_VAGUE_ACCEPTANCE="$TMPDIR/handoff-root-vague-acceptance"
+mkdir -p "$HANDOFF_ROOT_VAGUE_ACCEPTANCE"
+cd "$HANDOFF_ROOT_VAGUE_ACCEPTANCE"
+git init -q
+
+HANDOFF_SESSION_VAGUE_ACCEPTANCE="$TMPDIR/handoff-session-vague-acceptance.jsonl"
+HANDOFF_SNAPSHOT_VAGUE_ACCEPTANCE="$TMPDIR/handoff-proposal-vague-acceptance.json"
+HANDOFF_MESSAGES_VAGUE_ACCEPTANCE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Fix login redirect callback behavior.",
+    "scope": [
+        "Update the callback redirect decision logic.",
+        "Preserve the broader auth flow."
+    ],
+    "constraints": [
+        "Do not refactor the broader auth flow."
+    ],
+    "acceptance": [
+        "Current behavior stays understandable."
+    ],
+    "risks": [
+        "Broad recent context could be reused if the vague explicit handoff is ignored."
+    ],
+    "notes": [
+        "This handoff includes first-slice fields but still lacks concrete acceptance."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the redirect callback fix and its regression coverage.",
+    "first_slice_non_goals": [
+        "Do not refactor the broader auth flow."
+    ],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect.spec.ts"
+    ],
+    "why_this_slice_first": "The redirect callback bug is already bounded enough to start implementation safely once acceptance is concrete.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The task is workflow-worthy, but the acceptance still needs concrete repo-change detail."
+}
+recent_discussion = "Mission: Fix login redirect callback behavior.\nScope:\n- Update the callback redirect decision logic.\nConstraints:\n- Do not refactor the broader auth flow.\nAcceptance:\n- Add a regression test for returning to the requested page."
+messages = [
+    {"role": "user", "content": recent_discussion},
+    {"role": "assistant", "content": "This follow-up might soon be ready for /cook.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_VAGUE_ACCEPTANCE" "$HANDOFF_ROOT_VAGUE_ACCEPTANCE" "$HANDOFF_MESSAGES_VAGUE_ACCEPTANCE"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_VAGUE_ACCEPTANCE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_VAGUE_ACCEPTANCE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-vague-acceptance.out" 2>"$TMPDIR/pi-completion-handoff-vague-acceptance.err"
+
+python3 - "$HANDOFF_SNAPSHOT_VAGUE_ACCEPTANCE" "$TMPDIR/pi-completion-handoff-vague-acceptance.out" "$TMPDIR/pi-completion-handoff-vague-acceptance.err" <<'PY'
+import sys
+from pathlib import Path
+
+snapshot = Path(sys.argv[1])
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+
+assert not snapshot.exists(), 'fresh explicit handoff with vague acceptance should not emit a startup proposal snapshot'
+assert not Path('.agent').exists(), 'fresh explicit handoff with vague acceptance should fail closed without writing canonical state'
+assert 'fresh explicit primary-agent handoff exists' in output, 'fresh explicit handoff with vague acceptance should use the dedicated explicit-handoff fail-closed message'
+assert 'acceptance is not anchored to concrete repo changes or verification' in output, 'fresh explicit handoff with vague acceptance should explain the vague acceptance failure'
+PY
+
+# Done workflow + fresh handoff: the fresh explicit handoff should override done-state suppression and start the new round.
+HANDOFF_ROOT_DONE="$TMPDIR/handoff-root-done"
+mkdir -p "$HANDOFF_ROOT_DONE"
+cd "$HANDOFF_ROOT_DONE"
+git init -q
+
+DONE_SEED_SESSION="$TMPDIR/handoff-done-seed-session.jsonl"
+DONE_SEED_MESSAGES="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Seed a finished workflow before testing fresh handoff priority.",
+    "scope": ["Create canonical workflow state."],
+    "constraints": ["Keep the seed minimal."],
+    "acceptance": ["Add regression coverage for marking the seeded workflow done before the next step."],
+    "risks": [],
+    "notes": [],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Bootstrap the done-workflow seed fixture from an explicit handoff.",
+    "first_slice_non_goals": [],
+    "implementation_surfaces": ["scripts/context-proposal-test.sh"],
+    "verification_commands": ["npm run context-proposal-test"],
+    "why_this_slice_first": "The done-workflow handoff test needs canonical state before it can be marked done."
+}
+messages = [
+    {"role": "user", "content": "Prepare the done-workflow seed fixture and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "The done-workflow seed fixture is ready for /cook.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$DONE_SEED_SESSION" "$HANDOFF_ROOT_DONE" "$DONE_SEED_MESSAGES"
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$DONE_SEED_SESSION" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-done-seed.out" 2>"$TMPDIR/pi-completion-handoff-done-seed.err"
+mark_done
+
+HANDOFF_SESSION_DONE="$TMPDIR/handoff-session-done.jsonl"
+HANDOFF_SNAPSHOT_DONE="$TMPDIR/handoff-proposal-done.json"
+HANDOFF_MESSAGES_DONE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Reopen the login redirect work for the callback edge case.",
+    "scope": [
+        "Handle the callback edge case in the redirect logic.",
+        "Keep the finished workflow as historical context only."
+    ],
+    "constraints": [
+        "Do not turn done-state suppression into the startup mission."
+    ],
+    "acceptance": [
+        "Add a regression test for the callback edge case."
+    ],
+    "risks": [
+        "Done-state context could override the new mission if the handoff is ignored."
+    ],
+    "notes": [
+        "This is a fresh implementation round, not a summary of the finished workflow."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Patch the callback edge case and cover it with a focused regression test.",
+    "first_slice_non_goals": [
+        "Do not turn done-state suppression into the startup mission."
+    ],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect-edge.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect-edge.spec.ts"
+    ],
+    "why_this_slice_first": "The new callback edge case is the smallest fresh implementation slice after the prior round closed.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "A new implementation-ready edge case was identified after the previous round closed."
+}
+messages = [
+    {"role": "user", "content": "The previous round is done, but there is a fresh callback edge case to implement."},
+    {"role": "assistant", "content": "The next round is ready for /cook. Run /cook to confirm this fresh implementation mission.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_DONE" "$HANDOFF_ROOT_DONE" "$HANDOFF_MESSAGES_DONE"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_DONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_DONE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-done.out" 2>"$TMPDIR/pi-completion-handoff-done.err"
+
+python3 - "$HANDOFF_SNAPSHOT_DONE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert snapshot['source'] == 'handoff_capsule', 'done-workflow handoff should still use the explicit handoff capsule'
+assert snapshot['mission'] == 'Reopen the login redirect work for the callback edge case.', 'done-workflow handoff should preserve the fresh mission'
+assert state['mission_anchor'] == 'Reopen the login redirect work for the callback edge case.', 'done-workflow handoff should override done-state suppression with the fresh mission'
+assert state['continuation_policy'] == 'continue', 'done-workflow handoff should reopen canonical workflow state for the new round'
+assert state['advisory_startup_brief']['source'] == 'primary_agent_handoff', 'done-workflow handoff should preserve the handoff advisory source'
+assert 'First slice goal: Patch the callback edge case and cover it with a focused regression test.' in state['advisory_startup_brief']['notes'], 'done-workflow handoff should preserve first_slice_goal in advisory notes'
+assert 'Verification commands: npm test -- redirect-edge.spec.ts' in state['advisory_startup_brief']['notes'], 'done-workflow handoff should preserve verification_commands in advisory notes'
+PY
+
+# Stale handoff: later discussion should invalidate the older handoff capsule and fail closed instead of falling back to newer discussion.
+HANDOFF_ROOT_STALE="$TMPDIR/handoff-root-stale"
+mkdir -p "$HANDOFF_ROOT_STALE"
+cd "$HANDOFF_ROOT_STALE"
+git init -q
+
+HANDOFF_SESSION_STALE="$TMPDIR/handoff-session-stale.jsonl"
+HANDOFF_SNAPSHOT_STALE="$TMPDIR/handoff-proposal-stale.json"
+HANDOFF_MESSAGES_STALE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Fix the original login redirect callback behavior.",
+    "scope": ["Update the original callback redirect logic."],
+    "constraints": ["Do not refactor the auth stack."],
+    "acceptance": ["Add the original callback regression test."],
+    "risks": [],
+    "notes": [],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Ship the original login callback follow-up.",
+    "first_slice_non_goals": ["Do not refactor the auth stack."],
+    "implementation_surfaces": ["src/auth/login-redirect.ts"],
+    "verification_commands": ["npm test -- login-redirect.spec.ts"],
+    "why_this_slice_first": "The original callback follow-up was the first bounded implementation slice before later discussion replaced it."
+}
+newer_discussion = "Mission: Ship logout redirect consistency instead.\nScope:\n- Update the logout redirect path.\nConstraints:\n- Leave the login callback flow unchanged.\nAcceptance:\n- Add a logout redirect regression test."
+messages = [
+    {"role": "user", "content": "Please plan the login redirect follow-up."},
+    {"role": "assistant", "content": "Run /cook if you want to start the original follow-up.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+    {"role": "user", "content": newer_discussion},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_STALE" "$HANDOFF_ROOT_STALE" "$HANDOFF_MESSAGES_STALE"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_STALE" \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_STALE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-stale.out" 2>"$TMPDIR/pi-completion-handoff-stale.err"
+
+python3 - "$HANDOFF_SNAPSHOT_STALE" "$TMPDIR/pi-completion-handoff-stale.out" "$TMPDIR/pi-completion-handoff-stale.err" <<'PY'
+import sys
+from pathlib import Path
+
+snapshot = Path(sys.argv[1])
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
+
+assert not snapshot.exists(), 'stale handoff should not emit a startup proposal snapshot'
+assert not Path('.agent').exists(), 'stale handoff should fail closed without writing canonical state'
+assert 'primary-agent handoff step could not prepare a concrete startup handoff' in output, 'stale handoff should fail closed when the synthesized handoff step produces nothing'
+PY
+
+# Negative handoff rationale: a non-startable capsule must not become the startup mission.
+HANDOFF_ROOT_NEGATIVE="$TMPDIR/handoff-root-negative"
+mkdir -p "$HANDOFF_ROOT_NEGATIVE"
+cd "$HANDOFF_ROOT_NEGATIVE"
+git init -q
+
+HANDOFF_SESSION_NEGATIVE="$TMPDIR/handoff-session-negative.jsonl"
+HANDOFF_SNAPSHOT_NEGATIVE="$TMPDIR/handoff-proposal-negative.json"
+HANDOFF_MESSAGES_NEGATIVE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Do not reopen implementation for the finished workflow.",
+    "scope": ["Keep the old workflow closed."],
+    "constraints": ["Do not start repo changes."],
+    "acceptance": ["Explain that the finished workflow should stay closed."],
+    "risks": [],
+    "notes": [],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Keep the finished workflow closed.",
+    "first_slice_non_goals": ["Do not start repo changes."],
+    "implementation_surfaces": ["docs/workflow-status.md"],
+    "verification_commands": ["npm test -- workflow-status"],
+    "why_this_slice_first": "This is the only bounded next step being proposed, even though the mission itself is invalid."
+}
+messages = [
+    {"role": "user", "content": "Should we reopen the finished workflow?"},
+    {"role": "assistant", "content": "Do not reopen it directly.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
+write_session_messages "$HANDOFF_SESSION_NEGATIVE" "$HANDOFF_ROOT_NEGATIVE" "$HANDOFF_MESSAGES_NEGATIVE"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_NEGATIVE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$HANDOFF_SESSION_NEGATIVE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-negative.out" 2>"$TMPDIR/pi-completion-handoff-negative.err"
+
+python3 - "$HANDOFF_SNAPSHOT_NEGATIVE" "$TMPDIR/pi-completion-handoff-negative.out" "$TMPDIR/pi-completion-handoff-negative.err" <<'PY'
+import sys
+from pathlib import Path
+
+snapshot = Path(sys.argv[1])
+output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
 
-assert proposal['source'] == 'deferred_primary_agent_handoff', proposal
-assert state['mission_anchor'] == mission, state
-assert state['current_phase'] == 'reground', state
-assert state['next_mandatory_role'] == 'completion-regrounder', state
-assert startup_plan['mission_anchor'] == mission, startup_plan
-assert startup_plan['source'] == 'deferred_primary_agent_handoff', startup_plan
-assert plan['mission_anchor'] == mission, plan
-assert active['mission_anchor'] == mission, active
-assert 'Started a new completion workflow round and recorded the approved startup plan' in output, output
+assert not snapshot.exists(), 'negative handoff rationale should not emit a startup proposal snapshot'
+assert not Path('.agent').exists(), 'negative handoff rationale should fail closed without writing canonical state'
+assert '/cook failed closed' in output, 'negative handoff rationale should fail closed instead of becoming the startup mission'
 PY
 
-grep -q 'export function assessCookHandoffText' "$PKG_ROOT/extensions/completion/proposal.ts"
 grep -q 'export async function deriveCookContextProposalFromRecentDiscussion' "$PKG_ROOT/extensions/completion/proposal.ts"
-grep -q 'export async function analyzeContextProposalWithAgent' "$PKG_ROOT/extensions/completion/role-runner.ts"
+grep -q 'export function extractLatestCookHandoffProposal' "$PKG_ROOT/extensions/completion/proposal.ts"
+grep -q 'export function parseContextProposalAnalystOutput' "$PKG_ROOT/extensions/completion/proposal.ts"
+grep -q 'export function buildContextProposalConfirmationLayout' "$PKG_ROOT/extensions/completion/prompt-surfaces.ts"
+grep -q 'export function buildEvaluationRoleContextLines' "$PKG_ROOT/extensions/completion/prompt-surfaces.ts"
 
-echo "context proposal test passed: $PKG_ROOT"
+echo "context proposal test passed: $ROOT"