@linimin/pi-letscook 0.1.36 → 0.1.37

package/scripts/context-proposal-test.sh

@@ -101,20 +101,102 @@ mkdir -p "$ROOT"
 cd "$ROOT"
 git init -q
 
-# No workflow yet: /cook with no goal should not bootstrap from discussion alone when analyst output is unavailable.
+# No workflow yet: bare /cook should use strict structured discussion fallback when analyst output is unavailable.
 SESSION_ZERO="$TMPDIR/session-zero.jsonl"
 DISCUSSION_ZERO=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\n- Suppress the widget while a completion role is active.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\n- Keep observability regression coverage truthful.'
+DISCUSSION_SNAPSHOT_ZERO="$TMPDIR/context-proposal-structured-fallback.json"
 write_session "$SESSION_ZERO" "$ROOT" "$DISCUSSION_ZERO"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_ZERO" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_ZERO" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-no-analyst.out 2>/tmp/pi-completion-context-proposal-no-analyst.err
+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 - <<'PY'
+python3 - "$DISCUSSION_SNAPSHOT_ZERO" <<'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())
+
+assert Path('.agent').exists(), 'strict structured fallback should only create canonical state after Start is accepted'
+assert mission in mission_text, '.agent/mission.md did not record the structured-fallback mission anchor'
+assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after structured-fallback bootstrap'
+assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after structured-fallback bootstrap'
+assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after structured-fallback bootstrap'
+assert state['task_type'] == expected_task_type, 'state.json task_type mismatch after structured-fallback bootstrap'
+assert state['evaluation_profile'] == expected_eval_profile, 'state.json evaluation_profile mismatch after structured-fallback bootstrap'
+assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after structured-fallback bootstrap'
+assert plan['task_type'] == expected_task_type, 'plan.json task_type mismatch after structured-fallback bootstrap'
+assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluation_profile mismatch after structured-fallback bootstrap'
+assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after structured-fallback bootstrap'
+assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after structured-fallback bootstrap'
+assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after structured-fallback bootstrap'
+assert proposal['mission'] == mission, 'structured-fallback proposal snapshot should preserve the discussion mission anchor'
+assert proposal['source'] == 'session', 'structured-fallback proposal snapshot should record the strict session fallback source'
+assert proposal['scope'] == ['Keep the non-running completion widget.', 'Suppress the widget while a completion role is active.'], 'structured-fallback proposal snapshot should preserve discussion scope'
+assert proposal['constraints'] == ['Do not reintroduce any other completion status surface.'], 'structured-fallback proposal snapshot should preserve discussion constraints'
+assert proposal['acceptance'] == ['Update README to match the shipped behavior.', 'Keep observability regression coverage truthful.'], 'structured-fallback proposal snapshot should preserve discussion acceptance'
+assert state['current_phase'] == 'reground', 'state.json current_phase should start at reground after structured-fallback bootstrap'
+assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should start at completion-regrounder after structured-fallback bootstrap'
+assert state['continuation_reason'].startswith('User started workflow via /cook:'), 'structured-fallback startup should record the accepted startup routing in continuation_reason'
+assert 'task_type=completion-workflow' in state['continuation_reason'], 'structured-fallback startup should persist the selected task_type in continuation_reason'
+assert 'evaluation_profile=completion-rubric-v1' in state['continuation_reason'], 'structured-fallback startup should persist the selected evaluation_profile in continuation_reason'
+PY
+
+rm -rf .agent
+
+# No workflow yet: bare /cook should fail closed when a required structured section is missing and analyst output is unavailable.
+SESSION_ZERO_MISSING="$TMPDIR/session-zero-missing-section.jsonl"
+DISCUSSION_ZERO_MISSING=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\n- Suppress the widget while a completion role is active.\nConstraints:\n- Do not reintroduce any other completion status surface.'
+DISCUSSION_SNAPSHOT_ZERO_MISSING="$TMPDIR/context-proposal-missing-section.json"
+write_session "$SESSION_ZERO_MISSING" "$ROOT" "$DISCUSSION_ZERO_MISSING"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_ZERO_MISSING" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO_MISSING" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-missing-section.out" 2>"$TMPDIR/pi-completion-context-proposal-missing-section.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-missing-section.out" "$TMPDIR/pi-completion-context-proposal-missing-section.err" "$DISCUSSION_SNAPSHOT_ZERO_MISSING" <<'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(), 'missing-section structured discussion should fail closed without writing canonical state'
+assert not snapshot.exists(), 'missing-section structured discussion should not emit a proposal snapshot when bare /cook fails closed'
+assert 'Bare /cook failed closed' in output, 'missing-section structured discussion should explain the fail-closed startup outcome'
+assert 'Mission/Scope/Constraints/Acceptance' in output, 'missing-section structured discussion should explain the strict fallback requirement'
+PY
+
+# No workflow yet: bare /cook should fail closed on ambiguous structured discussion when analyst output is unavailable.
+SESSION_ZERO_AMBIG="$TMPDIR/session-zero-ambiguous.jsonl"
+DISCUSSION_ZERO_AMBIG=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\nMission: Ship an unrelated widget overhaul.\nScope:\n- Replace the widget entirely.'
+write_session "$SESSION_ZERO_AMBIG" "$ROOT" "$DISCUSSION_ZERO_AMBIG"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO_AMBIG" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ambiguous.out" 2>"$TMPDIR/pi-completion-context-proposal-ambiguous.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-ambiguous.out" "$TMPDIR/pi-completion-context-proposal-ambiguous.err" <<'PY'
+import sys
 from pathlib import Path
 
-assert not Path('.agent').exists(), '/cook should not bootstrap canonical state from discussion alone without analyst output'
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+assert not Path('.agent').exists(), 'ambiguous structured discussion should fail closed without writing canonical state'
+assert 'Bare /cook failed closed' in output, 'ambiguous structured discussion should explain the fail-closed startup outcome'
+assert 'Mission/Scope/Constraints/Acceptance' in output, 'ambiguous structured discussion should explain the strict fallback requirement'
 PY
 
 # No workflow yet: /cook with no goal should infer from recent discussion through analyst output.
@@ -173,21 +255,64 @@ assert 'evaluation_profile=completion-rubric-v1' in state['continuation_reason']
 assert 'Keep critique separate from the mission anchor so startup analysis does not rewrite the workflow goal.' in state['continuation_reason'], 'initial startup should persist the accepted critique outcome in continuation_reason'
 PY
 
-# Completed workflow: /cook with no goal should infer the next round from recent discussion through analyst output.
+# Active workflow: bare /cook with matching structured discussion should classify as continue
+# and resume the current workflow without opening the chooser or rewriting canonical state.
+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"
+write_session "$SESSION_ONE_CONTINUE" "$ROOT" "$DISCUSSION_ONE_CONTINUE"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=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_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" <<'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])
+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', 'active bare /cook continue regression should snapshot bare routing mode'
+assert routing['action'] == 'continue', 'matching structured discussion should classify active bare /cook as continue'
+assert routing['reason'] == 'matching_mission', 'matching structured discussion should keep the current mission rather than refocus'
+assert routing['currentMissionAnchor'] == mission, 'continue routing should preserve the current mission anchor'
+assert routing['proposedMissionAnchor'] == mission, 'continue routing should keep the proposed mission anchored to the current mission'
+assert 'Resume the completion workflow from canonical state.' in resume, 'active bare /cook continue should still use the canonical resume prompt'
+assert not chooser_path.exists(), 'active bare /cook continue should not open the refocus chooser'
+assert state['mission_anchor'] == mission, 'active bare /cook continue should keep state.json unchanged'
+assert plan['mission_anchor'] == mission, 'active bare /cook continue should keep plan.json unchanged'
+assert active['mission_anchor'] == mission, 'active bare /cook continue should keep active-slice.json unchanged'
+PY
+
+# Completed workflow: bare /cook should use the same strict structured fallback for the next workflow round when analyst output is unavailable.
 mark_done
 
 SESSION_TWO="$TMPDIR/session-two.jsonl"
 DISCUSSION_TWO=$'Mission: Ship the next workflow round for richer context-derived /cook startup.\nScope:\n- Start a new workflow round from recent discussion after the previous one is done.\n- Keep using canonical .agent state after confirmation.\nConstraints:\n- Do not resume the completed workflow when the new round is clearly different.\nAcceptance:\n- Reset canonical state back to reground for the new mission.\n- Preserve the tracked completion control-plane files.'
-ANALYST_OUTPUT_TWO='{"mission":"Ship the next workflow round for richer context-derived /cook startup.","scope":["Start a new workflow round from recent discussion after the previous one is done.","Keep using canonical .agent state after confirmation."],"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."],"confidence":0.93}'
+DISCUSSION_SNAPSHOT_TWO="$TMPDIR/context-proposal-next-round-structured-fallback.json"
 write_session "$SESSION_TWO" "$ROOT" "$DISCUSSION_TWO"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$ANALYST_OUTPUT_TWO" \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_TWO" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-next-round.out 2>/tmp/pi-completion-context-proposal-next-round.err
+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 - <<'PY'
+python3 - "$DISCUSSION_SNAPSHOT_TWO" <<'PY'
 import json
+import sys
 from pathlib import Path
 
 mission = 'Ship the next workflow round for richer context-derived /cook startup.'
@@ -198,6 +323,7 @@ profile = json.loads(Path('.agent/profile.json').read_text())
 state = json.loads(Path('.agent/state.json').read_text())
 plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
+proposal = json.loads(Path(sys.argv[1]).read_text())
 
 assert mission in mission_text, '.agent/mission.md did not update to the next-round context-derived mission anchor'
 assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after next-round startup'
@@ -211,6 +337,8 @@ assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluatio
 assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after starting the next workflow round'
 assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after starting the next workflow round'
 assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after starting the next workflow round'
+assert proposal['mission'] == mission, 'next-round structured-fallback proposal snapshot should preserve the discussion mission anchor'
+assert proposal['source'] == 'session', 'next-round structured-fallback proposal snapshot should record the strict session fallback 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'
@@ -224,25 +352,32 @@ assert plan['plan_basis'] == 'user_refocus', 'plan_basis should reset to user_re
 assert active['status'] == 'idle', 'active-slice should reset to idle for the next workflow round'
 PY
 
-# Active workflow: /cook <goal> plus refocus should use the explicit goal as the mission anchor
-# even when analyst output is unavailable, without falling back to session-derived proposal parsing.
+# Active workflow: /cook <goal> plus refocus should keep the explicit goal as the mission anchor
+# even when analyst output is unavailable and structured session fallback is present.
 SESSION_THREE="$TMPDIR/session-three.jsonl"
 DISCUSSION_THREE=$'Scope:\n- Preserve the richer proposal structure from discussion.\nConstraints:\n- Keep explicit goals as the mission anchor when they conflict with earlier text.\nAcceptance:\n- Refresh canonical state from the replacement mission.'
+DISCUSSION_SNAPSHOT_THREE="$TMPDIR/context-proposal-active-goal.json"
+ROUTING_SNAPSHOT_THREE="$TMPDIR/context-proposal-active-goal-routing.json"
 write_session "$SESSION_THREE" "$ROOT" "$DISCUSSION_THREE"
 
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_THREE" \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ROUTING_SNAPSHOT_THREE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_THREE" -e "$PKG_ROOT" -p "/cook Explicit replacement mission for the active workflow" >/tmp/pi-completion-context-proposal-active-goal.out 2>/tmp/pi-completion-context-proposal-active-goal.err
+pi --session "$SESSION_THREE" -e "$PKG_ROOT" -p "/cook Explicit replacement mission for the active workflow" >"$TMPDIR/pi-completion-context-proposal-active-goal.out" 2>"$TMPDIR/pi-completion-context-proposal-active-goal.err"
 
-python3 - <<'PY'
+python3 - "$DISCUSSION_SNAPSHOT_THREE" "$ROUTING_SNAPSHOT_THREE" <<'PY'
 import json
+import sys
 from pathlib import Path
 
 mission = 'Explicit replacement mission for the active workflow.'
 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())
@@ -261,6 +396,11 @@ assert plan['evaluation_profile'] == expected_eval_profile, 'plan.json evaluatio
 assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after explicit-goal replacement'
 assert active['task_type'] == expected_task_type, 'active-slice.json task_type mismatch after explicit-goal replacement'
 assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after explicit-goal replacement'
+assert proposal['mission'] == mission, 'explicit-goal replacement should route through the shared proposal confirmation pipeline'
+assert routing['mode'] == 'explicit', 'explicit-goal replacement should snapshot explicit active-workflow routing mode'
+assert routing['action'] == 'refocus', 'explicit-goal replacement should classify as refocus when the mission changes'
+assert routing['reason'] == 'explicit_goal', 'explicit-goal replacement should record the explicit-goal routing reason'
+assert routing['proposedMissionAnchor'] == mission, 'explicit-goal routing should expose the replacement mission anchor'
 assert state['current_phase'] == 'reground', 'current_phase should reset to reground after explicit-goal replacement'
 assert state['continuation_policy'] == 'continue', 'continuation_policy should stay continue after explicit-goal replacement'
 assert state['next_mandatory_role'] == 'completion-regrounder', 'next role should reset to completion-regrounder after explicit-goal replacement'

package/scripts/refocus-test.sh

@@ -5,10 +5,49 @@ PKG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 TMPDIR="$(mktemp -d)"
 trap 'rm -rf "$TMPDIR"' EXIT
 
+write_session() {
+  local session_path="$1"
+  local cwd="$2"
+  local text="$3"
+  python3 - "$session_path" "$cwd" "$text" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+session_path = Path(sys.argv[1])
+cwd = sys.argv[2]
+text = 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,
+    },
+    {
+        "type": "message",
+        "id": "a1b2c3d4",
+        "parentId": None,
+        "timestamp": "2026-01-01T00:00:01.000Z",
+        "message": {
+            "role": "user",
+            "content": text,
+            "timestamp": 1767225601000,
+        },
+    },
+]
+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
 
-pi -e "$PKG_ROOT" -p "/cook smoke-test mission" >/tmp/pi-completion-refocus-bootstrap.out 2>/tmp/pi-completion-refocus-bootstrap.err &
+pi -e "$PKG_ROOT" -p "/cook smoke-test mission" >"$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
@@ -18,7 +57,7 @@ for _ in $(seq 1 60); do
 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 /tmp/pi-completion-refocus-bootstrap.err >&2 || true
+  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
@@ -39,9 +78,9 @@ PI_COMPLETION_EXISTING_WORKFLOW_ACTION=cancel \
 PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$CHOOSER_SNAPSHOT" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi -e "$PKG_ROOT" -p "/cook replacement mission that should stay in the main chat" \
-  >/tmp/pi-completion-refocus-cancel.out 2>/tmp/pi-completion-refocus-cancel.err
+  >"$TMPDIR/pi-completion-refocus-cancel.out" 2>"$TMPDIR/pi-completion-refocus-cancel.err"
 
-python3 - "$CHOOSER_SNAPSHOT" "/tmp/pi-completion-refocus-cancel.out" "/tmp/pi-completion-refocus-cancel.err" "$INITIAL_MISSION" <<'PY'
+python3 - "$CHOOSER_SNAPSHOT" "$TMPDIR/pi-completion-refocus-cancel.out" "$TMPDIR/pi-completion-refocus-cancel.err" "$INITIAL_MISSION" <<'PY'
 import json
 import sys
 from pathlib import Path
@@ -58,25 +97,29 @@ assert plan['mission_anchor'] == initial_mission, 'cancelled chooser should keep
 assert active['mission_anchor'] == initial_mission, 'cancelled chooser should keep active-slice.json unchanged'
 assert chooser['title'].startswith('Existing completion workflow found'), 'chooser snapshot should describe the existing-workflow prompt'
 assert chooser['choices'][0].startswith('Continue current workflow'), 'chooser should keep the continue option'
-assert chooser['choices'][1].startswith('Abandon current workflow and start this new one'), 'chooser should keep the refocus option'
+assert chooser['choices'][1].startswith('Abandon current workflow and start this new one'), 'chooser should keep the explicit-goal refocus option'
 assert 'Start/Cancel confirmation' in chooser['choices'][1], 'chooser should mention the approval-only replacement confirmation'
 assert chooser['choices'][2].startswith('Cancel'), 'chooser should keep the cancel option'
 assert 'Discuss changes in the main chat and rerun /cook.' in chooser['choices'][2], 'chooser cancel copy should redirect users back to the main chat and rerun /cook'
 assert 'Discuss changes in the main chat and rerun /cook.' in output, 'chooser cancel output should redirect users back to the main chat and rerun /cook'
 PY
 
+EXPLICIT_ROUTING_SNAPSHOT="$TMPDIR/explicit-goal-routing.json"
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$EXPLICIT_ROUTING_SNAPSHOT" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi -e "$PKG_ROOT" -p "/cook refocused smoke-test mission with tests and docs" \
-  >/tmp/pi-completion-refocus.out 2>/tmp/pi-completion-refocus.err
+pi -e "$PKG_ROOT" -p "/cook Remove completion status line, keep widget" \
+  >"$TMPDIR/pi-completion-refocus.out" 2>"$TMPDIR/pi-completion-refocus.err"
 
-python3 - <<'PY'
+python3 - "$EXPLICIT_ROUTING_SNAPSHOT" <<'PY'
 import json
+import sys
 from pathlib import Path
 
-new_anchor = 'refocused smoke-test mission with tests and docs parity.'
+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())
@@ -101,6 +144,10 @@ assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_
 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'] == 'explicit', 'explicit /cook <goal> should use explicit active-workflow routing mode'
+assert routing['action'] == 'refocus', 'explicit /cook <goal> should classify as refocus when the mission changes'
+assert routing['reason'] == 'explicit_goal', 'explicit /cook <goal> should record the explicit-goal routing reason'
+assert routing['proposedMissionAnchor'] == new_anchor, 'explicit routing snapshot should expose the replacement mission anchor'
 PY
 
 UPDATED_MISSION="$(python3 - <<'PY'
@@ -112,8 +159,148 @@ PY
 )"
 
 if [[ "$INITIAL_MISSION" == "$UPDATED_MISSION" ]]; then
-  echo "expected mission anchor to change during refocus" >&2
+  echo "expected mission anchor to change during explicit refocus" >&2
   exit 1
 fi
 
+# Negated replacement missions that contain the current anchor must still reach the conservative chooser and final Start/Cancel gate.
+BARE_REFOCUS_MISSION='Do not remove completion status line, keep widget.'
+BARE_REFOCUS_DISCUSSION=$'Mission: Do not remove completion status line, keep widget.\nScope:\n- Treat the active bare /cook discussion as a replacement workflow rather than a resume.\n- Keep the replacement behind the existing approval-only Start/Cancel gate.\nConstraints:\n- Do not rewrite canonical state before the final Start confirmation.\nAcceptance:\n- Add deterministic coverage proving the chooser and final approval path for this negated replacement mission.'
+
+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 "$SESSION_BARE_CHOOSER_CANCEL" "$TMPDIR" "$BARE_REFOCUS_DISCUSSION"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+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"
+
+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'
+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())
+
+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 routing['action'] == 'refocus', 'clear structured discussion should classify active bare /cook as refocus'
+assert routing['reason'] == 'clear_refocus', 'clear structured discussion should record the clear-refocus routing reason'
+assert routing['currentMissionAnchor'] == updated_mission, 'clear-refocus routing should keep the current mission anchor until the user approves replacement'
+assert routing['proposedMissionAnchor'] == replacement_mission, 'clear-refocus routing should expose the proposed replacement mission'
+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 recent discussion'), 'bare chooser should offer the recent-discussion refocus 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'
+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 "$SESSION_BARE_FINAL_CANCEL" "$TMPDIR" "$BARE_REFOCUS_DISCUSSION"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+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"
+
+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'
+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 a clear-refocus classification'
+assert routing['reason'] == 'clear_refocus', 'final Start/Cancel cancel should preserve the clear-refocus 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 '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 "$SESSION_BARE_ACCEPT" "$TMPDIR" "$BARE_REFOCUS_DISCUSSION"
+
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+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 = 'Do not remove completion status line, keep widget.'
+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 routing['action'] == 'refocus', 'accepted bare refocus should keep the clear-refocus classification'
+assert routing['reason'] == 'clear_refocus', 'accepted bare refocus should keep the clear-refocus reason'
+assert routing['currentMissionAnchor'] == 'Remove completion status line, keep widget.', 'accepted bare refocus should expose the original mission until Start is accepted'
+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 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
+
 echo "refocus test passed: $TMPDIR"

package/scripts/release-check.sh

@@ -4,8 +4,42 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT"
 
-echo "[release-check] running control-plane validation, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, evaluator calibration, and rubric contract coverage"
+echo "[release-check] running control-plane validation, public /cook parity, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, evaluator calibration, and rubric contract coverage"
 bash .agent/verify_completion_control_plane.sh
+
+echo "[release-check] verifying public /cook single-command parity"
+python3 - <<'PY'
+from pathlib import Path
+
+checks = {
+    "README.md": [
+        "Bare `/cook` is now the primary workflow entrypoint.",
+        "`/cook <text>` is still supported as a temporary compatibility shim",
+        "Matching or unclear discussion resumes from canonical `.agent/**` state.",
+        "approval-only Start/Cancel gate",
+        "Start new workflow from recent discussion",
+        "fails closed instead of guessing",
+    ],
+    "CHANGELOG.md": [
+        "single public discussion-first workflow command",
+        "temporary compatibility shim",
+        "approval-only Start/Cancel gate",
+        "fail-closed ambiguous-discussion behavior",
+        "release-gated public-parity assertions",
+    ],
+    "extensions/completion/index.ts": [
+        'description: "Discussion-driven /cook workflow: start, continue, refocus, or start the next round"',
+        "temporary compatibility shim, pass /cook <text>",
+    ],
+}
+
+for path, needles in checks.items():
+    text = Path(path).read_text()
+    for needle in needles:
+        if needle not in text:
+            raise SystemExit(f"[release-check] missing expected public /cook parity text in {path}: {needle}")
+PY
+
 npm run smoke-test
 npm run refocus-test
 npm run context-proposal-test

package/scripts/smoke-test.sh

@@ -8,6 +8,8 @@ trap 'rm -rf "$TMPDIR"' EXIT
 ROOT="$TMPDIR/repo"
 KICKOFF_PROMPT="$TMPDIR/kickoff-prompt.txt"
 RESUME_PROMPT="$TMPDIR/resume-prompt.txt"
+UNCLEAR_ROUTING_SNAPSHOT="$TMPDIR/active-unclear-routing.json"
+UNCLEAR_CHOOSER_SNAPSHOT="$TMPDIR/unexpected-existing-workflow-chooser.json"
 AUTO_RESUME_PROMPT="$TMPDIR/auto-resume-prompt.txt"
 
 mkdir -p "$ROOT"
@@ -62,20 +64,32 @@ PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$RESUME_PROMPT" \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$UNCLEAR_ROUTING_SNAPSHOT" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$UNCLEAR_CHOOSER_SNAPSHOT" \
 pi -e "$PKG_ROOT" -p "/cook" \
   >"$TMPDIR/pi-completion-smoke-resume.out" 2>"$TMPDIR/pi-completion-smoke-resume.err"
 
-python3 - "$RESUME_PROMPT" <<'PY'
+python3 - "$RESUME_PROMPT" "$UNCLEAR_ROUTING_SNAPSHOT" "$UNCLEAR_CHOOSER_SNAPSHOT" <<'PY'
+import json
 import sys
 from pathlib import Path
 
 expected_task_type = 'completion-workflow'
 expected_eval_profile = 'completion-rubric-v1'
 resume = Path(sys.argv[1]).read_text()
+routing = json.loads(Path(sys.argv[2]).read_text())
+chooser_path = Path(sys.argv[3])
+state = json.loads(Path('.agent/state.json').read_text())
 
 assert 'Canonical routing profile:' in resume, 'resume prompt should expose canonical routing profile'
 assert f'- task_type: {expected_task_type}' in resume, 'resume prompt missing canonical task_type'
 assert f'- evaluation_profile: {expected_eval_profile}' in resume, 'resume prompt missing canonical evaluation_profile'
+assert routing['mode'] == 'bare', 'active bare /cook should snapshot bare routing mode'
+assert routing['action'] == 'unclear', 'no-discussion active bare /cook should classify as unclear'
+assert routing['reason'] == 'missing_proposal', 'no-discussion active bare /cook should fail closed because no replacement proposal was derived'
+assert routing['currentMissionAnchor'] == state['mission_anchor'], 'unclear routing snapshot should keep the current mission anchor'
+assert routing['proposedMissionAnchor'] is None, 'unclear no-discussion routing should not propose a replacement mission'
+assert not chooser_path.exists(), 'unclear active bare /cook should fall back to resume without opening the chooser'
 PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \