@linimin/pi-letscook 0.1.68 → 0.1.69

package/scripts/release-check.sh

@@ -5,42 +5,42 @@ ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT"
 export PI_COMPLETION_RUNNING_RELEASE_CHECK=1
 
-echo "[release-check] running control-plane validation, tracked .agent contract coverage, slice-surface parity, /cook startup-plan parity, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, legacy cleanup, evaluator calibration, and rubric contract coverage"
+echo "[release-check] running control-plane validation, tracked .agent contract coverage, slice-surface parity, explicit-/cook parity, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, legacy cleanup, evaluator calibration, and rubric contract coverage"
 bash .agent/verify_completion_control_plane.sh
 git ls-files --error-unmatch .agent/README.md .agent/mission.md .agent/profile.json .agent/verify_completion_stop.sh .agent/verify_completion_control_plane.sh >/dev/null
 
-echo "[release-check] verifying public /cook parity and startup-plan docs/help"
+echo "[release-check] verifying public /cook parity and primary-agent-handoff docs/help"
 python3 - <<'PY'
 from pathlib import Path
 
 checks = {
     "README.md": [
         "You can still implement directly in ordinary chat when you do not need workflow state.",
-        "When you explicitly run `/cook`, it always calls a same-entry primary-agent startup-plan synthesis step from the current task context, then asks you to **Start** or **Cancel** before rewriting canonical workflow state.",
-        "After **Start**, the approved startup plan is written into `.agent/startup-plan.json` / `.agent/startup-plan.md`, and `completion-regrounder` uses it to derive canonical slices from current repo truth.",
-        "Optional preview capsules in ordinary chat are advisory only. `/cook` does not directly consume them as approval-ready workflow state; it synthesizes a fresh startup plan in the `/cook` entry.",
+        "When you explicitly run `/cook`, it first checks for a fresh explicit primary-agent handoff.",
+        "If one is missing, it calls a same-entry primary-agent handoff synthesis step from the current task context, then asks you to **Start** or **Cancel** before rewriting canonical workflow state.",
+        "Explicit `/cook` capsules are still valid startup intake, but they are no longer the only path because `/cook` can synthesize the primary-agent handoff in the same entry when needed.",
     ],
     "CHANGELOG.md": [
-        "simplified `/cook` startup sourcing so workflow proposals now come only from same-entry primary-agent startup-plan synthesis",
-        "stopped `/cook` from directly adopting old preview capsules or falling back to transcript-derived startup proposals",
+        "preserved the confirmed `/cook` startup intent in canonical `.agent/startup-brief.json` so workflow entry is durable before regrounding authors canonical slices",
+        "moved workflow-session legitimacy away from in-memory routing activation and legacy `/skill:completion-protocol` prompt dependence toward canonical workflow-session state plus explicit `/cook` entry turns",
     ],
     "extensions/completion/prompt-surfaces.ts": [
-        '"If the user explicitly runs /cook, the extension should call a primary-agent startup-plan synthesis step from the current task context, show Start/Cancel confirmation in the same /cook entry, and only write the approved plan into .agent after Start."',
-        '"Do not expect /cook to infer or guess startup intent from recent discussion alone, and do not expect /cook to directly reuse an old preview capsule; /cook should always synthesize the startup plan fresh in the same entry from current task context."',
+        '"If the user explicitly runs /cook, the extension should call a primary-agent handoff synthesis step from the current task context, show Start/Cancel confirmation, and persist the confirmed startup brief into .agent/** without making the user rerun /cook."',
+        '"Do not expect /cook to infer or guess startup intent from recent discussion alone; /cook should use explicit primary-agent handoff data, whether it already exists or is synthesized in the same /cook entry."',
         '"In ordinary chat, do not load or follow completion-protocol, and do not call completion_role."',
     ],
     "extensions/completion/index.ts": [
-        '"/cook failed closed because the startup-plan step could not prepare a concrete workflow startup plan from the current task context. Clarify the mission, scope, acceptance, or verification intent in the main chat, then rerun /cook."',
-        'description: "/cook workflow: capture the approved startup plan into .agent, let completion-regrounder split canonical slices, or resume the current workflow from canonical state"',
-        '"Do not call completion_role from ordinary chat; it is reserved for explicit /cook workflow driver turns."',
+        '"/cook failed closed because the primary-agent handoff step could not prepare a concrete startup handoff from the current task context. Clarify the mission, first slice, or verification intent in the main chat, then rerun /cook."',
+        'description: "/cook workflow: start or replace workflow only from an explicit primary-agent handoff, or resume the current workflow from canonical state"',
+        '"Do not call completion_role from ordinary chat; it is reserved for active /cook workflow sessions."',
+        '`COMPLETION WORKFLOW DRIVER\\nStart or continue the completion workflow for this repo.',
     ],
     "extensions/completion/policy-guards.ts": [
-        'return "completion_role may only be used from an explicit /cook workflow driver turn.";',
+        'return "completion_role may only be used from an active /cook workflow session.";',
     ],
     "skills/cook-handoff-boundary/SKILL.md": [
         '- load or follow `completion-protocol` while still in ordinary chat',
         '- call `completion_role` before the user has explicitly entered `/cook`',
-        '- `/cook` should always synthesize the startup plan fresh in the same entry from current task context',
     ],
     "skills/completion-protocol/SKILL.md": [
         'Load this skill only after the user explicitly enters `/cook` and you are operating inside the `completion` workflow as the workflow driver or a completion role.',
@@ -52,7 +52,6 @@ forbidden = {
     "README.md": [
         "asks the primary agent to prepare one in the main chat and leaves canonical state unchanged until you rerun /cook",
         "Explicit `/cook` capsules are the required startup intake for new-workflow, next-round, and replacement entry.",
-        "When you explicitly run `/cook`, it first checks for a fresh explicit primary-agent startup-plan preview.",
     ],
     "extensions/completion/prompt-surfaces.ts": [
         '"If the user explicitly asks to enter /cook workflow, generate one fresh ```cook_handoff``` capsule in ordinary chat from the primary-agent view of the task, then tell the user to run /cook."',

package/scripts/role-runner-contract-test.sh

@@ -30,9 +30,9 @@ assertIncludes('extensions/completion/role-runner.ts', 'const transcription = ex
 assertIncludes('extensions/completion/role-runner.ts', 'env: { ...process.env, PI_COMPLETION_ROLE: params.role },');
 assertIncludes('extensions/completion/role-runner.ts', 'async function runContextProposalAnalystSubprocess(');
 assertIncludes('extensions/completion/role-runner.ts', 'export async function analyzeContextProposalWithAgent(');
-assertIncludes('extensions/completion/index.ts', 'import { runCompletionRole } from "./role-runner";');
+assertIncludes('extensions/completion/index.ts', 'import { analyzeContextProposalWithAgent, generateCookHandoffWithAgent, runCompletionRole } from "./role-runner";');
 assertIncludes('extensions/completion/index.ts', 'const result = await runCompletionRole({');
-assertNotIncludes('extensions/completion/index.ts', 'analyzeContextProposalWithAgent');
+assertIncludes('extensions/completion/index.ts', 'const raw = await generateCookHandoffWithAgent({');
 assertNotIncludes('extensions/completion/index.ts', 'const systemPromptTemp = await writeTempFile(runCwd, "pi-cook-proposal-analyst-", CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT);');
 assertNotIncludes('extensions/completion/index.ts', 'const invocation = getPiInvocation(args);');
 assertNotIncludes('extensions/completion/index.ts', 'async function loadAgentDefinition(');

package/scripts/smoke-test.sh

@@ -103,12 +103,13 @@ INLINE_REJECTION_ROUTING_SNAPSHOT="$TMPDIR/inline-arg-routing.json"
 INLINE_REJECTION_PROPOSAL_SNAPSHOT="$TMPDIR/inline-arg-proposal.json"
 INLINE_REJECTION_CHOOSER_SNAPSHOT="$TMPDIR/inline-arg-chooser.json"
 BOOTSTRAP_SESSION="$TMPDIR/session-smoke-bootstrap.jsonl"
-BOOTSTRAP_DISCUSSION=$'Please prepare the packaged smoke-test bootstrap path and tell me when it is ready for /cook.'
-GENERATED_HANDOFF="$(python3 - <<'PY'
+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": "Exercise smoke-test bootstrap.",
     "scope": [
         "Materialize the canonical completion control-plane files.",
@@ -118,14 +119,14 @@ capsule = {
         "Keep startup proposal confirmation approval-only."
     ],
     "acceptance": [
-        "Scaffold .agent/profile.json, .agent/state.json, .agent/plan.json, .agent/active-slice.json, and .agent/verification-evidence.json for the smoke fixture.",
+        "Write the workflow control-plane files under .agent, including profile.json, state.json, active-slice.json, verification-evidence.json, and the slice backlog file, for the smoke fixture.",
         "Keep scripts/smoke-test.sh and kickoff-prompt coverage truthful for packaged bootstrap."
     ],
     "risks": [
-        "Smoke-test bootstrap should stay anchored to same-entry primary-agent startup-plan synthesis."
+        "Smoke-test bootstrap should stay anchored to the fresh explicit handoff."
     ],
     "notes": [
-        "Keep the smoke fixture aligned with the shipped startup-plan-driven startup contract."
+        "Keep the smoke fixture aligned with the shipped explicit-handoff-only startup contract."
     ],
     "handoff_kind": "implementation_workflow_handoff",
     "first_slice_goal": "Scaffold canonical completion files and verify the packaged startup contract.",
@@ -139,12 +140,16 @@ capsule = {
     "verification_commands": [
         "npm run smoke-test"
     ],
-    "why_this_slice_first": "The packaged startup-plan entry path must work before later workflow verification can run.",
+    "why_this_slice_first": "The packaged explicit-handoff startup path must work before later workflow verification can run.",
     "task_type": "completion-workflow",
     "evaluation_profile": "completion-rubric-v1",
-    "why_cook_now": "The startup plan is concrete enough to bootstrap canonical workflow files."
+    "why_cook_now": "The startup handoff is concrete enough to bootstrap canonical workflow files."
 }
-print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+messages = [
+    {"role": "user", "content": "Please prepare the packaged smoke-test bootstrap path and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "This bootstrap path is 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
 )"
 
@@ -170,21 +175,21 @@ chooser = Path(sys.argv[5])
 
 assert not Path('.agent').exists(), 'startup /cook inline-args rejection should leave canonical state untouched'
 assert not routing.exists(), 'startup /cook inline-args rejection should not open active-workflow routing before a workflow exists'
-assert not proposal.exists(), 'startup /cook inline-args rejection should not emit a startup-plan proposal snapshot'
+assert not proposal.exists(), 'startup /cook inline-args rejection should not emit a startup-brief proposal snapshot'
 assert not chooser.exists(), 'startup /cook inline-args rejection should not open the existing-workflow chooser before a workflow exists'
 assert '/cook no longer accepts inline arguments.' in output, 'startup /cook inline-args rejection should explain the bare-only entry contract'
 PY
 
-write_session "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_DISCUSSION"
+write_session_messages "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_MESSAGES"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$GENERATED_HANDOFF" \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$KICKOFF_PROMPT" \
 pi --session "$BOOTSTRAP_SESSION" -e "$PKG_ROOT" -p "/cook" \
   >"$TMPDIR/pi-completion-smoke-bootstrap.out" 2>"$TMPDIR/pi-completion-smoke-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
+for file in .agent/profile.json .agent/state.json .agent/startup-brief.json .agent/plan.json .agent/active-slice.json .agent/verification-evidence.json; do
   [[ -f "$file" ]] || { echo "missing canonical bootstrap file: $file" >&2; exit 1; }
 done
 
@@ -204,8 +209,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())
-startup_plan = json.loads(Path('.agent/startup-plan.json').read_text())
-startup_plan_md = Path('.agent/startup-plan.md').read_text()
+startup_brief = json.loads(Path('.agent/startup-brief.json').read_text())
 evidence = json.loads(Path('.agent/verification-evidence.json').read_text())
 kickoff = Path(sys.argv[1]).read_text()
 
@@ -219,28 +223,28 @@ assert active['task_type'] == expected_task_type, 'active-slice.json task_type m
 assert active['evaluation_profile'] == expected_eval_profile, 'active-slice.json evaluation_profile mismatch after bootstrap'
 assert active['implementation_surfaces'] == [], 'active-slice.json should scaffold empty implementation_surfaces'
 assert active['verification_commands'] == [], 'active-slice.json should scaffold empty verification_commands'
+assert state['workflow_entry_status'] == 'active', 'state.json should mark workflow entry active after /cook Start'
+assert state['workflow_entry_source'] == '/cook', 'state.json should record /cook as workflow entry source'
+assert state['startup_brief_path'] == '.agent/startup-brief.json', 'state.json should point to startup-brief.json'
+assert isinstance(state['workflow_session_id'], str) and state['workflow_session_id'], 'state.json should record a workflow session id'
 brief = state['advisory_startup_brief']
 assert brief['kind'] == 'startup_brief', 'state.json should preserve the confirmed startup brief as advisory intake'
-assert brief['source'] == 'deferred_primary_agent_handoff', 'smoke bootstrap should record same-entry primary-agent synthesis in advisory intake'
+assert brief['source'] == 'primary_agent_handoff', 'smoke bootstrap should record the explicit handoff source in advisory intake'
 assert brief['mission'] == state['mission_anchor'], 'advisory startup brief mission should match the canonical mission anchor after bootstrap'
 assert brief['scope'] == ['Materialize the canonical completion control-plane files.', 'Keep the smoke test on supported /cook startup behavior.'], 'advisory startup brief should preserve scope items'
 assert brief['constraints'] == ['Keep startup proposal confirmation approval-only.'], 'advisory startup brief should preserve constraints'
-assert startup_plan['artifact_type'] == 'completion-startup-plan', 'startup-plan.json should persist the approved startup plan canonically'
-assert startup_plan['mission_anchor'] == state['mission_anchor'], 'startup-plan.json mission anchor should match canonical workflow state'
-assert startup_plan['source'] == 'deferred_primary_agent_handoff', 'startup-plan.json should preserve the same-entry primary-agent startup source'
-assert startup_plan['scope'] == brief['scope'], 'startup-plan.json should preserve approved scope items'
-assert startup_plan['constraints'] == brief['constraints'], 'startup-plan.json should preserve approved constraints'
-assert startup_plan['planned_surfaces'] == ['.agent/README.md', 'scripts/smoke-test.sh'], 'startup-plan.json should preserve planned surfaces derived from startup hints'
-assert startup_plan['verification_intent'] == ['npm run smoke-test'], 'startup-plan.json should preserve verification intent derived from startup hints'
-assert '## Planned surfaces' in startup_plan_md, 'startup-plan.md should render planned surfaces as a readable section'
-assert '.agent/README.md' in startup_plan_md and 'scripts/smoke-test.sh' in startup_plan_md, 'startup-plan.md should mirror planned surfaces'
 assert brief['acceptance'] == [
-    'Scaffold .agent/profile.json, .agent/state.json, .agent/plan.json, .agent/active-slice.json, and .agent/verification-evidence.json for the smoke fixture.',
+    'Write the workflow control-plane files under .agent, including profile.json, state.json, active-slice.json, verification-evidence.json, and the slice backlog file, for the smoke fixture.',
     'Keep scripts/smoke-test.sh and kickoff-prompt coverage truthful for packaged bootstrap.'
 ], 'advisory startup brief should preserve acceptance'
-assert brief['risks'] == ['Smoke-test bootstrap should stay anchored to same-entry primary-agent startup-plan synthesis.'], 'advisory startup brief should preserve startup-plan risks'
+assert brief['risks'] == ['Smoke-test bootstrap should stay anchored to the fresh explicit handoff.'], 'advisory startup brief should preserve handoff risks'
 assert 'First slice goal: Scaffold canonical completion files and verify the packaged startup contract.' in brief['notes'], 'advisory startup brief should preserve the first_slice_goal in notes'
 assert 'Verification commands: npm run smoke-test' in brief['notes'], 'advisory startup brief should preserve verification_commands in notes'
+assert startup_brief['artifact_type'] == 'completion-startup-brief', 'startup-brief.json artifact_type mismatch after bootstrap'
+assert startup_brief['mission'] == state['mission_anchor'], 'startup-brief.json mission should match the canonical mission anchor after bootstrap'
+assert startup_brief['task_type'] == expected_task_type, 'startup-brief.json task_type mismatch after bootstrap'
+assert startup_brief['evaluation_profile'] == expected_eval_profile, 'startup-brief.json evaluation_profile mismatch after bootstrap'
+assert startup_brief['acceptance'] == brief['acceptance'], 'startup-brief.json should preserve the confirmed acceptance list'
 assert evidence['artifact_type'] == 'completion-verification-evidence', 'verification-evidence.json artifact_type mismatch after bootstrap'
 assert evidence['subject_type'] == 'none', 'verification-evidence.json should scaffold idle subject_type'
 assert evidence['verification_commands'] == [], 'verification-evidence.json should scaffold empty verification_commands'
@@ -248,6 +252,7 @@ assert evidence['outcome'] == 'not_recorded', 'verification-evidence.json should
 assert 'Canonical routing profile:' in kickoff, 'kickoff prompt should expose canonical routing profile'
 assert f'- task_type: {expected_task_type}' in kickoff, 'kickoff prompt missing canonical task_type'
 assert f'- evaluation_profile: {expected_eval_profile}' in kickoff, 'kickoff prompt missing canonical evaluation_profile'
+assert f'- workflow_session_id: {state["workflow_session_id"]}' in kickoff, 'kickoff prompt should expose canonical workflow_session_id'
 PY
 
 rm -f "$ORDINARY_SYSTEM_REMINDER" "$ORDINARY_HANDOFF_REMINDER" "$ORDINARY_AUTO_RESUME_PROMPT"
@@ -277,9 +282,8 @@ assert 'Do not proactively tell the user to run /cook' in handoff_text, 'ordinar
 assert '/cook is optional workflow mode' in handoff_text, 'ordinary handoff reminder should position /cook as optional workflow mode'
 assert 'In ordinary chat, do not load or follow completion-protocol, and do not call completion_role.' in handoff_text, 'ordinary handoff reminder should forbid workflow-role routing before explicit /cook'
 assert 'If the user wants direct implementation now, stay in ordinary chat and help directly instead of blocking on /cook.' in handoff_text, 'ordinary handoff reminder should avoid blocking implementation on /cook'
-assert 'the extension should call a primary-agent startup-plan synthesis step from the current task context' in handoff_text, 'ordinary handoff reminder should describe same-entry primary-agent startup-plan synthesis for /cook'
+assert 'the extension should call a primary-agent handoff synthesis step from the current task context' in handoff_text, 'ordinary handoff reminder should describe same-entry primary-agent handoff synthesis for /cook'
 assert 'Do not expect /cook to infer or guess startup intent from recent discussion alone' in handoff_text, 'ordinary handoff reminder should forbid /cook-side guessing'
-assert 'the approved startup plan should be written into .agent and then handed to completion-regrounder' in handoff_text, 'ordinary handoff reminder should mention startup-plan persistence and regrounder slice derivation'
 assert 'do not silently rewrite discussion into canonical workflow state' in handoff_text, 'ordinary handoff reminder should preserve non-canonical ordinary-chat behavior'
 assert not auto_resume.exists(), 'ordinary non-/cook turn should not queue auto-resume before /cook activation'
 assert 'Skipped completion workflow auto-resume prompt (test mode)' not in output, 'ordinary non-/cook turn should not attempt auto-resume'
@@ -309,10 +313,10 @@ assert f'- task_type: {expected_task_type}' in resume, 'resume prompt missing ca
 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'] == 'continue', 'no-discussion active bare /cook should resume from canonical state without a concrete replacement mission'
-assert routing['reason'] == 'no_generated_startup_plan', 'no-discussion active bare /cook should explain that resume happened because no synthesized replacement startup plan existed'
+assert routing['reason'] == 'missing_explicit_handoff', 'no-discussion active bare /cook should explain that resume happened because no fresh explicit handoff existed'
 assert routing['currentMissionAnchor'] == state['mission_anchor'], 'resume routing snapshot should keep the current mission anchor'
 assert routing['proposedMissionAnchor'] is None, 'no-discussion active bare /cook should not propose a replacement mission'
-assert not chooser_path.exists(), 'active bare /cook resume should not open the chooser without a synthesized replacement startup plan'
+assert not chooser_path.exists(), 'active bare /cook resume should not open the chooser without a fresh explicit handoff'
 PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
@@ -329,10 +333,12 @@ expected_task_type = 'completion-workflow'
 expected_eval_profile = 'completion-rubric-v1'
 auto_resume = Path(sys.argv[1]).read_text()
 
+state = __import__('json').loads(Path('.agent/state.json').read_text())
 assert 'Resume the completion workflow from canonical state.' in auto_resume, 'auto-resume prompt should use the canonical resume workflow prompt'
 assert 'Canonical routing profile:' in auto_resume, 'auto-resume prompt should expose canonical routing profile'
 assert f'- task_type: {expected_task_type}' in auto_resume, 'auto-resume prompt missing canonical task_type'
 assert f'- evaluation_profile: {expected_eval_profile}' in auto_resume, 'auto-resume prompt missing canonical evaluation_profile'
+assert f'- workflow_session_id: {state["workflow_session_id"]}' in auto_resume, 'auto-resume prompt should expose canonical workflow_session_id'
 PY
 
 python3 - <<'PY'
@@ -383,54 +389,6 @@ active['evaluation_profile'] = profile['evaluation_profile']
 active_path.write_text(json.dumps(active, indent=2) + '\n')
 PY
 
-python3 - <<'PY'
-import json
-from pathlib import Path
-path = Path('.agent/startup-plan.json')
-startup = json.loads(path.read_text())
-startup.pop('task_type', None)
-path.write_text(json.dumps(startup, indent=2) + '\n')
-PY
-
-if bash .agent/verify_completion_control_plane.sh >/dev/null 2>&1; then
-  echo "expected control-plane verification to fail when startup-plan.json omits task_type" >&2
-  exit 1
-fi
-
-python3 - <<'PY'
-import json
-from pathlib import Path
-profile = json.loads(Path('.agent/profile.json').read_text())
-startup_path = Path('.agent/startup-plan.json')
-startup = json.loads(startup_path.read_text())
-startup['task_type'] = profile['task_type']
-startup_path.write_text(json.dumps(startup, indent=2) + '\n')
-PY
-
-python3 - <<'PY'
-import json
-from pathlib import Path
-path = Path('.agent/startup-plan.json')
-startup = json.loads(path.read_text())
-startup['mission_anchor'] = 'drifted-startup-plan-mission'
-path.write_text(json.dumps(startup, indent=2) + '\n')
-PY
-
-if bash .agent/verify_completion_control_plane.sh >/dev/null 2>&1; then
-  echo "expected control-plane verification to fail when startup-plan.json mission_anchor drifts from canonical workflow state" >&2
-  exit 1
-fi
-
-python3 - <<'PY'
-import json
-from pathlib import Path
-state = json.loads(Path('.agent/state.json').read_text())
-startup_path = Path('.agent/startup-plan.json')
-startup = json.loads(startup_path.read_text())
-startup['mission_anchor'] = state['mission_anchor']
-startup_path.write_text(json.dumps(startup, indent=2) + '\n')
-PY
-
 python3 - <<'PY'
 import json
 from pathlib import Path

package/skills/completion-protocol/SKILL.md

@@ -21,9 +21,8 @@ This skill defines shared protocol facts only. Role-specific behavior belongs in
 ## Shared Rules
 
 - Current repo truth beats stale notes, stale summaries, and conversation memory.
-- `startup-plan.json` is the approved workflow startup plan captured at `/cook`. Treat it as planning input only: `completion-regrounder` must reconcile it against current repo truth and derive canonical slices instead of copying it blindly into `plan.json`.
-- `startup-plan.md` is the human-readable rendering of that same approved startup plan and must remain in parity with `startup-plan.json`.
-- `plan.json` is the persistent machine-readable slice backlog. Rebuild it during every re-grounding wave from repo truth plus the approved startup plan, and keep it truthful after every committed slice.
+- `startup-brief.json` is the persistent machine-readable record of the confirmed `/cook` startup intent. It is canonical workflow intake, not the canonical slice plan.
+- `plan.json` is the persistent machine-readable slice backlog. Rebuild it during every re-grounding wave and keep it truthful after every committed slice.
 - `state.json` is the persistent machine-readable workflow controller. Keep `current_phase`, `continuation_policy`, `continuation_reason`, `next_mandatory_role`, and `next_mandatory_action` truthful after every transition.
 - Every slice in `plan.json` must have non-empty `acceptance_criteria` — concrete, verifiable conditions that define done. A slice without acceptance criteria is invalid and must not be selected.
 - Acceptance criteria are immutable after lock except for removing a criterion already satisfied with evidence or adding a missing criterion discovered during implementation.
@@ -78,7 +77,7 @@ If the workflow driver detects that the next mandatory action belongs to a compl
 
 1. If tracked protocol contract files are missing or first-time onboarding is required, invoke `completion-bootstrapper`.
 2. If canonical `.agent` execution state is missing, invalid, contradictory, stale, or ambiguous after compaction or recovery, invoke `completion-regrounder`.
-3. If no slice is selected, invoke `completion-regrounder` to read `.agent/startup-plan.json`, reconcile `.agent/plan.json` against current repo truth, and return the next exact handoff payload.
+3. If no slice is selected, invoke `completion-regrounder` to reconcile `.agent/plan.json` and return the next exact handoff payload.
 4. If a slice is `selected` or `in_progress` and no new slice commit exists yet, invoke `completion-implementer`.
 5. If the latest committed slice lacks a review result, invoke `completion-reviewer`.
 6. If the latest committed slice lacks an audit result, invoke `completion-auditor`.
@@ -101,8 +100,7 @@ Tracked repo-contract files:
 Ignored canonical execution-state files:
 
 - `.agent/state.json`
-- `.agent/startup-plan.json`
-- `.agent/startup-plan.md`
+- `.agent/startup-brief.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
@@ -118,7 +116,7 @@ Read these when making completion decisions:
 - `.agent/README.md`
 - `.agent/profile.json`
 - `.agent/state.json`
-- `.agent/startup-plan.json`
+- `.agent/startup-brief.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
@@ -145,7 +143,6 @@ Canonical truth remains in `.agent/**`.
 After context compaction, suspected memory loss, stalled-role recovery, or any ambiguous completion state, the workflow driver must re-read:
 
 - `.agent/state.json`
-- `.agent/startup-plan.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/verification-evidence.json`
@@ -161,9 +158,11 @@ The workflow driver must invoke `completion-regrounder` before continuing whenev
 
 The exact implementer handoff now includes implementation-scope surfaces and expected verification commands in addition to the locked slice goal, acceptance, notes, and before-slice counters.
 
+At workflow start, treat `.agent/startup-brief.json` as the confirmed intent anchor that regrounding must reconcile against current repo truth before selecting slices.
+
 The workflow driver must not continue implementation, review, audit, or stop evaluation from compacted conversation memory alone.
 
-After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/startup-plan.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
+After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
 
 ## Shared Report Header
 

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

@@ -13,8 +13,6 @@
 ## Ignored Canonical Execution State
 
 - `.agent/state.json`
-- `.agent/startup-plan.json`
-- `.agent/startup-plan.md`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
@@ -30,7 +28,6 @@ Read these when making completion decisions:
 - `.agent/README.md`
 - `.agent/profile.json`
 - `.agent/state.json`
-- `.agent/startup-plan.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/slice-history.jsonl`
@@ -133,37 +130,6 @@ Rules:
 4. `continuation_policy == paused` means the user explicitly paused the workflow.
 5. `continuation_policy == done` means canonical final stop reconciliation is complete and the workflow may stop.
 
-## Fixed Startup Plan Model
-
-`startup-plan.json` carries the approved workflow startup plan captured at `/cook`.
-
-Required fields:
-
-- `schema_version`
-- `artifact_type` where the value is `completion-startup-plan`
-- `status` where the value is `approved`
-- `source`
-- `captured_at`
-- `mission_anchor`
-- `goal_text`
-- `task_type`
-- `evaluation_profile`
-- `scope`
-- `constraints`
-- `acceptance`
-- `risks`
-- `notes`
-- `planned_surfaces`
-- `verification_intent`
-- `sequencing_hints`
-
-Rules:
-
-1. `startup-plan.json` is canonical startup intake, not canonical slice selection.
-2. `completion-regrounder` must treat `startup-plan.json` as planning input, reconcile it against current repo truth, and derive canonical slices in `plan.json`.
-3. `startup-plan.json` must stay aligned with the current canonical mission anchor in `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json` until a later `/cook` refocus or next-round startup rewrites it.
-4. `startup-plan.md` is the human-readable rendering of the same approved startup plan and must remain in parity with `startup-plan.json`.
-
 `plan.json` carries the ordered persistent slice backlog.
 
 Required fields:
@@ -372,7 +338,7 @@ It must not, while a slice is selected or in progress:
 
 1. If tracked protocol contract files are missing or first-time onboarding is required, invoke `completion-bootstrapper`.
 2. If canonical `.agent` execution state is missing, stale, invalid, contradictory, or ambiguous after compaction or recovery, invoke `completion-regrounder` first.
-3. If no slice is selected, invoke `completion-regrounder` to read `.agent/startup-plan.json`, reconcile `.agent/plan.json` against current repo truth, and return the next exact handoff payload.
+3. If no slice is selected, invoke `completion-regrounder` to reconcile `.agent/plan.json` and return the next exact handoff payload.
 4. If a slice is `selected` or `in_progress` and no new commit exists for it yet, invoke `completion-implementer`.
 5. If the latest committed slice lacks review, invoke `completion-reviewer`.
 6. If the latest committed slice lacks audit, invoke `completion-auditor`.
@@ -385,7 +351,6 @@ It must not, while a slice is selected or in progress:
 After context compaction, suspected memory loss, stalled-role recovery, or any ambiguous completion state, the workflow root must re-read:
 
 - `.agent/state.json`
-- `.agent/startup-plan.json`
 - `.agent/plan.json`
 - `.agent/active-slice.json`
 - `.agent/verification-evidence.json`
@@ -401,7 +366,7 @@ The workflow root must invoke `completion-regrounder` before continuing whenever
 
 The workflow root must not continue implementation, review, audit, or stop evaluation from compacted conversation memory alone.
 
-After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/startup-plan.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
+After compaction or recovery, `completion-implementer` must also re-read canonical `.agent/state.json`, `.agent/plan.json`, `.agent/active-slice.json`, and `.agent/verification-evidence.json` before resuming work. If `.agent/active-slice.json` still contains a truthful exact handoff snapshot, continue from canonical state rather than asking the user to resend the original caller payload.
 
 ## Default Priority Policy
 

package/skills/cook-handoff-boundary/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cook-handoff-boundary
-description: Ordinary-chat contract for treating `/cook` as an optional workflow mode while requiring `/cook` to capture a primary-agent-authored startup plan instead of guessing from recent discussion.
+description: Ordinary-chat contract for treating `/cook` as an optional workflow mode while requiring `/cook` to use primary-agent-authored handoff data instead of guessing from recent discussion.
 ---
 
 # /cook Handoff Boundary
@@ -58,20 +58,22 @@ But even in those cases:
 
 If the user explicitly runs or clearly chooses `/cook` workflow mode, the system behavior should be:
 
-1. call a primary-agent startup-plan synthesis step immediately from the current task context
-2. use that synthesized startup plan to show Start / Cancel confirmation in the same `/cook` entry
-3. after Start, write the approved startup plan into `.agent/startup-plan.json` / `.agent/startup-plan.md`, then let `completion-regrounder` derive canonical slices from repo truth
+1. check for a fresh explicit primary-agent `cook_handoff`
+2. if none exists, call a primary-agent handoff synthesis step immediately from the current task context
+3. use that handoff to show Start / Cancel confirmation in the same `/cook` entry
+4. after Start, persist a canonical startup brief in `.agent/**` and treat workflow entry as active
+5. let `completion-regrounder` turn that startup brief plus repo truth into canonical slices
 
 That means:
 
-- `/cook` must not infer or guess canonical slices from recent discussion alone
-- `/cook` should always synthesize the startup plan fresh in the same entry from current task context
-- `/cook` should not directly reuse an old preview capsule as canonical or approval-ready workflow state
-- `/cook` should not require a manual rerun just to consume a startup plan it can synthesize immediately from the primary-agent view
+- `/cook` must not infer or guess the startup slice from recent discussion alone
+- `/cook` should use primary-agent-authored handoff data
+- `/cook` should persist the confirmed startup brief before regrounding begins
+- `/cook` should not require a manual rerun just to consume a handoff it can synthesize immediately from the primary-agent view
 
 ## Optional Preview Behavior
 
-Only if the user explicitly asks for a preview startup plan or handoff capsule in ordinary chat may the primary agent provide one.
+Only if the user explicitly asks for a preview startup brief or handoff capsule in ordinary chat may the primary agent provide one.
 
 Optional preview capsule format:
 
@@ -82,7 +84,7 @@ Optional preview capsule format:
   "source": "primary_agent",
   "captured_at": "<ISO-8601 timestamp>",
   "source_turn_id": "<current assistant turn id>",
-  "mission": "<approved workflow mission>",
+  "mission": "<startable implementation mission>",
   "scope": ["..."],
   "constraints": ["..."],
   "non_goals": ["..."],
@@ -105,12 +107,12 @@ Optional preview capsule format:
 Notes:
 
 - `constraints` may be replaced or supplemented by `non_goals` when clearer.
-- `first_slice_goal`, `first_slice_non_goals`, `implementation_surfaces`, `verification_commands`, and `why_this_slice_first` are optional sequencing hints. They help `completion-regrounder` split slices later when they are already obvious, but the approved startup plan may still be startable without them.
-- Any capsule is advisory preview only. It is not canonical `.agent/**` state, not active-slice state, not a second repo contract source, and not something `/cook` should directly reuse without same-entry primary-agent synthesis.
+- `first_slice_goal`, `first_slice_non_goals`, `implementation_surfaces`, `verification_commands`, and `why_this_slice_first` are required for an implementation-ready handoff.
+- Any capsule is startup intake for `/cook` only. It is not canonical `.agent/**` state, not active-slice state, and not a second repo contract source.
 
 Suggested wording:
 
-> We can continue directly in ordinary chat if you want. If you prefer workflow mode, run `/cook` and it should capture an approved startup plan for Start / Cancel confirmation, then hand that plan to `completion-regrounder` for slice derivation.
+> We can continue directly in ordinary chat if you want. If you prefer workflow mode, run `/cook` and it should use a primary-agent handoff for Start / Cancel confirmation rather than guessing from recent discussion.
 
 ## Forbidden Behaviors
 
@@ -125,14 +127,13 @@ Before the user explicitly runs `/cook`, the primary agent must not:
 
 When the user does explicitly choose `/cook`, the system must not:
 
-- let `/cook` invent canonical slices from recent discussion alone
-- let `/cook` replace missing startup-plan data with generic transcript guessing
-- let `/cook` directly consume an old preview capsule instead of rerunning same-entry primary-agent startup-plan synthesis
-- require a second `/cook` invocation when same-entry primary-agent startup-plan synthesis is possible
+- let `/cook` invent the startup mission from recent discussion alone
+- let `/cook` replace missing handoff data with generic transcript guessing
+- require a second `/cook` invocation when same-entry primary-agent handoff synthesis is possible
 
 ## Relationship To `completion-protocol`
 
-This skill is only about pre-`/cook` ordinary-chat behavior and `/cook` startup-plan expectations.
+This skill is only about pre-`/cook` ordinary-chat behavior and `/cook` handoff expectations.
 
 After the user explicitly enters `/cook`, the separate `completion-protocol` skill governs: