@linimin/pi-letscook 0.1.73 → 0.1.74

package/CHANGELOG.md

@@ -1,11 +1,19 @@
 # Changelog
 
+## 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
+
 ## 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/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 {
@@ -1114,7 +1080,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.74",
   "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/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,16 @@ 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'
+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'
 PY
 
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
@@ -389,11 +385,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 +409,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,