@linimin/pi-letscook 0.1.73 → 0.1.75

package/CHANGELOG.md

@@ -1,11 +1,27 @@
 # Changelog
 
+## 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
+
+## 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
+- 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
 
 ### Fixed
 
-- fixed `/cook` await-user-input resumptions so a user's exact reply in the active workflow can dispatch the mandatory follow-up completion role without forcing an extra `/cook` rerun
-- kept active-workflow completion-role gating strict for ordinary main-chat turns while adding regression coverage that fails if await-user-input replies lose their workflow dispatch rights
+- 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
+- stopped pushing users to rerun `/cook` for routine active-workflow continuation or exact await-user-input replies when canonical workflow state is already active
+- added regression coverage so release-check fails if sticky active-workflow dispatch falls back to prompt-only gating again
 
 ## 0.1.72
 

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. |
 

package/extensions/completion/index.ts

@@ -257,42 +257,8 @@ function isCompletionDriverPromptTurn(snapshot: CompletionStateSnapshot | undefi
 	return true;
 }
 
-function isCompletionWorkflowSessionTurn(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
-	if (!(hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot))) return false;
-	return isCompletionDriverPromptTurn(snapshot, ctx) || isCookCommandTurn(ctx);
-}
-
-function isOrdinaryMainChatTurnDuringActiveWorkflow(
-	snapshot: CompletionStateSnapshot | undefined,
-	ctx: { sessionManager?: any },
-): boolean {
-	if (!hasActiveWorkflowEntry(snapshot)) return false;
-	const latest = latestUserOrCustomTurnText(ctx);
-	if (!latest) return false;
-	if (isCookCommandTurn(ctx)) return false;
-	if (isCompletionDriverPromptTurn(snapshot, ctx)) return false;
-	return true;
-}
-
-function isAwaitingUserInputWorkflowReplyTurn(
-	snapshot: CompletionStateSnapshot | undefined,
-	ctx: { sessionManager?: any },
-): boolean {
-	if (!hasActiveWorkflowEntry(snapshot)) return false;
-	if (!isOrdinaryMainChatTurnDuringActiveWorkflow(snapshot, ctx)) return false;
-	return asString(snapshot?.state?.continuation_policy) === "await_user_input";
-}
-
-function isCompletionRoleDispatchAllowedTurn(
-	snapshot: CompletionStateSnapshot | undefined,
-	ctx: { sessionManager?: any },
-): boolean {
-	if (hasCompletionRoutingActivation(snapshot)) return true;
-	if (!hasActiveWorkflowEntry(snapshot)) return false;
-	if (isCompletionWorkflowSessionTurn(snapshot, ctx)) return true;
-	if (isAwaitingUserInputWorkflowReplyTurn(snapshot, ctx)) return true;
-	if (isOrdinaryMainChatTurnDuringActiveWorkflow(snapshot, ctx)) return false;
-	return asString(snapshot?.state?.continuation_policy) === "continue";
+function isCompletionWorkflowSessionTurn(snapshot: CompletionStateSnapshot | undefined, _ctx: { sessionManager?: any }): boolean {
+	return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);
 }
 
 function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
@@ -464,7 +430,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"))
@@ -484,6 +450,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,
@@ -510,6 +480,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 {};
 }
 
@@ -1114,7 +1085,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		const snapshot = await loadCompletionSnapshot(cwd);
 		const completionActive = Boolean(snapshot) && asString(snapshot?.state?.continuation_policy) !== "done";
 		const root = snapshot?.files.root ?? findRepoRoot(cwd) ?? cwd;
-		const completionRoleDispatchAllowed = Boolean(role) || isCompletionRoleDispatchAllowedTurn(snapshot, ctx);
+		const completionRoleDispatchAllowed = Boolean(role) || isCompletionWorkflowSessionTurn(snapshot, ctx);
 		const reason = toolCallBlockReason({
 			toolName: event.toolName,
 			input: isRecord(event.input) ? event.input : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "description": "Pi package for long-running completion workflows with canonical .agent state, role-based subagents, continuity, and verification helpers.",
   "license": "MIT",
   "private": false,

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

@@ -510,7 +510,10 @@ import sys
 from pathlib import Path
 
 reminder = Path(sys.argv[1])
-assert not reminder.exists(), 'ordinary non-/cook turn should not inject completion reminder solely from selected-slice canonical state'
+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'
 PY
 
 python3 - <<'PY'

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

@@ -21,34 +21,26 @@ const assertNotIncludes = (file, snippet) => {
   }
 };
 
-assertIncludes('extensions/completion/index.ts', 'function isOrdinaryMainChatTurnDuringActiveWorkflow(');
-assertIncludes('extensions/completion/index.ts', 'function isCompletionRoleDispatchAllowedTurn(');
-assertIncludes('extensions/completion/index.ts', 'function isAwaitingUserInputWorkflowReplyTurn(');
-assertIncludes('extensions/completion/index.ts', 'if (isAwaitingUserInputWorkflowReplyTurn(snapshot, ctx)) return true;');
-assertIncludes('extensions/completion/index.ts', 'if (isOrdinaryMainChatTurnDuringActiveWorkflow(snapshot, ctx)) return false;');
-assertIncludes('extensions/completion/index.ts', 'return asString(snapshot?.state?.continuation_policy) === "await_user_input";');
-assertIncludes('extensions/completion/index.ts', 'return asString(snapshot?.state?.continuation_policy) === "continue";');
-assertIncludes('extensions/completion/index.ts', 'const completionRoleDispatchAllowed = Boolean(role) || isCompletionRoleDispatchAllowedTurn(snapshot, ctx);');
-assertIncludes('extensions/completion/index.ts', 'if (isCookCommandTurn(ctx)) return false;');
-assertIncludes('extensions/completion/index.ts', 'if (isCompletionDriverPromptTurn(snapshot, ctx)) return false;');
+assertIncludes('extensions/completion/index.ts', 'function isCompletionWorkflowSessionTurn(');
+assertIncludes('extensions/completion/index.ts', 'return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);');
+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', 'fixed completion-role continuation gating so an already-active `/cook` workflow with `continuation_policy: continue` can keep dispatching mandatory follow-up roles');
-assertIncludes('CHANGELOG.md', 'fixed `/cook` await-user-input resumptions so a user\'s exact reply in the active workflow can dispatch the mandatory follow-up completion role without forcing an extra `/cook` rerun');
+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',
-  'const completionRoleDispatchAllowed = Boolean(role) || isCompletionWorkflowSessionTurn(snapshot, ctx);',
-);
+assertNotIncludes('extensions/completion/index.ts', 'function isOrdinaryMainChatTurnDuringActiveWorkflow(');
+assertNotIncludes('extensions/completion/index.ts', 'function isCompletionRoleDispatchAllowedTurn(');
+assertNotIncludes('extensions/completion/index.ts', 'function isAwaitingUserInputWorkflowReplyTurn(');
 
 const indexText = read('extensions/completion/index.ts');
-const ordinaryGuardIndex = indexText.indexOf('if (isOrdinaryMainChatTurnDuringActiveWorkflow(snapshot, ctx)) return false;');
-const awaitReplyAllowIndex = indexText.indexOf('if (isAwaitingUserInputWorkflowReplyTurn(snapshot, ctx)) return true;');
-const continueFallbackIndex = indexText.indexOf('return asString(snapshot?.state?.continuation_policy) === "continue";');
-if (awaitReplyAllowIndex === -1 || ordinaryGuardIndex === -1 || awaitReplyAllowIndex > ordinaryGuardIndex) {
-  throw new Error('extensions/completion/index.ts must allow active await_user_input reply turns before the ordinary main-chat rejection guard.');
+const sessionTurnIndex = indexText.indexOf('function isCompletionWorkflowSessionTurn(');
+const stickyReturnIndex = indexText.indexOf('return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);');
+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 (ordinaryGuardIndex === -1 || continueFallbackIndex === -1 || ordinaryGuardIndex > continueFallbackIndex) {
-  throw new Error('extensions/completion/index.ts must reject ordinary main-chat turns before allowing the continuation_policy=continue fallback.');
+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.');
 }
 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/release-check.sh

@@ -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 isCompletionRoleDispatchAllowedTurn(',
-        'return asString(snapshot?.state?.continuation_policy) === "continue";',
+        'function isCompletionWorkflowSessionTurn(',
+        'return hasCompletionRoutingActivation(snapshot) || hasActiveWorkflowEntry(snapshot);',
     ],
     "extensions/completion/policy-guards.ts": [
         'return "completion_role may only be used from an active /cook workflow session.";',

package/scripts/smoke-test.sh

@@ -273,20 +273,15 @@ reminder = Path(sys.argv[3])
 handoff = Path(sys.argv[4])
 auto_resume = Path(sys.argv[5])
 
-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'
+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'
+if auto_resume.exists():
+    auto_resume_text = auto_resume.read_text()
+    assert 'COMPLETION WORKFLOW DRIVER' in auto_resume_text, 'auto-resume prompt should use the workflow driver format when it is queued'
+    assert 'Resume the completion workflow from canonical state.' in auto_resume_text, 'auto-resume prompt should resume canonical workflow state when it is queued'
 PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
@@ -303,14 +298,16 @@ 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())
 
-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'
+if resume_path.exists():
+    resume = resume_path.read_text()
+    assert 'Canonical routing profile:' in resume, 'resume prompt should expose canonical routing profile when it is queued'
+    assert f'- task_type: {expected_task_type}' in resume, 'resume prompt missing canonical task_type when it is queued'
+    assert f'- evaluation_profile: {expected_eval_profile}' in resume, 'resume prompt missing canonical evaluation_profile when it is queued'
 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'] == 'missing_explicit_handoff', 'no-discussion active bare /cook should explain that resume happened because no fresh explicit handoff existed'
@@ -389,11 +386,19 @@ active['evaluation_profile'] = profile['evaluation_profile']
 active_path.write_text(json.dumps(active, indent=2) + '\n')
 PY
 
+if ! git rev-parse HEAD >/dev/null 2>&1; then
+  git config user.name "smoke-test"
+  git config user.email "smoke-test@example.invalid"
+  git commit --allow-empty -m "smoke baseline" >/dev/null
+fi
+
 python3 - <<'PY'
 import json
+import subprocess
 from pathlib import Path
 path = Path('.agent/active-slice.json')
 active = json.loads(path.read_text())
+head = subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip()
 active.update({
     'status': 'selected',
     'slice_id': 'smoke-slice',
@@ -405,7 +410,7 @@ active.update({
     'must_fix_findings': [],
     'implementation_surfaces': ['extensions/completion/index.ts', '.agent/verify_completion_control_plane.sh'],
     'verification_commands': ['bash .agent/verify_completion_control_plane.sh', 'npm run smoke-test'],
-    'basis_commit': 'deadbeef',
+    'basis_commit': head,
     'remaining_contract_ids_before': ['smoke-contract'],
     'release_blocker_count_before': 1,
     'high_value_gap_count_before': 0,