@linimin/pi-letscook 0.1.60 → 0.1.62

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'
@@ -221,18 +265,14 @@ 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 '/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 '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 '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 '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 '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
@@ -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,48 +1,81 @@
 ---
 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 contract for treating `/cook` as an optional workflow mode while still allowing direct repo implementation in main chat when workflow state is unnecessary.
 ---
 
 # /cook Handoff Boundary
 
 Load or summarize this contract when the primary agent is operating in ordinary main chat before the user has explicitly entered `/cook`.
 
-This skill governs the boundary between:
+This skill governs the relationship between:
 
-- ordinary main-chat discussion, clarification, and proposal work
-- explicit transition into long-running completion workflow through `/cook`
+- ordinary main-chat discussion and direct implementation
+- optional transition into long-running completion workflow through `/cook`
 
 ## Core Contract
 
-- Ordinary chat may be used to clarify requirements, discuss tradeoffs, propose implementation approaches, and refine scope with the user.
-- `/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 may be used to clarify requirements, discuss tradeoffs, refine scope, and directly implement requested repo changes.
+- `/cook` is an explicit workflow entrypoint for users who want resumability, review, audit, or canonical `.agent/**` workflow state.
+- `/cook` is optional. It is not required just because the work spans multiple files or looks substantial.
+- Ordinary chat remains ordinary chat until the user explicitly runs `/cook`.
 
-## 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:
 
-- 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 task is better treated as a long-running repo mission than a one-off answer or tiny fix
+- answer follow-up questions
+- discuss tradeoffs
+- refine scope and constraints
+- summarize likely mission, acceptance, or risks
+- directly edit repo files when that is the most helpful response
+- complete multi-file implementation in ordinary chat when workflow state is unnecessary
 
-## Required Handoff Behavior
+The primary agent should not:
 
-When the task is judged ready for completion workflow, the primary agent must:
+- proactively tell the user to run `/cook` just because the task looks workflow-worthy
+- proactively emit a `cook_handoff` capsule by default
+- act as though workflow has already started when it has not
+- silently rewrite ordinary-chat discussion into canonical workflow state
 
-- 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
+## When `/cook` Is Helpful
 
-Optional preview capsule format when the user explicitly asks for it:
+The primary agent may mention `/cook` as an optional tool when it would genuinely help, for example when:
+
+- the work should be resumable across sessions
+- the user wants a tracked mission in canonical `.agent/**` state
+- the task benefits from explicit review / audit / stop-wave flow
+- the user wants a confirm-first workflow boundary before a long-running effort
+
+But even in those cases:
+
+- do not force `/cook`
+- do not frame `/cook` as mandatory for direct repo edits
+- continue helping directly in ordinary chat unless the user explicitly chooses workflow mode
+
+## Required Behavior Before Explicit `/cook`
+
+Before the user explicitly runs `/cook`, the primary agent must:
+
+- keep the interaction in ordinary chat
+- directly implement requested repo changes when appropriate instead of blocking on workflow mode
+- continue ordinary discussion naturally if the user keeps refining the task
+- avoid claiming that canonical workflow state already exists unless `/cook` actually started it
+
+## Deferred Handoff Model
+
+When the user explicitly runs `/cook`:
+
+- `/cook` synthesizes a startup brief from recent discussion using primary-agent-style context
+- `/cook` shows Start / Cancel confirmation before canonical workflow state is rewritten
+- that synthesized startup brief is advisory intake only until the user confirms startup
+
+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:
 
 ````text
 ```cook_handoff
@@ -75,30 +108,26 @@ 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 can continue directly in ordinary chat if you want. If you prefer resumable workflow state, explicit review flow, or a confirm-first startup gate, you can run `/cook` and it will synthesize a startup brief from our recent discussion 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
+- pretend `/cook` has 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
+- claim canonical `.agent/**` startup state exists when it does not
+- refuse ordinary-chat implementation solely because `/cook` would also be possible
 
 ## Relationship To `completion-protocol`
 
-This skill is only about pre-`/cook` ordinary-chat handoff behavior.
+This skill is only about pre-`/cook` ordinary-chat behavior.
 
 After the user explicitly enters `/cook`, the separate `completion-protocol` skill governs: