@linimin/pi-letscook 0.1.66 → 0.1.68

package/scripts/refocus-test.sh

@@ -47,130 +47,31 @@ with session_path.open('w', encoding='utf-8') as fh:
 PY
 }
 
-write_session_messages() {
-  local session_path="$1"
-  local cwd="$2"
-  local messages_json="$3"
-  python3 - "$session_path" "$cwd" "$messages_json" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-session_path = Path(sys.argv[1])
-cwd = sys.argv[2]
-messages = json.loads(sys.argv[3])
-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,
-    },
-]
-parent_id = None
-for index, message in enumerate(messages, start=1):
-    entry_id = f"m{index:04d}"
-    entries.append({
-        "type": "message",
-        "id": entry_id,
-        "parentId": parent_id,
-        "timestamp": f"2026-01-01T00:00:{index:02d}.000Z",
-        "message": {
-            "role": message["role"],
-            "content": message["content"],
-            "timestamp": 1767225600000 + index * 1000,
-        },
-    })
-    parent_id = entry_id
-with session_path.open('w', encoding='utf-8') as fh:
-    for entry in entries:
-        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
-PY
-}
-
-cd "$TMPDIR"
-git init -q
-
-BOOTSTRAP_SESSION="$TMPDIR/session-bootstrap.jsonl"
-BOOTSTRAP_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": "Smoke-test mission.",
-    "scope": [
-        "Bootstrap a completion workflow for the refocus regression fixture."
-    ],
-    "constraints": [
-        "Keep active-workflow refocus behavior under the explicit-handoff startup contract."
-    ],
-    "acceptance": [
-        "Bootstrap canonical refocus-fixture state for the active-workflow regression.",
-        "Verify the refocus regression with npm run refocus-test."
-    ],
-    "risks": [],
-    "notes": [
-        "Use explicit primary-agent handoff startup for the refocus regression fixture."
-    ],
-    "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Bootstrap the refocus regression fixture from a fresh explicit handoff.",
-    "first_slice_non_goals": [],
-    "implementation_surfaces": [
-        "scripts/refocus-test.sh"
-    ],
-    "verification_commands": [
-        "npm run refocus-test"
-    ],
-    "why_this_slice_first": "The refocus regression fixture needs canonical state before active-workflow routing can be exercised.",
-    "task_type": "completion-workflow",
-    "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The active-workflow refocus regression needs a fresh explicit startup boundary."
+bootstrap_active_workflow() {
+  local repo_root="$1"
+  local session_path="$2"
+  local bootstrap_discussion="$3"
+  local generated_handoff="$4"
+
+  mkdir -p "$repo_root"
+  cd "$repo_root"
+  git init -q
+  write_session "$session_path" "$repo_root" "$bootstrap_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"
+
+  for file in .agent/profile.json .agent/state.json .agent/startup-plan.json .agent/startup-plan.md .agent/plan.json .agent/active-slice.json .agent/verification-evidence.json; do
+    [[ -f "$file" ]] || { echo "missing canonical bootstrap file: $file" >&2; exit 1; }
+  done
 }
-messages = [
-    {"role": "user", "content": "Prepare the refocus regression fixture and tell me when it is ready for /cook."},
-    {"role": "assistant", "content": "The refocus regression 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 "$BOOTSTRAP_SESSION" "$TMPDIR" "$BOOTSTRAP_MESSAGES"
-
-PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-pi --session "$BOOTSTRAP_SESSION" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-refocus-bootstrap.out" 2>"$TMPDIR/pi-completion-refocus-bootstrap.err" &
-PI_PID=$!
-for _ in $(seq 1 60); do
-  if [[ -f .agent/profile.json && -f .agent/state.json && -f .agent/plan.json && -f .agent/active-slice.json ]]; then
-    break
-  fi
-  sleep 1
-done
-if [[ ! -f .agent/profile.json || ! -f .agent/state.json || ! -f .agent/plan.json || ! -f .agent/active-slice.json ]]; then
-  echo "completion bootstrap did not materialize canonical files in time" >&2
-  cat "$TMPDIR/pi-completion-refocus-bootstrap.err" >&2 || true
-  kill "$PI_PID" >/dev/null 2>&1 || true
-  wait "$PI_PID" >/dev/null 2>&1 || true
-  exit 1
-fi
-kill "$PI_PID" >/dev/null 2>&1 || true
-wait "$PI_PID" >/dev/null 2>&1 || true
 
-INITIAL_MISSION="$(python3 - <<'PY'
-import json
-from pathlib import Path
-state = json.loads(Path('.agent/state.json').read_text())
-print(state['mission_anchor'])
-PY
-)"
-
-INLINE_REJECTION_ROUTING="$TMPDIR/inline-arg-routing.json"
-INLINE_REJECTION_PROPOSAL="$TMPDIR/inline-arg-proposal.json"
-INLINE_REJECTION_CHOOSER="$TMPDIR/inline-arg-chooser.json"
-INLINE_REJECTION_BASELINE="$TMPDIR/inline-arg-before.json"
-python3 - "$INLINE_REJECTION_BASELINE" <<'PY'
+snapshot_tracked() {
+  local baseline_path="$1"
+  python3 - "$baseline_path" <<'PY'
 import json
 import sys
 from pathlib import Path
@@ -179,421 +80,246 @@ 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
+}
 
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$INLINE_REJECTION_ROUTING" \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$INLINE_REJECTION_PROPOSAL" \
-PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$INLINE_REJECTION_CHOOSER" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi -e "$PKG_ROOT" -p "/cook replacement mission that should stay in the main chat" \
-  >"$TMPDIR/pi-completion-refocus-inline-arg.out" 2>"$TMPDIR/pi-completion-refocus-inline-arg.err"
-
-python3 - "$TMPDIR/pi-completion-refocus-inline-arg.out" "$TMPDIR/pi-completion-refocus-inline-arg.err" "$INLINE_REJECTION_ROUTING" "$INLINE_REJECTION_PROPOSAL" "$INLINE_REJECTION_CHOOSER" "$INITIAL_MISSION" "$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])
-initial_mission = sys.argv[6]
-before = json.loads(Path(sys.argv[7]).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'),
-]
-current_state = json.loads(before['state.json'])
-assert current_state['mission_anchor'] == initial_mission, 'active /cook inline-args rejection should start from the current mission anchor'
-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 open final startup-brief confirmation'
-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
-
-SESSION_INITIAL_REFOCUS="$TMPDIR/session-initial-bare-refocus.jsonl"
-INITIAL_REFOCUS_ROUTING="$TMPDIR/initial-bare-refocus-routing.json"
-INITIAL_REFOCUS_MESSAGES="$(python3 - <<'PY'
+BOOTSTRAP_DISCUSSION=$'Prepare the active workflow fixture and keep the initial mission small and truthful.'
+BOOTSTRAP_HANDOFF="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
     "source": "primary_agent",
-    "captured_at": "2026-01-01T00:00:02.000Z",
-    "source_turn_id": "m0002",
-    "mission": "Remove completion status line, keep widget.",
+    "mission": "Maintain the active workflow fixture baseline.",
     "scope": [
-        "Replace the initial smoke-test workflow with the widget mission."
+        "Scaffold canonical completion files for the refocus regression fixture.",
+        "Keep the initial workflow ready for later replacement checks."
     ],
     "constraints": [
-        "Keep the approval-only Start/Cancel refocus gate."
+        "Use supported bare /cook startup only."
     ],
     "acceptance": [
-        "Rewrite canonical state only after the replacement mission is approved."
+        "Bootstrap canonical completion state for the refocus regression fixture.",
+        "Keep scripts/refocus-test.sh aligned with the shipped startup behavior."
     ],
     "risks": [],
     "notes": [
-        "Use a fresh explicit primary-agent handoff for the active-workflow replacement."
+        "Bootstrap from same-entry primary-agent startup-plan synthesis."
     ],
     "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Replace the initial smoke-test workflow with the widget mission.",
+    "first_slice_goal": "Scaffold canonical files for the refocus regression fixture.",
     "first_slice_non_goals": [],
-    "implementation_surfaces": [
-        "scripts/refocus-test.sh"
-    ],
-    "verification_commands": [
-        "npm run refocus-test"
-    ],
-    "why_this_slice_first": "The fresh explicit handoff is the only supported replacement entry while a workflow is active.",
+    "implementation_surfaces": ["scripts/refocus-test.sh"],
+    "verification_commands": ["npm run refocus-test"],
+    "why_this_slice_first": "Canonical state must exist before refocus can be exercised.",
     "task_type": "completion-workflow",
     "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "A different active workflow is ready and explicitly handed off by the primary agent."
+    "why_cook_now": "The fixture startup is concrete enough to begin workflow planning."
 }
-messages = [
-    {"role": "user", "content": "The smoke-test workflow is active, but a different replacement workflow may now be ready."},
-    {"role": "assistant", "content": "Use this fresh explicit handoff if you want /cook to replace the active workflow.\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_INITIAL_REFOCUS" "$TMPDIR" "$INITIAL_REFOCUS_MESSAGES"
-
-PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
-PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$INITIAL_REFOCUS_ROUTING" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_INITIAL_REFOCUS" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/pi-completion-refocus.out" 2>"$TMPDIR/pi-completion-refocus.err"
-
-python3 - "$INITIAL_REFOCUS_ROUTING" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-new_anchor = 'Remove completion status line, keep widget.'
-expected_task_type = 'completion-workflow'
-expected_eval_profile = 'completion-rubric-v1'
-routing = json.loads(Path(sys.argv[1]).read_text())
-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())
-
-assert new_anchor in mission_text, '.agent/mission.md did not update to the refocused mission anchor'
-assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after refocus'
-assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after refocus'
-assert state['mission_anchor'] == new_anchor, 'state.json mission_anchor mismatch after refocus'
-assert state['task_type'] == expected_task_type, 'state.json task_type mismatch after refocus'
-assert state['evaluation_profile'] == expected_eval_profile, 'state.json evaluation_profile mismatch after refocus'
-assert state['advisory_startup_brief']['mission'] == new_anchor, 'refocus should preserve the confirmed startup brief as advisory intake'
-assert plan['mission_anchor'] == new_anchor, 'plan.json mission_anchor mismatch after refocus'
-assert plan['task_type'] == expected_task_type, 'plan.json task_type mismatch after refocus'
-assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluation_profile mismatch after refocus'
-assert active['mission_anchor'] == new_anchor, 'active-slice.json mission_anchor mismatch after refocus'
-assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after refocus'
-assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after refocus'
-assert state['current_phase'] == 'reground', 'state.json current_phase should reset to reground after refocus'
-assert state['requires_reground'] is True, 'state.json requires_reground should be true after refocus'
-assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should reset to completion-regrounder'
-assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'continuation_reason should record the refocus'
-assert plan['plan_basis'] == 'user_refocus', 'plan.json plan_basis should be user_refocus after refocus'
-assert active['status'] == 'idle', 'active-slice.json status should reset to idle after refocus'
-assert routing['mode'] == 'bare', 'supported refocus should use bare active-workflow routing mode'
-assert 'explicitGoal' not in routing, 'supported bare refocus should not expose removed explicit-goal shim fields'
-assert 'explicitGoalProvided' not in routing, 'supported bare refocus should not expose removed explicit-goal shim fields'
-assert routing['action'] == 'refocus', 'supported bare /cook should classify as refocus when a fresh explicit handoff proposes a different mission'
-assert routing['reason'] == 'fresh_explicit_handoff', 'supported bare /cook should record the explicit-handoff replacement reason'
-assert routing['proposedMissionAnchor'] == new_anchor, 'explicit handoff routing snapshot should expose the replacement mission anchor'
-assert routing['proposalSource'] == 'handoff_capsule', 'explicit handoff routing snapshot should preserve the handoff source'
-PY
-
-UPDATED_MISSION="$(python3 - <<'PY'
-import json
-from pathlib import Path
-state = json.loads(Path('.agent/state.json').read_text())
-print(state['mission_anchor'])
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
 PY
 )"
-
-if [[ "$INITIAL_MISSION" == "$UPDATED_MISSION" ]]; then
-  echo "expected mission anchor to change during supported bare refocus" >&2
-  exit 1
-fi
-
-# Fresh explicit handoff replacements must still reach the chooser and final Start/Cancel gate while the
-# workflow is active.
-BARE_REFOCUS_MISSION='Exercise explicit active-workflow replacement coverage.'
-BARE_REFOCUS_MESSAGES="$(python3 - <<'PY'
+REPLACEMENT_DISCUSSION=$'Switch the active workflow to the widget mission and keep the change confirm-first.'
+REPLACEMENT_HANDOFF="$(python3 - <<'PY'
 import json
 capsule = {
     "kind": "cook_handoff",
     "source": "primary_agent",
-    "captured_at": "2026-01-01T00:00:02.000Z",
-    "source_turn_id": "m0002",
-    "mission": "Exercise explicit active-workflow replacement coverage.",
+    "mission": "Remove the completion status line while keeping the completion widget.",
     "scope": [
-        "Treat the active bare /cook request as an explicit replacement workflow.",
-        "Keep the replacement behind the existing approval-only Start/Cancel gate."
+        "Replace the active fixture mission with the widget mission.",
+        "Keep refocus approval-only before canonical rewrite."
     ],
     "constraints": [
-        "Do not rewrite canonical state before the final Start confirmation."
+        "Do not bypass the Start/Cancel gate."
     ],
     "acceptance": [
-        "Add deterministic coverage proving the chooser and final approval path for this explicit replacement mission."
+        "Rewrite canonical workflow state only after the replacement mission is approved.",
+        "Keep refocus regression coverage aligned with same-entry synthesis behavior."
+    ],
+    "risks": [
+        "Do not leave the old mission partially active after refocus."
     ],
-    "risks": [],
     "notes": [
-        "This replacement should come only from the fresh explicit handoff, not recent discussion inference."
+        "This replacement must come from same-entry primary-agent startup-plan synthesis."
     ],
     "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Exercise the active-workflow explicit-handoff replacement path.",
-    "first_slice_non_goals": [],
-    "implementation_surfaces": [
-        "scripts/refocus-test.sh"
-    ],
-    "verification_commands": [
-        "npm run refocus-test"
-    ],
-    "why_this_slice_first": "The active workflow should only replace from a fresh explicit handoff.",
+    "first_slice_goal": "Rewrite canonical workflow state for the widget mission.",
+    "first_slice_non_goals": ["Do not start implementation before the refocus is approved."],
+    "implementation_surfaces": ["scripts/refocus-test.sh", ".agent/startup-plan.json"],
+    "verification_commands": ["npm run refocus-test"],
+    "why_this_slice_first": "The active workflow must be re-anchored before later role dispatch.",
     "task_type": "completion-workflow",
     "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The primary agent explicitly handed off a replacement workflow while the current one is active."
+    "why_cook_now": "A different workflow mission is now concrete enough to replace the active one."
 }
-messages = [
-    {"role": "user", "content": "The current workflow is active, but there is a fresh explicit replacement handoff ready."},
-    {"role": "assistant", "content": "Use this fresh explicit handoff if you want /cook to replace the active workflow.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
-]
-print(json.dumps(messages, ensure_ascii=False))
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
 PY
 )"
 
-SESSION_BARE_CHOOSER_CANCEL="$TMPDIR/session-bare-chooser-cancel.jsonl"
-BARE_CHOOSER_SNAPSHOT="$TMPDIR/bare-existing-workflow-chooser.json"
-BARE_ROUTING_CHOOSER_CANCEL="$TMPDIR/bare-routing-chooser-cancel.json"
-write_session_messages "$SESSION_BARE_CHOOSER_CANCEL" "$TMPDIR" "$BARE_REFOCUS_MESSAGES"
-
+# Case 1: chooser cancel leaves canonical state untouched while still surfacing synthesized replacement routing.
+ROOT_ONE="$TMPDIR/repo-one"
+SESSION_ONE_BOOTSTRAP="$TMPDIR/session-one-bootstrap.jsonl"
+SESSION_ONE_REFOCUS="$TMPDIR/session-one-refocus.jsonl"
+ROUTING_ONE="$TMPDIR/routing-one.json"
+CHOOSER_ONE="$TMPDIR/chooser-one.json"
+PROPOSAL_ONE="$TMPDIR/proposal-one.json"
+BASELINE_ONE="$TMPDIR/baseline-one.json"
+bootstrap_active_workflow "$ROOT_ONE" "$SESSION_ONE_BOOTSTRAP" "$BOOTSTRAP_DISCUSSION" "$BOOTSTRAP_HANDOFF"
+cd "$ROOT_ONE"
+snapshot_tracked "$BASELINE_ONE"
+write_session "$SESSION_ONE_REFOCUS" "$ROOT_ONE" "$REPLACEMENT_DISCUSSION"
+
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$REPLACEMENT_HANDOFF" \
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=cancel \
-PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$BARE_CHOOSER_SNAPSHOT" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$BARE_ROUTING_CHOOSER_CANCEL" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_BARE_CHOOSER_CANCEL" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/pi-completion-bare-chooser-cancel.out" 2>"$TMPDIR/pi-completion-bare-chooser-cancel.err"
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_ONE" \
+pi --session "$SESSION_ONE_REFOCUS" -e "$PKG_ROOT" -p "/cook" \
+  >"$TMPDIR/refocus-one.out" 2>"$TMPDIR/refocus-one.err"
 
-python3 - "$BARE_CHOOSER_SNAPSHOT" "$BARE_ROUTING_CHOOSER_CANCEL" "$TMPDIR/pi-completion-bare-chooser-cancel.out" "$TMPDIR/pi-completion-bare-chooser-cancel.err" "$UPDATED_MISSION" "$BARE_REFOCUS_MISSION" <<'PY'
+python3 - "$ROUTING_ONE" "$CHOOSER_ONE" "$PROPOSAL_ONE" "$BASELINE_ONE" "$TMPDIR/refocus-one.out" "$TMPDIR/refocus-one.err" <<'PY'
 import json
 import sys
 from pathlib import Path
 
-chooser = json.loads(Path(sys.argv[1]).read_text())
-routing = json.loads(Path(sys.argv[2]).read_text())
-output = Path(sys.argv[3]).read_text() + Path(sys.argv[4]).read_text()
-updated_mission = sys.argv[5]
-replacement_mission = sys.argv[6]
-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())
+routing = json.loads(Path(sys.argv[1]).read_text())
+chooser = json.loads(Path(sys.argv[2]).read_text())
+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}
 
-assert state['mission_anchor'] == updated_mission, 'chooser cancel should keep the current mission anchor'
-assert plan['mission_anchor'] == updated_mission, 'chooser cancel should keep plan.json unchanged'
-assert active['mission_anchor'] == updated_mission, 'chooser cancel should keep active-slice.json unchanged'
-assert routing['mode'] == 'bare', 'bare /cook should snapshot bare active-workflow routing mode'
-assert 'explicitGoal' not in routing, 'bare chooser routing should not expose removed explicit-goal shim fields'
-assert 'explicitGoalProvided' not in routing, 'bare chooser routing should not expose removed explicit-goal shim fields'
-assert routing['action'] == 'refocus', 'fresh explicit replacement handoff should classify active bare /cook as refocus'
-assert routing['reason'] == 'fresh_explicit_handoff', 'fresh explicit replacement handoff should record the explicit-handoff reason'
-assert routing['currentMissionAnchor'] == updated_mission, 'explicit-handoff routing should keep the current mission anchor until the user approves replacement'
-assert routing['proposedMissionAnchor'] == replacement_mission, 'explicit-handoff routing should expose the proposed replacement mission'
-assert routing['proposalSource'] == 'handoff_capsule', 'explicit-handoff routing should preserve the handoff source'
-assert chooser['title'].startswith('Existing completion workflow found'), 'bare chooser snapshot should describe the existing-workflow prompt'
-assert chooser['choices'][0].startswith('Continue current workflow'), 'bare chooser should keep the continue option'
-assert chooser['choices'][1].startswith('Start new workflow from explicit primary-agent handoff'), 'bare chooser should offer the explicit-handoff replacement option'
-assert 'Start/Cancel confirmation' in chooser['choices'][1], 'bare chooser should mention the approval-only replacement confirmation'
-assert chooser['choices'][2].startswith('Cancel'), 'bare chooser should keep the cancel option'
-assert 'Discuss changes in the main chat and rerun /cook.' in output, 'bare chooser cancel should redirect users back to the main chat and rerun /cook'
+assert routing['action'] == 'refocus', routing
+assert routing['reason'] == 'generated_replacement_startup_plan', routing
+assert routing['proposedMissionAnchor'] == 'Remove the completion status line while keeping the completion widget.', routing
+assert chooser['choices'][1].startswith('Start new workflow from same-entry primary-agent startup plan'), chooser
+assert not proposal.exists(), 'chooser cancel should not open the final Start/Cancel proposal snapshot'
+assert before == after, 'chooser cancel should leave canonical workflow files unchanged'
+assert 'Cancelled existing workflow confirmation.' in output, output
 PY
 
-SESSION_BARE_FINAL_CANCEL="$TMPDIR/session-bare-final-cancel.jsonl"
-BARE_ROUTING_FINAL_CANCEL="$TMPDIR/bare-routing-final-cancel.json"
-BARE_PROPOSAL_CANCEL="$TMPDIR/bare-replacement-proposal-cancel.json"
-write_session_messages "$SESSION_BARE_FINAL_CANCEL" "$TMPDIR" "$BARE_REFOCUS_MESSAGES"
-
+# Case 2: final Start/Cancel cancel still leaves canonical state untouched after chooser acceptance.
+ROOT_TWO="$TMPDIR/repo-two"
+SESSION_TWO_BOOTSTRAP="$TMPDIR/session-two-bootstrap.jsonl"
+SESSION_TWO_REFOCUS="$TMPDIR/session-two-refocus.jsonl"
+ROUTING_TWO="$TMPDIR/routing-two.json"
+CHOOSER_TWO="$TMPDIR/chooser-two.json"
+PROPOSAL_TWO="$TMPDIR/proposal-two.json"
+BASELINE_TWO="$TMPDIR/baseline-two.json"
+bootstrap_active_workflow "$ROOT_TWO" "$SESSION_TWO_BOOTSTRAP" "$BOOTSTRAP_DISCUSSION" "$BOOTSTRAP_HANDOFF"
+cd "$ROOT_TWO"
+snapshot_tracked "$BASELINE_TWO"
+write_session "$SESSION_TWO_REFOCUS" "$ROOT_TWO" "$REPLACEMENT_DISCUSSION"
+
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$REPLACEMENT_HANDOFF" \
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=cancel \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$BARE_PROPOSAL_CANCEL" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$BARE_ROUTING_FINAL_CANCEL" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_BARE_FINAL_CANCEL" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/pi-completion-bare-final-cancel.out" 2>"$TMPDIR/pi-completion-bare-final-cancel.err"
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_TWO" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_TWO" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_TWO" \
+pi --session "$SESSION_TWO_REFOCUS" -e "$PKG_ROOT" -p "/cook" \
+  >"$TMPDIR/refocus-two.out" 2>"$TMPDIR/refocus-two.err"
 
-python3 - "$BARE_PROPOSAL_CANCEL" "$BARE_ROUTING_FINAL_CANCEL" "$TMPDIR/pi-completion-bare-final-cancel.out" "$TMPDIR/pi-completion-bare-final-cancel.err" "$UPDATED_MISSION" "$BARE_REFOCUS_MISSION" <<'PY'
+python3 - "$ROUTING_TWO" "$CHOOSER_TWO" "$PROPOSAL_TWO" "$BASELINE_TWO" "$TMPDIR/refocus-two.out" "$TMPDIR/refocus-two.err" <<'PY'
 import json
 import sys
 from pathlib import Path
 
-proposal = json.loads(Path(sys.argv[1]).read_text())
-routing = json.loads(Path(sys.argv[2]).read_text())
-output = Path(sys.argv[3]).read_text() + Path(sys.argv[4]).read_text()
-updated_mission = sys.argv[5]
-replacement_mission = sys.argv[6]
-state = json.loads(Path('.agent/state.json').read_text())
-plan = json.loads(Path('.agent/plan.json').read_text())
-active = json.loads(Path('.agent/active-slice.json').read_text())
-
-assert state['mission_anchor'] == updated_mission, 'final Start/Cancel cancel should keep the current mission anchor'
-assert plan['mission_anchor'] == updated_mission, 'final Start/Cancel cancel should keep plan.json unchanged'
-assert active['mission_anchor'] == updated_mission, 'final Start/Cancel cancel should keep active-slice.json unchanged'
-assert routing['action'] == 'refocus', 'final Start/Cancel cancel should still come from an explicit-handoff refocus classification'
-assert routing['reason'] == 'fresh_explicit_handoff', 'final Start/Cancel cancel should preserve the explicit-handoff reason'
-assert routing['currentMissionAnchor'] == updated_mission, 'final Start/Cancel cancel should keep the current mission anchor until the user approves replacement'
-assert proposal['mission'] == replacement_mission, 'final Start/Cancel cancel should still prepare the replacement proposal before rewriting state'
-assert proposal['source'] == 'handoff_capsule', 'final Start/Cancel cancel should preserve the explicit-handoff proposal source'
-assert 'Discuss changes in the main chat and rerun /cook.' in output, 'final Start/Cancel cancel should redirect users back to the main chat and rerun /cook'
-PY
-
-SESSION_BARE_ACCEPT="$TMPDIR/session-bare-accept.jsonl"
-BARE_ROUTING_ACCEPT="$TMPDIR/bare-routing-accept.json"
-BARE_PROPOSAL_ACCEPT="$TMPDIR/bare-replacement-proposal-accept.json"
-write_session_messages "$SESSION_BARE_ACCEPT" "$TMPDIR" "$BARE_REFOCUS_MESSAGES"
-
-PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
-PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$BARE_PROPOSAL_ACCEPT" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$BARE_ROUTING_ACCEPT" \
-PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_BARE_ACCEPT" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/pi-completion-bare-accept.out" 2>"$TMPDIR/pi-completion-bare-accept.err"
-
-python3 - "$BARE_PROPOSAL_ACCEPT" "$BARE_ROUTING_ACCEPT" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-new_anchor = 'Exercise explicit active-workflow replacement coverage.'
-expected_task_type = 'completion-workflow'
-expected_eval_profile = 'completion-rubric-v1'
-proposal = json.loads(Path(sys.argv[1]).read_text())
-routing = json.loads(Path(sys.argv[2]).read_text())
-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())
-
-assert proposal['mission'] == new_anchor, 'accepted bare refocus should preserve the replacement proposal mission'
-assert routing['mode'] == 'bare', 'accepted bare refocus should keep bare routing mode'
-assert 'explicitGoal' not in routing, 'accepted bare refocus should not expose removed explicit-goal shim fields'
-assert 'explicitGoalProvided' not in routing, 'accepted bare refocus should not expose removed explicit-goal shim fields'
-assert routing['action'] == 'refocus', 'accepted bare refocus should keep the explicit-handoff refocus classification'
-assert routing['reason'] == 'fresh_explicit_handoff', 'accepted bare refocus should keep the explicit-handoff reason'
-assert routing['currentMissionAnchor'] == 'Remove completion status line, keep widget.', 'accepted bare refocus should expose the original mission until Start is accepted'
-assert routing['proposalSource'] == 'handoff_capsule', 'accepted bare refocus should preserve the explicit-handoff source'
-assert new_anchor in mission_text, '.agent/mission.md did not update to the bare refocus mission anchor'
-assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after bare refocus'
-assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after bare refocus'
-assert state['mission_anchor'] == new_anchor, 'state.json mission_anchor mismatch after bare refocus'
-assert state['task_type'] == expected_task_type, 'state.json task_type mismatch after bare refocus'
-assert state['evaluation_profile'] == expected_eval_profile, 'state.json evaluation_profile mismatch after bare refocus'
-assert state['advisory_startup_brief']['mission'] == new_anchor, 'bare refocus should preserve the confirmed startup brief as advisory intake'
-assert plan['mission_anchor'] == new_anchor, 'plan.json mission_anchor mismatch after bare refocus'
-assert plan['task_type'] == expected_task_type, 'plan.json task_type mismatch after bare refocus'
-assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluation_profile mismatch after bare refocus'
-assert active['mission_anchor'] == new_anchor, 'active-slice.json mission_anchor mismatch after bare refocus'
-assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after bare refocus'
-assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after bare refocus'
-assert state['current_phase'] == 'reground', 'state.json current_phase should reset to reground after bare refocus'
-assert state['requires_reground'] is True, 'state.json requires_reground should be true after bare refocus'
-assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should reset to completion-regrounder after bare refocus'
-assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'continuation_reason should record the bare refocus'
-assert plan['plan_basis'] == 'user_refocus', 'plan.json plan_basis should be user_refocus after bare refocus'
-assert active['status'] == 'idle', 'active-slice.json status should reset to idle after bare refocus'
-PY
-
-SYNTH_REPLACEMENT_SESSION="$TMPDIR/session-synthesized-active-replacement.jsonl"
-SYNTH_REPLACEMENT_ROUTING="$TMPDIR/synthesized-active-replacement-routing.json"
-SYNTH_REPLACEMENT_PROPOSAL="$TMPDIR/synthesized-active-replacement-proposal.json"
-write_session "$SYNTH_REPLACEMENT_SESSION" "$TMPDIR" "Please replace the current workflow with the synthesized replacement mission when I run /cook."
+routing = json.loads(Path(sys.argv[1]).read_text())
+chooser = json.loads(Path(sys.argv[2]).read_text())
+proposal = json.loads(Path(sys.argv[3]).read_text())
+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}
 
-SYNTH_REPLACEMENT_HANDOFF="$(python3 - <<'PY'
-import json
-capsule = {
-    "kind": "cook_handoff",
-    "source": "primary_agent",
-    "captured_at": "2026-01-01T00:00:02.000Z",
-    "source_turn_id": "generated-primary-agent-handoff",
-    "mission": "Exercise same-entry active-workflow replacement synthesis.",
-    "scope": [
-        "Generate the replacement handoff inside the same /cook entry.",
-        "Keep the chooser and final Start/Cancel confirmation truthful."
-    ],
-    "constraints": [
-        "Do not rewrite canonical state before the final Start confirmation."
-    ],
-    "acceptance": [
-        "Replace the active workflow using the synthesized primary-agent handoff.",
-        "Keep deterministic coverage for same-entry active replacement."
-    ],
-    "risks": [],
-    "notes": [
-        "This replacement is synthesized during /cook rather than pre-authored in the transcript."
-    ],
-    "handoff_kind": "implementation_workflow_handoff",
-    "first_slice_goal": "Exercise same-entry active-workflow replacement synthesis.",
-    "first_slice_non_goals": [],
-    "implementation_surfaces": [
-        "scripts/refocus-test.sh"
-    ],
-    "verification_commands": [
-        "npm run refocus-test"
-    ],
-    "why_this_slice_first": "Active replacement should work when the primary-agent handoff is synthesized in the same /cook entry.",
-    "task_type": "completion-workflow",
-    "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The user explicitly chose workflow mode and the replacement handoff can be synthesized immediately."
-}
-print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+assert routing['action'] == 'refocus', routing
+assert routing['reason'] == 'generated_replacement_startup_plan', routing
+assert chooser['choices'][1].startswith('Start new workflow from same-entry primary-agent startup plan'), chooser
+assert proposal['source'] == 'deferred_primary_agent_handoff', proposal
+assert proposal['mission'] == 'Remove the completion status line while keeping the completion widget.', proposal
+assert before == after, 'final Start/Cancel cancel should leave canonical workflow files unchanged'
+assert 'Cancelled replacement workflow proposal.' in output, output
 PY
-)"
 
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$SYNTH_REPLACEMENT_HANDOFF" \
+# Case 3: accepting the synthesized replacement rewrites canonical mission and startup plan.
+ROOT_THREE="$TMPDIR/repo-three"
+SESSION_THREE_BOOTSTRAP="$TMPDIR/session-three-bootstrap.jsonl"
+SESSION_THREE_REFOCUS="$TMPDIR/session-three-refocus.jsonl"
+ROUTING_THREE="$TMPDIR/routing-three.json"
+CHOOSER_THREE="$TMPDIR/chooser-three.json"
+PROPOSAL_THREE="$TMPDIR/proposal-three.json"
+bootstrap_active_workflow "$ROOT_THREE" "$SESSION_THREE_BOOTSTRAP" "$BOOTSTRAP_DISCUSSION" "$BOOTSTRAP_HANDOFF"
+cd "$ROOT_THREE"
+write_session "$SESSION_THREE_REFOCUS" "$ROOT_THREE" "$REPLACEMENT_DISCUSSION"
+
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$REPLACEMENT_HANDOFF" \
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$SYNTH_REPLACEMENT_PROPOSAL" \
-PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$SYNTH_REPLACEMENT_ROUTING" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SYNTH_REPLACEMENT_SESSION" -e "$PKG_ROOT" -p "/cook" \
-  >"$TMPDIR/pi-completion-synthesized-active-replacement.out" 2>"$TMPDIR/pi-completion-synthesized-active-replacement.err"
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_THREE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_THREE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$PROPOSAL_THREE" \
+pi --session "$SESSION_THREE_REFOCUS" -e "$PKG_ROOT" -p "/cook" \
+  >"$TMPDIR/refocus-three.out" 2>"$TMPDIR/refocus-three.err"
 
-python3 - "$SYNTH_REPLACEMENT_PROPOSAL" "$SYNTH_REPLACEMENT_ROUTING" <<'PY'
+python3 - "$ROUTING_THREE" "$CHOOSER_THREE" "$PROPOSAL_THREE" "$TMPDIR/refocus-three.out" "$TMPDIR/refocus-three.err" <<'PY'
 import json
 import sys
 from pathlib import Path
 
-new_anchor = 'Exercise same-entry active-workflow replacement synthesis.'
-proposal = json.loads(Path(sys.argv[1]).read_text())
-routing = json.loads(Path(sys.argv[2]).read_text())
+routing = json.loads(Path(sys.argv[1]).read_text())
+chooser = json.loads(Path(sys.argv[2]).read_text())
+proposal = json.loads(Path(sys.argv[3]).read_text())
+output = Path(sys.argv[4]).read_text() + Path(sys.argv[5]).read_text()
 state = json.loads(Path('.agent/state.json').read_text())
+startup_plan = json.loads(Path('.agent/startup-plan.json').read_text())
+startup_plan_md = Path('.agent/startup-plan.md').read_text()
 plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
 
-assert proposal['mission'] == new_anchor, 'same-entry synthesized replacement should preserve the replacement proposal mission'
-assert routing['action'] == 'refocus', 'same-entry synthesized replacement should classify active bare /cook as refocus'
-assert routing['reason'] == 'fresh_explicit_handoff', 'same-entry synthesized replacement should reuse the explicit-handoff routing reason because /cook synthesized an explicit handoff'
-assert routing['proposalSource'] == 'handoff_capsule', 'same-entry synthesized replacement should surface the synthesized handoff as a handoff capsule source'
-assert state['mission_anchor'] == new_anchor, 'state.json mission_anchor mismatch after same-entry synthesized refocus'
-assert plan['mission_anchor'] == new_anchor, 'plan.json mission_anchor mismatch after same-entry synthesized refocus'
-assert active['mission_anchor'] == new_anchor, 'active-slice.json mission_anchor mismatch after same-entry synthesized refocus'
-assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'same-entry synthesized replacement should record the /cook refocus continuation reason'
+mission = 'Remove the completion status line while keeping the completion widget.'
+assert routing['action'] == 'refocus', routing
+assert routing['reason'] == 'generated_replacement_startup_plan', routing
+assert chooser['choices'][1].startswith('Start new workflow from same-entry primary-agent startup plan'), chooser
+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 '## Goal' in startup_plan_md and mission in startup_plan_md, startup_plan_md
+assert plan['mission_anchor'] == mission, plan
+assert active['mission_anchor'] == mission, active
+assert 'Refocused completion mission from same-entry primary-agent startup plan' in output, output
 PY
 
-echo "refocus test passed: $TMPDIR"
+echo "refocus test passed: $PKG_ROOT"