@linimin/pi-letscook 0.1.60 → 0.1.61

package/scripts/smoke-test.sh

@@ -103,8 +103,55 @@ INLINE_REJECTION_ROUTING_SNAPSHOT="$TMPDIR/inline-arg-routing.json"
 INLINE_REJECTION_PROPOSAL_SNAPSHOT="$TMPDIR/inline-arg-proposal.json"
 INLINE_REJECTION_CHOOSER_SNAPSHOT="$TMPDIR/inline-arg-chooser.json"
 BOOTSTRAP_SESSION="$TMPDIR/session-smoke-bootstrap.jsonl"
-BOOTSTRAP_DISCUSSION=$'Mission: Exercise smoke-test bootstrap.\nScope:\n- Materialize the canonical completion control-plane files.\n- Keep the smoke test on supported /cook startup behavior.\nConstraints:\n- Keep startup proposal confirmation approval-only.\nAcceptance:\n- Scaffold .agent/profile.json, .agent/state.json, .agent/plan.json, .agent/active-slice.json, and .agent/verification-evidence.json for the smoke fixture.\n- Keep scripts/smoke-test.sh and kickoff-prompt coverage truthful for packaged bootstrap.'
-BOOTSTRAP_PROPOSAL="$TMPDIR/bootstrap-proposal.json"
+BOOTSTRAP_MESSAGES="$(python3 - <<'PY'
+import json
+capsule = {
+    "kind": "cook_handoff",
+    "source": "primary_agent",
+    "captured_at": "2026-01-01T00:00:02.000Z",
+    "source_turn_id": "m0002",
+    "mission": "Exercise smoke-test bootstrap.",
+    "scope": [
+        "Materialize the canonical completion control-plane files.",
+        "Keep the smoke test on supported /cook startup behavior."
+    ],
+    "constraints": [
+        "Keep startup proposal confirmation approval-only."
+    ],
+    "acceptance": [
+        "Scaffold .agent/profile.json, .agent/state.json, .agent/plan.json, .agent/active-slice.json, and .agent/verification-evidence.json for the smoke fixture.",
+        "Keep scripts/smoke-test.sh and kickoff-prompt coverage truthful for packaged bootstrap."
+    ],
+    "risks": [
+        "Smoke-test bootstrap should stay anchored to the fresh explicit handoff."
+    ],
+    "notes": [
+        "Keep the smoke fixture aligned with the shipped explicit-handoff-only startup contract."
+    ],
+    "handoff_kind": "implementation_workflow_handoff",
+    "first_slice_goal": "Scaffold canonical completion files and verify the packaged startup contract.",
+    "first_slice_non_goals": [
+        "Do not broaden the smoke fixture beyond the packaged startup surfaces."
+    ],
+    "implementation_surfaces": [
+        ".agent/README.md",
+        "scripts/smoke-test.sh"
+    ],
+    "verification_commands": [
+        "npm run smoke-test"
+    ],
+    "why_this_slice_first": "The packaged explicit-handoff startup path must work before later workflow verification can run.",
+    "task_type": "completion-workflow",
+    "evaluation_profile": "completion-rubric-v1",
+    "why_cook_now": "The startup handoff is concrete enough to bootstrap canonical workflow files."
+}
+messages = [
+    {"role": "user", "content": "Please prepare the packaged smoke-test bootstrap path and tell me when it is ready for /cook."},
+    {"role": "assistant", "content": "This bootstrap path is ready for /cook. Run /cook to confirm the startup brief.\n\n```cook_handoff\n" + json.dumps(capsule, ensure_ascii=False, indent=2) + "\n```"},
+]
+print(json.dumps(messages, ensure_ascii=False))
+PY
+)"
 
 mkdir -p "$ROOT"
 cd "$ROOT"
@@ -133,12 +180,11 @@ assert not chooser.exists(), 'startup /cook inline-args rejection should not ope
 assert '/cook no longer accepts inline arguments.' in output, 'startup /cook inline-args rejection should explain the bare-only entry contract'
 PY
 
-write_session "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_DISCUSSION"
+write_session_messages "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_MESSAGES"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$BOOTSTRAP_PROPOSAL" \
 PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$KICKOFF_PROMPT" \
 pi --session "$BOOTSTRAP_SESSION" -e "$PKG_ROOT" -p "/cook" \
   >"$TMPDIR/pi-completion-smoke-bootstrap.out" 2>"$TMPDIR/pi-completion-smoke-bootstrap.err"
@@ -151,7 +197,7 @@ git ls-files --error-unmatch .agent/README.md .agent/mission.md .agent/profile.j
 bash .agent/verify_completion_control_plane.sh >/dev/null
 bash .agent/verify_completion_stop.sh >/dev/null
 
-python3 - "$KICKOFF_PROMPT" "$BOOTSTRAP_PROPOSAL" <<'PY'
+python3 - "$KICKOFF_PROMPT" <<'PY'
 import json
 import sys
 from pathlib import Path
@@ -165,7 +211,6 @@ plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
 evidence = json.loads(Path('.agent/verification-evidence.json').read_text())
 kickoff = Path(sys.argv[1]).read_text()
-proposal = json.loads(Path(sys.argv[2]).read_text())
 
 assert profile['task_type'] == expected_task_type, 'profile.json task_type mismatch after bootstrap'
 assert profile['evaluation_profile'] == expected_eval_profile, 'profile.json evaluation_profile mismatch after bootstrap'
@@ -179,7 +224,7 @@ assert active['implementation_surfaces'] == [], 'active-slice.json should scaffo
 assert active['verification_commands'] == [], 'active-slice.json should scaffold empty verification_commands'
 brief = state['advisory_startup_brief']
 assert brief['kind'] == 'startup_brief', 'state.json should preserve the confirmed startup brief as advisory intake'
-assert brief['source'] == 'recent_discussion', 'smoke bootstrap should record recent-discussion synthesis in advisory intake'
+assert brief['source'] == 'primary_agent_handoff', 'smoke bootstrap should record the explicit handoff source in advisory intake'
 assert brief['mission'] == state['mission_anchor'], 'advisory startup brief mission should match the canonical mission anchor after bootstrap'
 assert brief['scope'] == ['Materialize the canonical completion control-plane files.', 'Keep the smoke test on supported /cook startup behavior.'], 'advisory startup brief should preserve scope items'
 assert brief['constraints'] == ['Keep startup proposal confirmation approval-only.'], 'advisory startup brief should preserve constraints'
@@ -187,10 +232,9 @@ assert brief['acceptance'] == [
     'Scaffold .agent/profile.json, .agent/state.json, .agent/plan.json, .agent/active-slice.json, and .agent/verification-evidence.json for the smoke fixture.',
     'Keep scripts/smoke-test.sh and kickoff-prompt coverage truthful for packaged bootstrap.'
 ], 'advisory startup brief should preserve acceptance'
-assert brief['risks'] == [], 'recent-discussion smoke bootstrap should not invent handoff-only risks'
-assert brief['notes'] == ['No additional operator notes were derived from recent discussion.'], 'recent-discussion smoke bootstrap should keep advisory notes non-canonical'
-assert proposal['mission'] == state['mission_anchor'], 'recent-discussion smoke bootstrap should persist the synthesized mission in the proposal snapshot'
-assert proposal['source'] == 'session', 'recent-discussion smoke bootstrap should snapshot the structured-session proposal source'
+assert brief['risks'] == ['Smoke-test bootstrap should stay anchored to the fresh explicit handoff.'], 'advisory startup brief should preserve handoff risks'
+assert 'First slice goal: Scaffold canonical completion files and verify the packaged startup contract.' in brief['notes'], 'advisory startup brief should preserve the first_slice_goal in notes'
+assert 'Verification commands: npm run smoke-test' in brief['notes'], 'advisory startup brief should preserve verification_commands in notes'
 assert evidence['artifact_type'] == 'completion-verification-evidence', 'verification-evidence.json artifact_type mismatch after bootstrap'
 assert evidence['subject_type'] == 'none', 'verification-evidence.json should scaffold idle subject_type'
 assert evidence['verification_commands'] == [], 'verification-evidence.json should scaffold empty verification_commands'
@@ -222,17 +266,13 @@ assert not reminder.exists(), 'ordinary non-/cook turn should not inject complet
 assert handoff.exists(), 'ordinary non-/cook turn should inject the /cook handoff boundary reminder'
 handoff_text = handoff.read_text()
 assert '/cook is the only explicit entrypoint into long-running completion workflow.' in handoff_text, 'ordinary handoff reminder should preserve the explicit /cook workflow boundary'
-assert 'do not begin long-running product implementation in ordinary chat' in handoff_text, 'ordinary handoff reminder should block workflow-level implementation before /cook'
-assert 'recommend /cook as the workflow boundary while keeping the conversation in ordinary chat until the user explicitly runs /cook.' in handoff_text, 'ordinary handoff reminder should keep pre-/cook discussion advisory-first'
-assert 'continue that ordinary-chat discussion normally instead of switching into a handoff-only refusal mode' in handoff_text, 'ordinary handoff reminder should avoid hard refusal mode before explicit /cook'
-assert 'do not emit a structured preview or cook_handoff capsule in ordinary chat once the task is concrete enough' in handoff_text, 'ordinary handoff reminder should keep pre-/cook capsules opt-in instead of default'
-assert 'bare /cook will synthesize a startup brief from recent ordinary-chat discussion' in handoff_text, 'ordinary handoff reminder should describe /cook-time startup synthesis truthfully'
-assert 'If the user explicitly asks for a /cook preview or capsule before running /cook' in handoff_text, 'ordinary handoff reminder should keep previews opt-in'
-assert 'implementation_workflow_handoff' in handoff_text, 'ordinary handoff reminder should preserve the explicit preview handoff kind'
-assert 'first_slice_goal, first_slice_non_goals, implementation_surfaces, verification_commands, why_this_slice_first' in handoff_text, 'ordinary handoff reminder should preserve first-slice preview fields when explicitly requested'
-assert 'Any preview capsule is startup intake for /cook only' in handoff_text, 'ordinary handoff reminder should keep any preview non-canonical'
-assert 'resume from canonical .agent state' in handoff_text, 'ordinary handoff reminder should preserve active-workflow canonical resume wording'
-assert 'fresh valid explicit primary-agent handoff capsule from recent ordinary-chat discussion' not in handoff_text, 'ordinary handoff reminder should no longer describe explicit capsules as the default startup path'
+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 'do not emit a ```cook_handoff``` capsule by default in ordinary chat' in handoff_text, 'ordinary handoff reminder should stop proactive capsule emission'
+assert 'ordinary chat remains ordinary chat until the user explicitly runs /cook' in handoff_text, 'ordinary handoff reminder should preserve the explicit /cook boundary'
+assert 'do not begin long-running product implementation in ordinary chat' in handoff_text, 'ordinary handoff reminder should still block workflow-level implementation before /cook'
+assert 'Only provide a preview startup brief or ```cook_handoff``` capsule in ordinary chat when the user explicitly asks for that preview behavior.' in handoff_text, 'ordinary handoff reminder should restrict preview capsules to explicit preview requests'
+assert 'startup brief from recent discussion using primary-agent-style context' in handoff_text, 'ordinary handoff reminder should describe deferred startup synthesis'
+assert 'Start/Cancel confirmation before canonical workflow state is rewritten' in handoff_text, 'ordinary handoff reminder should preserve confirm-first startup'
 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
@@ -260,8 +300,8 @@ assert 'Canonical routing profile:' in resume, 'resume prompt should expose cano
 assert f'- task_type: {expected_task_type}' in resume, 'resume prompt missing canonical task_type'
 assert f'- evaluation_profile: {expected_eval_profile}' in resume, 'resume prompt missing canonical evaluation_profile'
 assert routing['mode'] == 'bare', 'active bare /cook should snapshot bare routing mode'
-assert routing['action'] == 'continue', 'no-discussion active bare /cook should resume from canonical state without a fresh explicit handoff'
-assert routing['reason'] == 'missing_explicit_handoff', 'no-discussion active bare /cook should explain that resume happened because no fresh explicit handoff existed'
+assert routing['action'] == 'continue', 'no-discussion active bare /cook should resume from canonical state without a concrete replacement mission'
+assert routing['reason'] == 'no_replacement_proposal', 'no-discussion active bare /cook should explain that resume happened because no replacement mission was derived'
 assert routing['currentMissionAnchor'] == state['mission_anchor'], 'resume routing snapshot should keep the current mission anchor'
 assert routing['proposedMissionAnchor'] is None, 'no-discussion active bare /cook should not propose a replacement mission'
 assert not chooser_path.exists(), 'active bare /cook resume should not open the chooser without a fresh explicit handoff'

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

@@ -1,6 +1,6 @@
 ---
 name: cook-handoff-boundary
-description: Ordinary-chat boundary contract for deciding when a task has matured enough that the primary agent must stop short of long-running implementation and hand the user off to `/cook`.
+description: Ordinary-chat boundary contract for keeping main chat advisory until the user explicitly enters `/cook`, while preventing long-running implementation from starting before that explicit workflow entry.
 ---
 
 # /cook Handoff Boundary
@@ -14,35 +14,66 @@ This skill governs the boundary between:
 
 ## Core Contract
 
-- Ordinary chat may be used to clarify requirements, discuss tradeoffs, propose implementation approaches, and refine scope with the user.
+- Ordinary chat may be used to clarify requirements, discuss tradeoffs, propose implementation approaches, and refine scope.
 - `/cook` is the only explicit entrypoint into long-running completion workflow.
-- When the primary agent judges that a task has matured into completion-workflow scope, it must stop short of long-running implementation and treat `/cook` as the workflow boundary.
-- Before the user explicitly runs `/cook`, ordinary chat remains ordinary chat: the agent may still answer follow-up questions and refine requirements instead of switching into a handoff-only refusal mode.
+- Ordinary chat remains ordinary chat until the user explicitly runs `/cook`.
+- Before that explicit `/cook` entry, the primary agent must stop short of long-running implementation for workflow-level tasks.
 
-## When To Hand Off To `/cook`
+## What Ordinary Chat May Do
 
-The primary agent should consider `/cook` handoff appropriate when one or more of the following are true:
+The primary agent may:
+
+- answer follow-up questions
+- discuss tradeoffs
+- refine scope and constraints
+- summarize likely mission, acceptance, or risks
+- help the user determine whether the work seems large enough for `/cook`
+
+The primary agent should not:
+
+- proactively tell the user to run `/cook`
+- proactively emit a `cook_handoff` capsule by default
+- act as though workflow has already started
+- rewrite ordinary-chat discussion into canonical workflow state
+
+## When Work Looks Workflow-Worthy
+
+The primary agent should treat work as workflow-worthy when one or more of the following are true:
 
-- the user has clearly shifted from exploration into implementation intent
-- the agent has just produced a concrete plan or proposal whose natural next step would be implementation
 - the task spans multiple files, steps, or verification surfaces
-- the task needs resumability, review, audit, or canonical workflow state
+- the next natural step would be bounded repo implementation rather than more explanation
+- the work needs resumability, review, audit, or canonical workflow state
 - the task is better treated as a long-running repo mission than a one-off answer or tiny fix
 
-## Required Handoff Behavior
+Even then, the boundary remains:
+
+- ordinary chat can still keep refining the task
+- only explicit `/cook` starts workflow
+
+## Required Behavior Before Explicit `/cook`
 
-When the task is judged ready for completion workflow, the primary agent must:
+When a task has matured into workflow-level work, the primary agent must:
 
 - stop before long-running implementation
-- not edit tracked product files in ordinary chat for that workflow-level task
-- recommend bare `/cook` as the explicit workflow boundary once the task is implementation-ready
-- explain that bare `/cook` synthesizes a startup brief from recent ordinary-chat discussion for a new workflow or next round, while active workflows resume from canonical state unless the user explicitly chooses a replacement path backed by a fresh valid explicit handoff
-- distinguish a workflow-worthy handoff from an opt-in preview request
-- not append an implementation-ready `/cook` handoff capsule by default once the task becomes concrete enough; ordinary chat stays advisory-first until explicit `/cook`
-- only provide a `/cook` startup preview or `cook_handoff` capsule when the user explicitly asks for that preview behavior in ordinary chat
-- if the user asks follow-up questions or refines requirements before running `/cook`, continue ordinary-chat discussion normally without acting as though workflow already started
+- not edit tracked product files for that workflow-level task in ordinary chat
+- continue ordinary discussion naturally if the user keeps asking questions or refining scope
+- wait for the user to explicitly run `/cook` before treating the conversation as workflow startup
+
+## Deferred Handoff Model
+
+When the user explicitly runs `/cook`:
+
+- `/cook` will synthesize a startup brief from recent discussion using primary-agent-style context
+- `/cook` will show Start / Cancel confirmation before canonical workflow state is rewritten
+- that synthesized startup brief is advisory intake only, not canonical `.agent/**` state by itself
+
+This means the primary agent does **not** need to proactively attach startup capsules during ordinary chat just because the task looks ready.
+
+## Optional Preview Behavior
+
+Only if the user explicitly asks for a preview startup brief or handoff capsule in ordinary chat may the primary agent provide one.
 
-Optional preview capsule format when the user explicitly asks for it:
+Optional preview capsule format:
 
 ````text
 ```cook_handoff
@@ -75,30 +106,27 @@ Notes:
 
 - `constraints` may be replaced or supplemented by `non_goals` when clearer.
 - `first_slice_goal`, `first_slice_non_goals`, `implementation_surfaces`, `verification_commands`, and `why_this_slice_first` are required only for an implementation-ready preview capsule.
-- If the work is workflow-worthy but the first slice still needs refinement, say that `/cook` will be the right next step once the slice is concrete enough, then keep refining in ordinary chat without emitting a preview capsule unless the user explicitly asks for one.
-- If later ordinary-chat discussion materially changes the startup brief before `/cook` runs, update or replace the preview capsule in a later assistant reply.
-- The mission must be positively startable implementation work; do not use rejection or suppression text as the mission.
 - Any preview capsule is startup intake for `/cook` only. It is not canonical `.agent/**` state, not active-slice state, and not a second repo contract source.
 
 Suggested wording:
 
-> This task now looks like `/cook` workflow work, but we are still in ordinary chat until you explicitly run `/cook`. If you want to keep refining the first slice first, we can do that here. Once you want to start implementation workflow, run bare `/cook` and it will synthesize the startup brief from our recent discussion before the Start/Cancel gate. If you explicitly want a preview capsule first, ask and I can sketch one here.
+> We are still in ordinary chat until you explicitly run `/cook`. If you want, we can keep refining the first slice here. When you do run `/cook`, it will synthesize a startup brief from our recent discussion and show Start / Cancel before workflow begins.
 
 A short recap may include mission, scope, or acceptance, but that recap must not be presented as canonical plan state.
 
 ## Forbidden Behaviors
 
-Once the task is judged ready for completion workflow, the primary agent must not:
+Before the user explicitly runs `/cook`, the primary agent must not:
 
 - directly begin long-running implementation in ordinary chat
 - modify tracked product files as part of that workflow-level task
 - act as though `/cook` had already been invoked
 - silently rewrite ordinary-chat discussion into active workflow state
-- refuse ordinary-chat clarification or requirement-refinement turns solely because `/cook` would now be appropriate
+- refuse ordinary-chat clarification only because `/cook` would now be appropriate
 
 ## Relationship To `completion-protocol`
 
-This skill is only about pre-`/cook` ordinary-chat handoff behavior.
+This skill is only about pre-`/cook` ordinary-chat boundary behavior.
 
 After the user explicitly enters `/cook`, the separate `completion-protocol` skill governs: