@linimin/pi-letscook 0.1.74 → 0.1.76

package/CHANGELOG.md

@@ -1,11 +1,27 @@
 # Changelog
 
+## 0.1.76
+
+### Fixed
+
+- taught the completion protocol and core role prompts to auto-preserve routine unrelated tracked worktree dirt with a reversible stash-plus-note flow instead of asking the user to choose between stash/cleanup/background continuation for every dirty-worktree checkpoint
+- refined sticky `/cook` continuation detection so clear workflow-follow-up turns stay inside the active workflow while unrelated ordinary chat stays outside it, and aligned smoke/release regressions with that split
+
+## 0.1.75
+
+### Fixed
+
+- stopped treating a fresh but under-specified explicit `cook_handoff` as an automatic startup blocker; `/cook` now uses the user's explicit entry as implementation intent and lets same-entry primary-agent startup synthesis tighten the first slice before it gives up
+- aligned startup, sticky-workflow, and canonical-evidence regressions with the new implementation-first `/cook` behavior so long-running workflows no longer bounce users back into handoff-authoring loops
+- taught the completion protocol and core role prompts to auto-preserve routine unrelated tracked worktree dirt with a reversible stash-plus-note flow instead of asking the user to choose between stash/cleanup/background continuation for every dirty-worktree checkpoint
+
 ## 0.1.74
 
 ### Fixed
 
-- made active `/cook` workflows sticky across subsequent turns so routine continuation, exact await-user-input replies, and mandatory completion-role dispatch no longer depend on prompt-shaped driver turns or repeated manual `/cook` re-entry
+- made active `/cook` workflows sticky across routine continuation turns, exact await-user-input replies, and mandatory completion-role dispatch so long-running workflows keep moving without repeated manual `/cook` re-entry while unrelated ordinary chat stays outside workflow mode
 - updated smoke, canonical-evidence, release-check, and completion-role gating regressions to enforce the new sticky active-workflow self-healing behavior
+- stopped letting fresh but under-specified explicit `cook_handoff` capsules block `/cook` startup by default; `/cook` now treats the user's entry as implementation intent and tries same-entry primary-agent startup synthesis to tighten the first slice before failing closed
 
 ## 0.1.73
 

package/README.md

@@ -61,7 +61,7 @@ Then run `/reload` in Pi.
 
 If the primary-agent handoff step still cannot prepare a concrete handoff, `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to refine the mission, first slice, or verification intent in the main chat before rerunning `/cook`.
 
-If a fresh explicit handoff exists but is still workflow-worthy rather than implementation-startable, `/cook` also fails closed instead of silently treating that capsule as planning support or canonical workflow state.
+If a fresh explicit handoff exists but is still workflow-worthy rather than implementation-startable, `/cook` now treats your `/cook` entry as implementation intent and asks the same-entry primary-agent handoff synthesis step to tighten that startup from recent discussion before it gives up. Only if the synthesized startup is still not concrete enough does `/cook` fail closed and ask for refinement in the main chat.
 
 If you pass inline arguments to `/cook`, it also fails closed and tells you to move that intent into the main chat before rerunning bare `/cook`.
 
@@ -98,7 +98,7 @@ I want to add login redirect handling and tests.
 
 | Repo state | What you'll see |
 |---|---|
-| No workflow yet | `/cook` consumes a fresh explicit primary-agent handoff when one already exists, or synthesizes one from the primary-agent view in the same entry, then asks you to choose **Start** or **Cancel**. Stale, planning-only, or non-startable handoffs still fail closed. |
+| No workflow yet | `/cook` consumes a fresh explicit primary-agent handoff when one already exists, or synthesizes one from the primary-agent view in the same entry, then asks you to choose **Start** or **Cancel**. If a fresh explicit handoff is still under-specified, `/cook` first tries to tighten it through same-entry startup synthesis before failing closed. |
 | Active workflow exists | Usually a resume of the current workflow from canonical `.agent/**` state. If a concrete replacement handoff exists already or is synthesized in the same `/cook` entry and points to a different mission, `/cook` shows a chooser first and only rewrites canonical state after you confirm the replacement. Ambiguous or missing replacement handoff stays conservative. |
 | Previous workflow is `done` | `/cook` can start the next implementation round from a fresh explicit primary-agent handoff or from the same-entry primary-agent handoff synthesis step behind **Start** or **Cancel**. Weak or planning-only next-round handoffs still fail closed. |
 
@@ -190,6 +190,8 @@ Deterministic active-slice contract regression now lives in `bash scripts/active
 
 Deterministic verification for this packaged contract also lives in `npm run rubric-contract-test`, which now exercises reviewer, auditor, and stop-judge transcription paths while the bootstrap/refocus/context regressions plus control-plane verifier fail closed when required canonical signaling is missing.
 
+Active `/cook` workflows now also auto-reconcile routine unrelated tracked worktree dirt instead of bouncing that decision back to the user. When the dirty tracked files are outside the latest slice or current reconciliation surfaces and can be isolated safely, the workflow should preserve them with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note, continue the mandatory step on a clean worktree, and restore them before handing control back. Only overlapping changes, ownership ambiguity, or stash/restore conflicts should force a user-facing decision.
+
 ## Canonical files
 
 This package stores canonical workflow state under:

package/agents/completion-implementer.md

@@ -64,13 +64,14 @@ These lines are for workflow observability, not hidden reasoning. Keep them brie
 3. Confirm the canonical slice ID, goal, acceptance criteria, contract IDs, priority, why_now, implementation_surfaces, verification_commands, locked notes, must-fix findings, basis_commit, and before-slice counters in `.agent/active-slice.json` match canonical `.agent/plan.json`. If they do not match, stop and report the mismatch instead of guessing.
 4. Make truthful `.agent/state.json` and `.agent/active-slice.json` updates before implementation if needed.
 5. If implementation reveals roadmap-level drift — for example a missing prerequisite slice, invalid slice boundary, dependency reorder, or blocker that changes the current slice contract — do not silently redesign the plan. Report the discrepancy explicitly, make only the minimal truthful local state updates needed for the current slice, and hand control back for canonical re-grounding by `completion-regrounder`.
-6. Make the smallest correct tracked-file change.
-7. Add or strengthen tests or deterministic proof.
-8. Run focused verification first, then broader verification if shared surfaces changed.
-9. If the chosen slice changes top-level validation entrypoints or is explicitly about verifier freshness, refresh `.agent/verify_completion_stop.sh` so it remains a truthful repo-level baseline verifier.
-10. Create a new commit.
-11. Make truthful `.agent/state.json`, `.agent/active-slice.json`, and `.agent/plan.json` updates after the commit, including `current_phase = post_commit_review`, `continuation_policy = continue`, `continuation_reason`, and `next_mandatory_role = completion-reviewer`.
-12. Append exactly one `implemented` record to `.agent/slice-history.jsonl`.
+6. If unrelated tracked worktree changes are present and would otherwise block the mandatory dirty-worktree reconciliation or the current slice commit, auto-preserve them yourself with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note, continue the current slice on a clean worktree, and restore them before handing control back. Ask the user only when overlap, ownership ambiguity, or stash/restore conflicts make automatic isolation unsafe.
+7. Make the smallest correct tracked-file change.
+8. Add or strengthen tests or deterministic proof.
+9. Run focused verification first, then broader verification if shared surfaces changed.
+10. If the chosen slice changes top-level validation entrypoints or is explicitly about verifier freshness, refresh `.agent/verify_completion_stop.sh` so it remains a truthful repo-level baseline verifier.
+11. Create a new commit.
+12. Make truthful `.agent/state.json`, `.agent/active-slice.json`, and `.agent/plan.json` updates after the commit, including `current_phase = post_commit_review`, `continuation_policy = continue`, `continuation_reason`, and `next_mandatory_role = completion-reviewer`.
+13. Append exactly one `implemented` record to `.agent/slice-history.jsonl`.
 
 Do not stop after editing or verification if the slice changes remain uncommitted.
 

package/agents/completion-regrounder.md

@@ -41,14 +41,16 @@ These lines are for workflow observability, not hidden reasoning. Keep them brie
 5. Reopen any previously `done` slice whose acceptance criteria no longer hold.
 6. Keep `.agent/state.json` and `.agent/active-slice.json` truthful, including `current_phase`, `continuation_policy`, `continuation_reason`, `next_mandatory_role`, and any exact implementer handoff snapshot fields.
 7. Reconcile canonical state after review, audit, and final stop verification waves when required.
-8. If the latest committed slice leaves the tracked and unignored worktree dirty, treat that dirty state as a blocker, reopen or continue that latest slice for reconciliation, set `Next role to invoke` to `completion-implementer`, and do not select or hand off any different next slice until it is reconciled.
-9. When reconciling after review, audit, or dirty-worktree follow-up for the latest committed slice, emit an explicit reconciliation record decision:
+8. If the latest committed slice leaves the tracked and unignored worktree dirty, first classify the dirty tracked files against the latest slice's `implementation_surfaces` and the tracked reconciliation surfaces you need to touch now.
+9. If the dirty tracked files are unrelated and can be isolated safely, auto-preserve them yourself with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note, continue the mandatory reconciliation on a clean worktree, and restore them before handing control back. Do not ask the user for this routine unrelated-dirty-worktree case.
+10. If overlap, ownership ambiguity, or stash/restore conflicts make automatic isolation unsafe, treat that dirty state as a blocker, reopen or continue the latest slice for reconciliation, set `Next role to invoke` to `completion-implementer`, and do not select or hand off any different next slice until it is reconciled.
+11. When reconciling after review, audit, or dirty-worktree follow-up for the latest committed slice, emit an explicit reconciliation record decision:
    - `accepted` only when the latest committed slice is truthfully accepted as-is
    - `reopened` only when the latest committed slice must be reopened for follow-up work
    - `none` when this re-ground was not a post-commit reconciliation decision
-10. If you emit `accepted` or `reopened`, also emit the exact reconciled slice id in the report.
-11. If a slice is already selected, ensure `.agent/active-slice.json` contains the exact implementer handoff snapshot and return that exact handoff payload for `completion-implementer` instead of implementing it yourself.
-12. If no slice is selected, return the exact next recommended slice and why.
+12. If you emit `accepted` or `reopened`, also emit the exact reconciled slice id in the report.
+13. If a slice is already selected, ensure `.agent/active-slice.json` contains the exact implementer handoff snapshot and return that exact handoff payload for `completion-implementer` instead of implementing it yourself.
+14. If no slice is selected, return the exact next recommended slice and why.
 
 Output format:
 

package/extensions/completion/index.ts

@@ -257,8 +257,26 @@ function isCompletionDriverPromptTurn(snapshot: CompletionStateSnapshot | undefi
 	return true;
 }
 
-function isCompletionWorkflowSessionTurn(snapshot: CompletionStateSnapshot | undefined, _ctx: { sessionManager?: any }): boolean {
-	return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);
+function workflowContinuationIntentText(text: string | undefined): string {
+	return (text ?? "").trim().toLowerCase();
+}
+
+function isLikelyWorkflowContinuationTurn(
+	snapshot: CompletionStateSnapshot | undefined,
+	ctx: { sessionManager?: any },
+): boolean {
+	if (!hasActiveWorkflowEntry(snapshot)) return false;
+	const latest = workflowContinuationIntentText(latestUserOrCustomTurnText(ctx));
+	if (!latest) return false;
+	if (isCookCommandTurn(ctx) || isCompletionDriverPromptTurn(snapshot, ctx)) return true;
+	if (asString(snapshot?.state?.continuation_policy) === "await_user_input") return true;
+	return /(\b(continue|resume|proceed|go ahead|keep going|next|finish|fix|repair|reconcile|commit|stash|audit|review|reground|implement|phase|slice|batch)\b|\.agent\b|\bworktree\b|\bworkflow\b|\bdirty\b|繼續|继续|開始|开始|先做|先把|修好|修復|修复|清理|處理|处理|提交|下一步|接著|继续做|做完|完成)/iu.test(latest);
+}
+
+function isCompletionWorkflowSessionTurn(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
+	if (hasCompletionRoutingActivation(snapshot)) return true;
+	if (!hasActiveWorkflowEntry(snapshot)) return false;
+	return isCookCommandTurn(ctx) || isCompletionDriverPromptTurn(snapshot, ctx) || isLikelyWorkflowContinuationTurn(snapshot, ctx);
 }
 
 function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
@@ -430,7 +448,7 @@ async function deriveCookContextProposal(
 	projectName: string,
 ): Promise<CookContextProposalResult> {
 	const explicit = await deriveCookStartupProposal(ctx, projectName);
-	if (explicit.proposal || explicit.blockedFailureMessage) return explicit;
+	if (explicit.proposal) return explicit;
 	const recentMessages = collectRecentSessionMessages(ctx, { isRecord, asString, asNumber, isStaleContextError });
 	const recentEntries = recentMessages
 		.filter((entry) => !entry.isCommand && (entry.role === "user" || entry.role === "assistant" || entry.role === "custom" || entry.role === "summary"))
@@ -450,6 +468,10 @@ async function deriveCookContextProposal(
 			`verification summary: ${asString(snapshot.verificationEvidence?.summary) ?? "(none)"}`,
 		]
 		: [];
+	if (explicit.blockedFailureMessage) {
+		workflowContextLines.push(`fresh explicit handoff required tightening before startup: ${explicit.blockedFailureMessage}`);
+		workflowContextLines.push("Treat the user's /cook as implementation intent. Tighten the first slice and verification details from recent discussion instead of failing closed solely because the latest explicit handoff capsule was under-specified.");
+	}
 	const raw = await generateCookHandoffWithAgent({
 		ctx,
 		projectName,
@@ -476,6 +498,7 @@ async function deriveCookContextProposal(
 	});
 	if (generated.status === "startable") return { proposal: generated.proposal };
 	if (generated.status === "fresh_but_not_startable") return { blockedFailureMessage: generated.message };
+	if (explicit.blockedFailureMessage) return { blockedFailureMessage: explicit.blockedFailureMessage };
 	return {};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "description": "Pi package for long-running completion workflows with canonical .agent state, role-based subagents, continuity, and verification helpers.",
   "license": "MIT",
   "private": false,
@@ -42,6 +42,7 @@
     "context-proposal-test": "bash ./scripts/context-proposal-test.sh",
     "observability-status-test": "bash ./scripts/observability-status-test.sh",
     "completion-role-gating-test": "bash ./scripts/completion-role-gating-test.sh",
+    "dirty-worktree-policy-test": "bash ./scripts/dirty-worktree-policy-test.sh",
     "evaluator-calibration-test": "bash ./scripts/evaluator-calibration-test.sh",
     "rubric-contract-test": "bash ./scripts/rubric-contract-test.sh",
     "release-check": "bash ./scripts/release-check.sh"

package/scripts/canonical-evidence-artifact-test.sh

@@ -510,10 +510,7 @@ import sys
 from pathlib import Path
 
 reminder = Path(sys.argv[1])
-assert reminder.exists(), 'active selected-slice canonical state should inject the completion reminder on subsequent non-/cook turns'
-text = reminder.read_text()
-assert 'Completion workflow detected.' in text, 'selected-slice reminder should expose canonical workflow context'
-assert 'Verification evidence subject: selected_slice' in text, 'selected-slice reminder should expose the canonical evidence subject'
+assert not reminder.exists(), 'ordinary non-/cook turn should not inject completion reminder solely from selected-slice canonical state'
 PY
 
 python3 - <<'PY'

package/scripts/completion-role-gating-test.sh

@@ -21,26 +21,24 @@ const assertNotIncludes = (file, snippet) => {
   }
 };
 
+assertIncludes('extensions/completion/index.ts', 'function isLikelyWorkflowContinuationTurn(');
 assertIncludes('extensions/completion/index.ts', 'function isCompletionWorkflowSessionTurn(');
-assertIncludes('extensions/completion/index.ts', 'return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);');
+assertIncludes('extensions/completion/index.ts', 'return isCookCommandTurn(ctx) || isCompletionDriverPromptTurn(snapshot, ctx) || isLikelyWorkflowContinuationTurn(snapshot, ctx);');
 assertIncludes('extensions/completion/index.ts', 'const completionRoleDispatchAllowed = Boolean(role) || isCompletionWorkflowSessionTurn(snapshot, ctx);');
 assertIncludes('extensions/completion/policy-guards.ts', 'return "completion_role may only be used from an active /cook workflow session.";');
-assertIncludes('CHANGELOG.md', 'made active `/cook` workflows sticky across subsequent turns so completion-role dispatch and workflow context continue to self-heal from canonical active state instead of depending on prompt-shaped driver turns');
 assertIncludes('CHANGELOG.md', 'stopped pushing users to rerun `/cook` for routine active-workflow continuation or exact await-user-input replies when canonical workflow state is already active');
 
-assertNotIncludes('extensions/completion/index.ts', 'function isOrdinaryMainChatTurnDuringActiveWorkflow(');
-assertNotIncludes('extensions/completion/index.ts', 'function isCompletionRoleDispatchAllowedTurn(');
-assertNotIncludes('extensions/completion/index.ts', 'function isAwaitingUserInputWorkflowReplyTurn(');
+assertNotIncludes('extensions/completion/index.ts', 'return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);');
 
 const indexText = read('extensions/completion/index.ts');
-const sessionTurnIndex = indexText.indexOf('function isCompletionWorkflowSessionTurn(');
-const stickyReturnIndex = indexText.indexOf('return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);');
+const continuationIntentIndex = indexText.indexOf('function isLikelyWorkflowContinuationTurn(');
+const stickyReturnIndex = indexText.indexOf('return isCookCommandTurn(ctx) || isCompletionDriverPromptTurn(snapshot, ctx) || isLikelyWorkflowContinuationTurn(snapshot, ctx);');
 const toolGateIndex = indexText.indexOf('const completionRoleDispatchAllowed = Boolean(role) || isCompletionWorkflowSessionTurn(snapshot, ctx);');
-if (sessionTurnIndex === -1 || stickyReturnIndex === -1 || toolGateIndex === -1) {
-  throw new Error('extensions/completion/index.ts must derive workflow legitimacy from canonical active state and reuse that gate for completion_role dispatch.');
+if (continuationIntentIndex === -1 || stickyReturnIndex === -1 || toolGateIndex === -1) {
+  throw new Error('extensions/completion/index.ts must gate workflow continuation through explicit workflow turns or likely continuation turns before dispatching completion_role.');
 }
-if (!(sessionTurnIndex < stickyReturnIndex && stickyReturnIndex < toolGateIndex)) {
-  throw new Error('extensions/completion/index.ts should define sticky workflow-session detection before reusing it for completion_role dispatch.');
+if (!(continuationIntentIndex < stickyReturnIndex && stickyReturnIndex < toolGateIndex)) {
+  throw new Error('extensions/completion/index.ts should define continuation-turn detection before reusing it for completion_role dispatch.');
 }
 NODE
 

package/scripts/context-proposal-test.sh

@@ -564,8 +564,8 @@ assert plan['mission_anchor'] == mission, 'summary-only active bare /cook should
 assert active['mission_anchor'] == mission, 'summary-only active bare /cook should keep active-slice.json unchanged'
 PY
 
-# Active workflow: a fresh explicit handoff that is not implementation-startable should still fail closed
-# without rewriting canonical state.
+# Active workflow: a fresh explicit handoff that is not implementation-startable should trigger
+# same-entry startup synthesis instead of blocking active-workflow continuation outright.
 SESSION_ONE_NON_STARTABLE_ACTIVE="$TMPDIR/session-one-non-startable-active.jsonl"
 NON_STARTABLE_ACTIVE_ROUTING="$TMPDIR/active-non-startable-routing.json"
 NON_STARTABLE_ACTIVE_RESUME="$TMPDIR/unexpected-active-non-startable-resume.txt"
@@ -614,6 +614,49 @@ PY
 )"
 write_session_messages "$SESSION_ONE_NON_STARTABLE_ACTIVE" "$ROOT" "$NON_STARTABLE_ACTIVE_MESSAGES"
 
+SYNTH_NON_STARTABLE_ACTIVE_HANDOFF="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:03.000Z",
+    "source_turn_id": "s0001",
+    "mission": "Replace the current widget mission with a concrete redirect-hardening workflow.",
+    "scope": [
+        "Tighten the active workflow replacement into a bounded redirect-hardening slice.",
+        "Preserve the current workflow until the user confirms replacement."
+    ],
+    "constraints": [
+        "Do not rewrite canonical state until replacement confirmation succeeds."
+    ],
+    "non_goals": [],
+    "acceptance": [
+        "Add a regression test that proves the replacement redirect behavior on a concrete repo path.",
+        "Keep replacement startup bounded to the redirect-handling slice with deterministic verification."
+    ],
+    "risks": [],
+    "notes": [
+        "This synthesized handoff tightens the vague explicit capsule into a concrete replacement option."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the redirect-hardening regression slice before any broader workflow replacement.",
+    "first_slice_non_goals": [],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect.spec.ts"
+    ],
+    "why_this_slice_first": "The redirect-handling path is the smallest concrete slice that can justify replacing the active workflow.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The user explicitly entered /cook, so startup synthesis should tighten the vague explicit handoff instead of failing closed immediately."
+}
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+PY
+)"
+
 python3 - "$TMPDIR/active-non-startable-before.json" <<'PY'
 import json
 import sys
@@ -633,6 +676,7 @@ PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$NON_STARTABLE_ACTIVE_ROUTING"
 PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$NON_STARTABLE_ACTIVE_RESUME" \
 PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$NON_STARTABLE_ACTIVE_CHOOSER" \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$NON_STARTABLE_ACTIVE_PROPOSAL" \
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$SYNTH_NON_STARTABLE_ACTIVE_HANDOFF" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$SESSION_ONE_NON_STARTABLE_ACTIVE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-non-startable.out" 2>"$TMPDIR/pi-completion-context-proposal-active-non-startable.err"
 
@@ -657,15 +701,15 @@ after = {
 }
 
 assert routing['mode'] == 'bare', 'fresh non-startable explicit handoff should snapshot bare routing mode'
-assert routing['action'] == 'blocked', 'fresh non-startable explicit handoff should fail closed for active bare /cook'
-assert routing['reason'] == 'fresh_explicit_handoff_not_startable', 'fresh non-startable explicit handoff should keep the dedicated explicit-handoff fail-closed reason'
-assert 'fresh explicit primary-agent handoff exists' in routing['blockedFailureMessage'], 'fresh non-startable explicit handoff should surface the dedicated fail-closed message'
-assert 'acceptance is not anchored to concrete repo changes or verification' in routing['blockedFailureMessage'], 'fresh non-startable explicit handoff should explain why the capsule is not startable'
-assert not resume_path.exists(), 'fresh non-startable explicit handoff should not queue a resume prompt'
-assert not chooser_path.exists(), 'fresh non-startable explicit handoff should not open the replacement chooser'
-assert not proposal_path.exists(), 'fresh non-startable explicit handoff should not open final proposal confirmation'
-assert 'fresh explicit primary-agent handoff exists' in output, 'fresh non-startable explicit handoff should explain that the explicit capsule blocked active-workflow replacement'
-assert before == after, 'fresh non-startable explicit handoff should leave canonical state unchanged'
+assert routing['action'] == 'refocus', 'fresh non-startable explicit handoff should synthesize a concrete replacement option instead of blocking active bare /cook'
+assert routing['reason'] == 'fresh_explicit_handoff', 'fresh non-startable explicit handoff should keep explicit-handoff replacement routing after startup synthesis tightens it'
+assert resume_path.exists(), 'non-interactive active workflow should continue by queueing the canonical resume prompt after synthesized replacement routing'
+assert chooser_path.exists(), 'fresh non-startable explicit handoff should still open the replacement chooser snapshot after startup synthesis tightens it'
+assert not proposal_path.exists(), 'non-interactive active workflow should not open final replacement confirmation without an explicit chooser refocus selection'
+chooser = json.loads(chooser_path.read_text())
+assert 'Replace the current widget mission with a concrete redirect-hardening workflow.' in chooser['candidateMissions'], 'replacement chooser should include the synthesized concrete mission'
+assert 'fresh explicit primary-agent handoff exists' not in output, 'fresh non-startable explicit handoff should not fail closed once startup synthesis tightens it'
+assert before == after, 'fresh non-startable explicit handoff should still leave canonical state unchanged until replacement confirmation succeeds'
 PY
 
 # Completed workflow: bare /cook should suppress proposals that simply restate the completed mission
@@ -1311,8 +1355,8 @@ assert 'Why this slice first: The redirect callback bug is already bounded enoug
 assert 'Primary-agent /cook handoff rationale: The implementation plan is concrete and ready for repo changes.' in state['advisory_startup_brief']['notes'], 'explicit handoff startup should preserve why_cook_now as notes'
 PY
 
-# Fresh but non-startable explicit handoff: /cook should fail closed instead of falling back
-# to a broad recent-discussion startup brief when the explicit capsule is still too vague.
+# Fresh but non-startable explicit handoff: /cook should tighten startup in the same entry
+# instead of failing closed solely because the explicit capsule is still too vague.
 HANDOFF_ROOT_VAGUE="$TMPDIR/handoff-root-vague"
 mkdir -p "$HANDOFF_ROOT_VAGUE"
 cd "$HANDOFF_ROOT_VAGUE"
@@ -1365,7 +1409,54 @@ PY
 )"
 write_session_messages "$HANDOFF_SESSION_VAGUE" "$HANDOFF_ROOT_VAGUE" "$HANDOFF_MESSAGES_VAGUE"
 
+SYNTH_HANDOFF_VAGUE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:03.000Z",
+    "source_turn_id": "s-vague",
+    "mission": "Fix login redirect callback behavior.",
+    "scope": [
+        "Update the callback redirect decision logic.",
+        "Add a regression test for returning to the requested page."
+    ],
+    "constraints": [
+        "Do not refactor the broader auth flow."
+    ],
+    "non_goals": [],
+    "acceptance": [
+        "Add a regression test proving the callback returns to the requested page.",
+        "Keep the broader auth flow unchanged while the redirect regression passes."
+    ],
+    "risks": [
+        "Broad recent context could broaden the startup brief if synthesis ignores the bounded first slice."
+    ],
+    "notes": [
+        "This synthesized startup brief tightens the vague explicit handoff into a bounded redirect fix."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the callback redirect fix and its regression coverage.",
+    "first_slice_non_goals": [
+        "Do not refactor the broader auth flow."
+    ],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect.spec.ts"
+    ],
+    "why_this_slice_first": "The callback redirect path is the smallest concrete slice implied by the recent discussion.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1"
+}
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+PY
+)"
+
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$SYNTH_HANDOFF_VAGUE" \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_VAGUE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$HANDOFF_SESSION_VAGUE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-vague.out" 2>"$TMPDIR/pi-completion-handoff-vague.err"
@@ -1377,16 +1468,16 @@ from pathlib import Path
 snapshot = Path(sys.argv[1])
 output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
 
-assert not snapshot.exists(), 'fresh non-startable handoff should not emit a startup proposal snapshot'
-assert not Path('.agent').exists(), 'fresh non-startable handoff should fail closed without writing canonical state'
-assert 'fresh explicit primary-agent handoff exists' in output, 'fresh non-startable handoff should explain that the explicit capsule blocked startup'
-assert 'acceptance is not anchored to concrete repo changes or verification' in output, 'fresh non-startable handoff should explain the workflow-only acceptance failure'
-assert 'implementation_surfaces is empty' in output, 'fresh non-startable handoff should explain the missing implementation_surfaces requirement'
-assert 'verification_commands is empty' in output, 'fresh non-startable handoff should explain the missing verification_commands requirement'
+assert snapshot.exists(), 'fresh non-startable handoff should emit a startup proposal snapshot after same-entry startup synthesis tightens it'
+assert not Path('.agent').exists(), 'fresh non-startable handoff should still wait for confirmation before writing canonical state'
+proposal = __import__('json').loads(snapshot.read_text())
+assert proposal['mission'] == 'Fix login redirect callback behavior.', 'synthesized startup proposal should preserve the concrete mission anchor from recent discussion'
+assert proposal['source'] == 'handoff_capsule', 'synthesized startup proposal should still reflect primary-agent handoff startup synthesis output'
+assert 'fresh explicit primary-agent handoff exists' not in output, 'fresh non-startable handoff should not fail closed once startup synthesis tightens it'
 PY
 
-# Fresh explicit handoff with complete first-slice fields but vague acceptance: /cook should still fail closed
-# with the dedicated explicit-handoff message instead of bootstrapping canonical state.
+# Fresh explicit handoff with complete first-slice fields but vague acceptance: /cook should still
+# try same-entry startup synthesis before giving up.
 HANDOFF_ROOT_VAGUE_ACCEPTANCE="$TMPDIR/handoff-root-vague-acceptance"
 mkdir -p "$HANDOFF_ROOT_VAGUE_ACCEPTANCE"
 cd "$HANDOFF_ROOT_VAGUE_ACCEPTANCE"
@@ -1445,7 +1536,54 @@ PY
 )"
 write_session_messages "$HANDOFF_SESSION_VAGUE_ACCEPTANCE" "$HANDOFF_ROOT_VAGUE_ACCEPTANCE" "$HANDOFF_MESSAGES_VAGUE_ACCEPTANCE"
 
+SYNTH_HANDOFF_VAGUE_ACCEPTANCE="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:03.500Z",
+    "source_turn_id": "s-vague-acceptance",
+    "mission": "Fix login redirect callback behavior.",
+    "scope": [
+        "Update the callback redirect decision logic.",
+        "Preserve the broader auth flow."
+    ],
+    "constraints": [
+        "Do not refactor the broader auth flow."
+    ],
+    "non_goals": [],
+    "acceptance": [
+        "Add a regression test for returning to the requested page.",
+        "Verify the redirect callback path with npm test -- redirect.spec.ts."
+    ],
+    "risks": [
+        "Broad recent context could broaden the startup brief if synthesis ignores the bounded first slice."
+    ],
+    "notes": [
+        "This synthesized startup brief tightens the vague explicit acceptance into concrete repo-change verification."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Land the redirect callback fix and its regression coverage.",
+    "first_slice_non_goals": [
+        "Do not refactor the broader auth flow."
+    ],
+    "implementation_surfaces": [
+        "src/auth/redirect.ts",
+        "tests/auth/redirect.spec.ts"
+    ],
+    "verification_commands": [
+        "npm test -- redirect.spec.ts"
+    ],
+    "why_this_slice_first": "The redirect callback bug is already bounded enough to start once startup synthesis tightens the acceptance contract.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1"
+}
+print("```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```")
+PY
+)"
+
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_PRIMARY_HANDOFF_OUTPUT="$SYNTH_HANDOFF_VAGUE_ACCEPTANCE" \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_VAGUE_ACCEPTANCE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$HANDOFF_SESSION_VAGUE_ACCEPTANCE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-vague-acceptance.out" 2>"$TMPDIR/pi-completion-handoff-vague-acceptance.err"
@@ -1457,10 +1595,12 @@ from pathlib import Path
 snapshot = Path(sys.argv[1])
 output = Path(sys.argv[2]).read_text() + Path(sys.argv[3]).read_text()
 
-assert not snapshot.exists(), 'fresh explicit handoff with vague acceptance should not emit a startup proposal snapshot'
-assert not Path('.agent').exists(), 'fresh explicit handoff with vague acceptance should fail closed without writing canonical state'
-assert 'fresh explicit primary-agent handoff exists' in output, 'fresh explicit handoff with vague acceptance should use the dedicated explicit-handoff fail-closed message'
-assert 'acceptance is not anchored to concrete repo changes or verification' in output, 'fresh explicit handoff with vague acceptance should explain the vague acceptance failure'
+assert snapshot.exists(), 'fresh explicit handoff with vague acceptance should emit a startup proposal snapshot after same-entry startup synthesis tightens it'
+assert not Path('.agent').exists(), 'fresh explicit handoff with vague acceptance should still wait for confirmation before writing canonical state'
+proposal = __import__('json').loads(snapshot.read_text())
+assert proposal['mission'] == 'Fix login redirect callback behavior.', 'synthesized startup proposal should preserve the concrete mission anchor when tightening vague acceptance'
+assert proposal['source'] == 'handoff_capsule', 'synthesized startup proposal should still be attributed to primary-agent handoff synthesis'
+assert 'fresh explicit primary-agent handoff exists' not in output, 'fresh explicit handoff with vague acceptance should not fail closed once startup synthesis tightens it'
 PY
 
 # Done workflow + fresh handoff: the fresh explicit handoff should override done-state suppression and start the new round.
@@ -1673,6 +1813,7 @@ PY
 write_session_messages "$HANDOFF_SESSION_NEGATIVE" "$HANDOFF_ROOT_NEGATIVE" "$HANDOFF_MESSAGES_NEGATIVE"
 
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_DISABLE_PRIMARY_HANDOFF_SYNTHESIS=1 \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$HANDOFF_SNAPSHOT_NEGATIVE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$HANDOFF_SESSION_NEGATIVE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-handoff-negative.out" 2>"$TMPDIR/pi-completion-handoff-negative.err"

package/scripts/dirty-worktree-policy-test.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+node <<'NODE'
+const fs = require('node:fs');
+
+const read = (file) => fs.readFileSync(file, 'utf8');
+const assertIncludes = (file, snippet) => {
+  const text = read(file);
+  if (!text.includes(snippet)) {
+    throw new Error(`${file} is missing required dirty-worktree policy text: ${snippet}`);
+  }
+};
+
+assertIncludes('skills/completion-protocol/SKILL.md', 'auto-preserve them with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note');
+assertIncludes('skills/completion-protocol/SKILL.md', 'Ask the user only when overlap, ownership ambiguity, or stash/restore conflicts make automatic isolation unsafe.');
+assertIncludes('skills/completion-protocol/references/completion.md', 'Dirty-worktree auto-reconcile. If tracked worktree dirt is unrelated to the latest slice or current reconciliation surfaces and can be isolated safely');
+assertIncludes('agents/completion-regrounder.md', 'Do not ask the user for this routine unrelated-dirty-worktree case.');
+assertIncludes('agents/completion-implementer.md', 'auto-preserve them yourself with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note');
+assertIncludes('README.md', 'Active `/cook` workflows now also auto-reconcile routine unrelated tracked worktree dirt instead of bouncing that decision back to the user.');
+assertIncludes('CHANGELOG.md', 'auto-preserve routine unrelated tracked worktree dirt with a reversible stash-plus-note flow');
+NODE
+
+echo "dirty-worktree policy test passed"

package/scripts/release-check.sh

@@ -5,7 +5,7 @@ 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, explicit-/cook parity, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, completion-role gating, 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, completion-role gating, dirty-worktree policy, 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
 
@@ -34,8 +34,8 @@ checks = {
         '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.',
-        'function isCompletionWorkflowSessionTurn(',
-        'return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);',
+        'function isLikelyWorkflowContinuationTurn(',
+        'return isCookCommandTurn(ctx) || isCompletionDriverPromptTurn(snapshot, ctx) || isLikelyWorkflowContinuationTurn(snapshot, ctx);',
     ],
     "extensions/completion/policy-guards.ts": [
         'return "completion_role may only be used from an active /cook workflow session.";',
@@ -84,6 +84,7 @@ bash ./scripts/canonical-evidence-artifact-test.sh
 bash ./scripts/active-slice-contract-test.sh
 npm run observability-status-test
 npm run completion-role-gating-test
+npm run dirty-worktree-policy-test
 bash ./scripts/legacy-cleanup-test.sh
 npm run evaluator-calibration-test
 npm run rubric-contract-test

package/scripts/smoke-test.sh

@@ -273,16 +273,20 @@ reminder = Path(sys.argv[3])
 handoff = Path(sys.argv[4])
 auto_resume = Path(sys.argv[5])
 
-assert reminder.exists(), 'active workflow should inject the completion reminder on subsequent non-/cook turns'
-reminder_text = reminder.read_text()
-assert 'Completion workflow detected.' in reminder_text, 'active workflow reminder should inject canonical workflow context'
-assert 'If continuation_policy == continue, do not stop after a slice or ask whether to continue; dispatch the next mandatory role directly.' in reminder_text, 'active workflow reminder should direct mandatory continuation'
-assert not handoff.exists(), 'active workflow should not fall back to the ordinary /cook handoff boundary reminder'
-assert auto_resume.exists(), 'active workflow should queue an auto-resume prompt from canonical state without requiring another /cook'
-auto_resume_text = auto_resume.read_text()
-assert 'COMPLETION WORKFLOW DRIVER' in auto_resume_text, 'auto-resume prompt should use the workflow driver format'
-assert 'Resume the completion workflow from canonical state.' in auto_resume_text, 'auto-resume prompt should resume canonical workflow state'
-assert 'Skipped completion workflow auto-resume prompt (test mode)' in output, 'active workflow should attempt auto-resume in test mode'
+assert not reminder.exists(), 'ordinary non-/cook turn should not inject completion reminder solely from canonical state'
+assert handoff.exists(), 'ordinary non-/cook turn should inject the /cook handoff boundary reminder'
+handoff_text = handoff.read_text()
+assert 'ordinary main chat unless the user explicitly runs /cook' in handoff_text, 'ordinary handoff reminder should preserve explicit /cook workflow entry'
+assert 'directly implement requested repo changes, including multi-file work' in handoff_text, 'ordinary handoff reminder should allow direct ordinary-chat implementation'
+assert 'Do not proactively tell the user to run /cook' in handoff_text, 'ordinary handoff reminder should keep ordinary chat neutral until explicit /cook entry'
+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 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 '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'
 PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
@@ -299,11 +303,12 @@ from pathlib import Path
 
 expected_task_type = 'completion-workflow'
 expected_eval_profile = 'completion-rubric-v1'
-resume = Path(sys.argv[1]).read_text()
+resume_path = Path(sys.argv[1])
 routing = json.loads(Path(sys.argv[2]).read_text())
 chooser_path = Path(sys.argv[3])
 state = json.loads(Path('.agent/state.json').read_text())
 
+resume = resume_path.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'

package/skills/completion-protocol/SKILL.md

@@ -32,6 +32,7 @@ This skill defines shared protocol facts only. Role-specific behavior belongs in
 - Run exactly one implementation slice at a time.
 - A slice is not complete unless it lands as a new commit.
 - Before selecting or advancing to the next slice after a committed slice, the tracked and unignored worktree must be clean. If it is not clean, treat that dirty state as a blocker to next-slice progression and reopen or continue the latest slice for reconciliation.
+- When that dirty tracked worktree contains changes unrelated to the latest slice or current reconciliation surfaces and those changes can be isolated safely, auto-preserve them with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note, continue the mandatory workflow step, and restore them before handing control back. Ask the user only when overlap, ownership ambiguity, or stash/restore conflicts make automatic isolation unsafe.
 - Docs, config, and runbooks must stay truthful to shipped behavior.
 - `.agent/verify_completion_stop.sh` is a generated repo-level baseline verifier. Onboarding should create a working version from current repo truth rather than an unconditional failing placeholder.
 - The packaged default stop policy is `required_stop_judges: 2` plus `stop_aggregation_policy: "unanimous-current-head-v1"` in `.agent/profile.json`.

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

@@ -168,6 +168,7 @@ Rules:
 3. Done requires all satisfied. A slice may only transition to `done` when every acceptance criterion is satisfied and `evidence` contains the proof for each one.
 4. Re-ground validation. During re-ground, the current slice backlog must be revalidated against repo truth. A slice previously marked `done` whose criteria no longer hold must be reopened.
 5. Clean handoff before next slice. After a committed slice is reviewed and audited, the tracked and unignored worktree must be clean before the next slice is selected.
+6. Dirty-worktree auto-reconcile. If tracked worktree dirt is unrelated to the latest slice or current reconciliation surfaces and can be isolated safely, the workflow should auto-preserve it with a reversible mechanism such as a named git stash plus a `.agent/tmp/dirty-worktree-autostash.json` note, continue the mandatory workflow step, and restore it before handing control back. Ask the user only when overlap, ownership ambiguity, or stash/restore conflicts make automatic isolation unsafe.
 
 `active-slice.json` carries one current slice cursor.