sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/instructions.ts

@@ -2,7 +2,7 @@ import { SDD_VERSION } from './ai-tools.js';
 
 export const SDD_INSTRUCTIONS_CONTRACT = 'sdd-instructions-v1';
 
-export type InstructionAction = 'overview' | 'init' | 'doctor' | 'update' | 'spec' | 'plan' | 'tasks' | 'verifies' | 'test' | 'do' | 'verify' | 'ship' | 'run-task' | 'verify-task';
+export type InstructionAction = 'overview' | 'init' | 'doctor' | 'update' | 'spec' | 'plan' | 'tasks' | 'execute' | 'ship';
 
 export interface SddInstructionPayload {
   contract: typeof SDD_INSTRUCTIONS_CONTRACT;
@@ -17,26 +17,25 @@ export interface SddInstructionPayload {
 
 const INSTRUCTION_PAYLOADS: Record<InstructionAction, Omit<SddInstructionPayload, 'contract' | 'version' | 'action'>> = {
   overview: {
-    summary: 'Route natural-language SDD intent from branch/source status to task execution, agent evidence, strict verification-contract consumption, goal verification, truthAlignment, and release readiness while keeping CLI/core output as source of truth.',
-    requiredCommands: ['sdd status', 'sdd lifecycle decide --from-text <text>', 'sdd doctor', 'sdd tasks inspect <task_id>', 'sdd do task <task_id-or-task-text>', 'sdd test <validation_unit_id-or-validation_text> --branch <branch>', 'sdd test close --branch <branch> --target goal-verify --json', 'sdd ship close --branch <branch> --json', 'sdd instructions ship --json'],
+    summary: 'Route natural-language SDD intent through the fixed public lifecycle spec -> plan -> tasks -> execute -> ship while keeping runtime projection, accepted evidence, checkpoint, and release readiness as CLI/core-owned truth.',
+    requiredCommands: ['sdd status', 'sdd doctor', 'sdd instructions spec --json', 'sdd instructions plan --json', 'sdd instructions tasks --json', 'sdd instructions execute --json', 'sdd execute --branch <branch> --json', 'sdd ship close --branch <branch> --json'],
     allowedSideEffects: ['read .sdd state', 'read specs documents', 'read generated AI entries'],
     forbiddenSideEffects: ['background write', 'worktree creation', 'auto commit', 'force push', 'publish or push release artifacts without explicit human confirmation'],
     nextSteps: [
       'Treat /sdd as a natural-language intent router, then run sdd status first to see branch/source context and the recommended next command; report only workflow state, blocker/current task, and next action unless the user asks for full detail.',
       'Dynamic routing comes from CLI/core output; follow the recommended next command and do not infer dynamic state from generated markdown.',
-      'Use /sdd:tasks as the user-visible bundle for tasks -> verifies, and /sdd:test as the user-visible bundle for test -> goal-verify; do not invent separate slash entries for internal substages.',
-      'If intent remains ambiguous after status, ask one clarifying question before spec/plan/tasks/do/test/ship work.',
-      'If status reports generated entry drift, missing config, compatibility drift, or projection drift, run sdd doctor and follow its current-run repair or rebuild recommendation before normal do/test/ship.',
-      'If status recommends a pending task, run sdd tasks inspect <task_id> and execute only the approved task boundary; scout/implementer/reviewer/validator participation should be recorded as stage evidence rather than hidden in the main chat.',
-      'For test, bind user intent to an accepted verify.md validation unit with sdd test <validation_unit_id-or-validation_text>; use task/batch/wave subcommands only for explicit low-level diagnostics or narrowed overrides.',
-      'After test closure is accepted, continue through /sdd:test with sdd test close --target goal-verify so runtime can record truthAlignment before ship readiness.'
+      'Use the fixed public lifecycle: /sdd:spec -> /sdd:plan -> /sdd:tasks -> /sdd:execute -> /sdd:ship.',
+      'Use /sdd:tasks to produce AI-ready implementation tickets with work-unit context, boundaries, rollback units, completion evidence, validation expected results, and failure routes; verification-design semantics belong in tasks, not a public verifies stage.',
+      'Use /sdd:execute for implementation, review, validation, debug, checkpoint, and evidence-judgment lanes; do not expose do/test/verify/goal-verify as public lifecycle stages.',
+      'If status reports generated entry drift, missing config, compatibility drift, or projection drift, run sdd doctor and follow its current-run repair or rebuild recommendation before normal execute/ship.',
+      'If status recommends a pending task, run sdd tasks inspect <task_id> and execute only the approved task boundary; scout/implementer/reviewer/validator participation should be recorded as stage evidence rather than hidden in the main chat.'
     ]
   },
   init: {
     summary: 'Initialize .sdd project configuration and managed AI tool entries for the current repository; workflow partition documents are entered through the spec stage, not init.',
     requiredCommands: ['sdd init --ai claude-code', 'sdd status', 'sdd instructions spec --json', 'sdd doctor'],
     allowedSideEffects: ['write .sdd/project.yml', 'initialize runtime.sqlite state', 'write managed generated AI entries'],
-    forbiddenSideEffects: ['create workflow partition documents unless explicitly using the spec stage or legacy --scaffold-docs', 'overwrite foreign AI entry files', 'background write', 'auto commit'],
+    forbiddenSideEffects: ['create workflow partition documents unless explicitly using the spec stage', 'overwrite foreign AI entry files', 'background write', 'auto commit'],
     nextSteps: ['Run sdd init --ai claude-code.', 'Run sdd status to inspect current Git branch partition state and the recommended next command.', 'Use the spec stage to create or refine specs/<partition>/spec.md; omitted --branch uses the current Git branch, explicit --branch uses the requested partition.', 'Run sdd doctor after initialization.']
   },
   doctor: {
@@ -54,75 +53,40 @@ const INSTRUCTION_PAYLOADS: Record<InstructionAction, Omit<SddInstructionPayload
     nextSteps: ['Run sdd update.', 'Run sdd doctor to verify drift is resolved.']
   },
   spec: {
-    summary: 'Create or refine specs/<partition>/spec.md as the workflow partition entry: omitted --branch uses the current Git branch, explicit --branch uses the requested branch partition.',
-    requiredCommands: ['sdd status', 'sdd lifecycle decide --from-text <text>', 'read specs/<partition>/spec.md', 'write specs/<partition>/spec.md'],
-    allowedSideEffects: ['read project context', 'create or read the resolved specs/<partition> directory', 'write proposed or approved requirement contract'],
-    forbiddenSideEffects: ['implement code', 'design technical solution in spec.md', 'silently advance to plan', 'auto commit'],
-    nextSteps: ['Resolve the workflow partition: omit --branch to use the current Git branch, or pass --branch <name> only when intentionally writing another partition.', 'Clarify user intent, objective/customer value, actors, scenarios, scope, and non-goals.', 'Run sdd lifecycle decide --from-text <text> when changes mention state-machine, concurrency, database, SQL, security, API/schema, CI/build, or external unknown risk.', 'Write acceptance criteria with stable IDs such as AC-1 and verification hints.', 'Record assumptions/dependencies, risks/hard gates, open questions, and lifecycle reference.', 'If this is a requirement change after plan/tasks/run work exists, update spec.md and let status expose stale downstream hashes before continuing.', 'Stop before technical design or implementation when requirement gaps remain.']
+    summary: 'Enter the spec stage through projection-backed SpecStageWorkOrderHandoff, then let spec-manager produce or refine specs/<partition>/spec.md V3 as the only runtime primary spec artifact for plan/tasks.',
+    requiredCommands: ['sdd status', 'sdd instructions spec --json', 'read specs/<partition>/spec.md', 'write specs/<partition>/spec.md', 'sdd spec close --branch <branch> --json'],
+    allowedSideEffects: ['read project context', 'read the resolved specs/<partition> directory', 'write final spec.md V3 after spec-manager synthesis', 'optionally write spec-stage side logs under .sdd/runs/<branch>/spec/'],
+    forbiddenSideEffects: ['implement code', 'design technical solution in spec.md', 'write spec-stage subagent output as runtime primary evidence', 'silently advance to plan', 'auto commit'],
+    nextSteps: ['Resolve the workflow partition: omit --branch to use the current Git branch, or pass --branch <name> only when intentionally writing another partition.', 'Run sdd instructions spec --json and read specStageWorkOrderHandoff; if it is missing, stop on the runtime authority repair reason instead of writing spec.md directly.', 'Hand off to spec-manager with the user request, current spec.md when present, the spec.md V3 artifact-depth template, and the projection-backed handoff.', 'Spec-manager uses the content chain surface request -> reframed problem -> real intent -> scope boundary -> acceptance criterion -> evidence target; it resolves knowable or researchable uncertainty through scout evidence when useful and asks the user only for blocking user decisions.', 'Spec-reviewer pressure should identify changelog-only specs, hidden user decisions, weak acceptance evidence, and plan/task leakage as repairable content findings, not runtime primary evidence.', 'Final spec.md V3 should contain Problem Reframing / Intent Discovery, Change Delta, Scope, Requirements with reasoning, Acceptance Criteria / Evidence Targets, Definitions / Rules, Planning Constraints / Signals, Open Questions / Ambiguity Ledger, and Close Quality Evidence.', 'Treat scout output, review output, and manager trace as internal or side-log material; runtime spec close accepts final spec.md ref/hash plus boundary facts only.', 'Do not include legacy lifecycle metadata, runtime gate metadata, candidate/analyzer handoff wording, implementation plan, task list, validation plan, or subagent trace in spec.md.', 'If blocking user decisions remain before plan, spec-manager must ask the user before producing a close-ready final spec.md.', 'Run sdd spec close --branch <branch> --json after final spec.md V3 is ready; plan/tasks must consume only the runtime accepted spec ref/hash.']
   },
   plan: {
-    summary: 'Refine specs/<partition>/plan.md and .sdd/runs/<branch>/plan/*.md as agent-authored plan-stage evidence, then let runtime close validate refs/hashes/contracts into SQLite.',
-    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'write specs/<partition>/plan.md', 'write .sdd/runs/<branch>/plan/plan-review-vN.md', 'write .sdd/runs/<branch>/plan/plan-manager-vN.md', 'write .sdd/runs/<branch>/plan/plan-collaboration-contract-vN.md', 'sdd plan close --branch <branch> --json'],
-    allowedSideEffects: ['read project context', 'read spec document', 'write agent-authored plan-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/plan/'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'implement code', 'silently advance to tasks', 'bypass unresolved spec gaps'],
-    nextSteps: ['Read the approved spec and acceptance criteria plus the current normalized spec contract hash from sdd status.', 'Do not write based_on_* hash metadata into plan.md; accepted dependency edges belong to runtime close/accept projections.', 'Have planner/reviewer/plan-manager author plan-stage Markdown evidence under .sdd/runs/<branch>/plan/ including a StageCollaborationContract.', 'Run sdd plan close --branch <branch> --json; runtime must validate refs/frontmatter/contracts, compute hashes, and write only .sdd/runtime.sqlite.', 'Stop with explicit plan gaps and tasks readiness; do not let runtime create or repair Markdown.']
+    summary: 'Enter the plan stage through projection-backed PlanStageWorkOrderHandoff, then let plan-manager produce specs/<partition>/plan.md V3 as an AI-ready technical design artifact for tasks.',
+    requiredCommands: ['sdd status', 'sdd instructions plan --json', 'read planStageWorkOrderHandoff.acceptedSpecRef', 'read accepted specs/<partition>/spec.md by matching hash', 'write specs/<partition>/plan.md', 'sdd plan close --branch <branch> --json'],
+    allowedSideEffects: ['read project context', 'read runtime-accepted spec document by ref/hash', 'write final plan.md V3 after plan-manager synthesis', 'optionally write plan-stage side logs under .sdd/runs/<branch>/plan/'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'implement code', 'silently advance to tasks', 'bypass unresolved spec gaps', 'write plan-stage side logs as runtime primary evidence', 'put task topology or task decomposition in plan.md'],
+    nextSteps: ['Run sdd instructions plan --json and read planStageWorkOrderHandoff; if it is missing, stop on the runtime authority repair reason instead of planning from latest spec.md.', 'Verify the opened specs/<partition>/spec.md content hash matches planStageWorkOrderHandoff.acceptedSpecRef before planning.', 'Hand off to plan-manager with the accepted spec, current plan.md when present, the plan.md V3 technical design depth template, and the projection-backed handoff.', 'Plan-manager uses the content chain code/data fact -> design implication -> technical decision -> risk control -> validation scenario, grounded in concrete project files, APIs, SQL, UI, config, or tests.', 'Use plan-scout as bounded evidence-to-plan input when code/data/domain facts are missing, and use plan-review-agent to detect dense-but-shallow plans, vague mappings, missing risk controls, weak validation hooks, and task-list leakage.', 'Do not consume spec-stage side logs, subagent payload, warnings, or spec-manager internal trace as plan input; do not expose plan-stage side logs to tasks-stage as primary input.', 'Final plan.md V3 should contain Upstream Spec Trace, Planning Problem / Strategy Framing, Current Implementation Map, Target Design Overview, Change Topology / Responsibility Boundaries, Interface / API / Schema Design, State / Data / Concurrency Design, Key Design Decisions, Alternatives Considered, Risk Controls, Validation Strategy, Rollout / Rollback / Compatibility, Task-stage Constraints, Open Questions / User Decisions, and Plan Close Quality Evidence.', 'If blocking design decisions or open questions remain before tasks, plan-manager must ask the user before producing a close-ready final plan.md.', 'Plan side logs and professional agent findings may exist as optional/internal audit material, but runtime plan close accepts final plan.md ref/hash plus boundary facts only.', 'Do not include task graph, task units, task decomposition, code diff, validation results, runtime gate metadata, candidate/analyzer wording, or subagent trace in plan.md.', 'Run sdd plan close --branch <branch> --json after final plan.md V3 is ready; tasks must consume only the runtime accepted spec and plan refs/hashes.']
   },
   tasks: {
-    summary: 'Use /sdd:tasks as the user-visible bundle for tasks -> verifies: refine specs/<partition>/tasks.md and .sdd/runs/<branch>/tasks/*.md first, then continue through the same bundle when runtime handoff targets verifies.',
-    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'read specs/<partition>/plan.md', 'sdd tasks format', 'write specs/<partition>/tasks.md', 'write .sdd/runs/<branch>/tasks/tasks-review-vN.md', 'write .sdd/runs/<branch>/tasks/tasks-manager-vN.md', 'write .sdd/runs/<branch>/tasks/tasks-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --json', 'write specs/<partition>/verify.md', 'write .sdd/runs/<branch>/verifies/verifies-review-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-manager-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --target verifies --json'],
-    allowedSideEffects: ['read spec and plan documents', 'write agent-authored tasks-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/tasks/', 'write agent-authored verifies-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/verifies/ after a runtime handoff to verifies'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'write verify.md before tasks close produces a fresh verifies handoff', 'implement code', 'execute dependency waves', 'run validation commands', 'silently advance to do', 'turn tasks.md into project-management backlog'],
-    nextSteps: ['Read approved spec acceptance IDs, approved plan design sections, and the current normalized plan contract hash from sdd status.', 'Do not write based_on_* hash metadata into tasks.md; accepted dependency edges belong to runtime close/accept projections.', 'Run sdd tasks format to get the canonical block format.', 'Map every task to acceptance_refs and plan_refs where applicable.', 'Declare change_surface, implementation_wave, validation_batch, validation_timing, requires_verify_before_next, evidence expectations, and review gates before freezing tasks.', 'Have task-planner/reviewer/tasks-manager author .sdd/runs/<branch>/tasks/*.md evidence including a StageCollaborationContract.', 'Run sdd tasks close --branch <branch> --json; runtime must validate refs/frontmatter/contracts, compute hashes, and write only .sdd/runtime.sqlite.', 'If runtime/status targets verifies inside the tasks bundle, have verification-designer/reviewer/verifies-manager author specs/<branch>/verify.md plus .sdd/runs/<branch>/verifies/*.md evidence.', 'Continue with sdd tasks close --branch <branch> --target verifies --json; runtime must validate verifies refs/contracts and return the next legal route.']
+    summary: 'Enter the tasks stage through projection-backed TasksStageWorkOrderHandoff, then let tasks-manager produce specs/<partition>/tasks.md V2 as a readable execute playbook, not a runtime metadata form.',
+    requiredCommands: ['sdd status', 'sdd instructions tasks --json', 'read tasksStageWorkOrderHandoff.acceptedSpecRef', 'read tasksStageWorkOrderHandoff.acceptedPlanRef', 'read accepted specs/<partition>/spec.md and plan.md by matching hashes', 'sdd tasks format', 'write specs/<partition>/tasks.md', 'sdd tasks close --branch <branch> --json'],
+    allowedSideEffects: ['read runtime-accepted spec and plan documents by ref/hash', 'write final tasks.md V2 after tasks-manager synthesis', 'optionally write tasks-stage side logs under .sdd/runs/<branch>/tasks/'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'implement code', 'execute dependency waves', 'run validation commands', 'silently advance to execute', 'turn tasks.md into project-management backlog', 'write tasks-stage side logs as runtime primary evidence'],
+    nextSteps: ['Run sdd instructions tasks --json and read tasksStageWorkOrderHandoff; if it is missing, stop on the runtime authority repair reason instead of slicing from latest docs.', 'Verify opened specs/<partition>/spec.md and plan.md content hashes match tasksStageWorkOrderHandoff accepted upstream refs before task slicing.', 'Hand off to tasks-manager with accepted spec, accepted plan, current tasks.md when present, the tasks.md V2 execution playbook rubric, and the projection-backed handoff.', 'Tasks-manager builds coverage across requirements, acceptance criteria, plan decisions, risks, and non-goals, then writes task units using the chain: plan decision -> work-unit boundary -> dependency / rollback rationale -> internal execution sequence -> completion evidence -> one-to-one validation task -> failure route.', 'Do not mechanically split by file type: if backend Java, SQL, XML/Dubbo wiring, UI/config, or other surfaces are one rollback unit, keep them in one implementation task and write ordered internal steps for execute.', 'Every implementation task must hand off to exactly one validation task, and every validation task must validate exactly one implementation task; split broad validation scenarios into per-task checks instead of many-to-one mappings.', 'Prefer readable execute context over schema-first metadata: each task should explain why it exists, where execute should start, what to change, what not to change, what proves completion, which validation task proves it, and where failure routes.', 'Implementation tasks do code review and basic code sanity only; validation closure belongs to validation task units and execute validation lanes.', 'Use task-slicer when rollback unit, dependency unlock, validation closure, shared writable ownership, or parallelism safety is unclear.', 'Use task-review-agent to detect TOO_THIN_FOR_EXECUTE, CHECKLIST_TASKS, SCHEMA_FIRST_TASKS, BOUNDARY_CONFLICT, VALIDATION_INSUFFICIENT, oversized-without-sequence, many-to-one validation, scope expansion, missing expected results, and missing failure routes.', 'Keep only minimal structured anchors needed for routing and parsing; do not add obligation matrices, runtime projection payloads, or metadata fields just to force quality.', 'Tasks side logs and review notes may exist as optional/internal audit material, but runtime tasks close accepts final tasks.md ref/hash plus boundary facts only.', 'Do not include code diff, validation execution results, long-term backlog state, runtime gate metadata, candidate/analyzer wording, subagent trace, or obligation/projection payloads in tasks.md.', 'Run sdd tasks close --branch <branch> --json after final tasks.md V2 is ready; execute must consume only the runtime accepted tasks ref/hash plus minimal task routing/read model.']
   },
-  verifies: {
-    summary: 'Diagnostic/internal action for verifies-stage closure; normal users enter it through /sdd:tasks with target=verifies.',
-    requiredCommands: ['sdd status', 'read specs/<partition>/tasks.md', 'write specs/<partition>/verify.md', 'write .sdd/runs/<branch>/verifies/verifies-review-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-manager-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --target verifies --json'],
-    allowedSideEffects: ['read spec, plan, and tasks documents', 'write agent-authored verifies-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/verifies/'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'run validation commands', 'modify source files', 'auto commit'],
-    nextSteps: ['Run sdd status and confirm tasks.md is current.', 'Have verification-designer/reviewer/verifies-manager author verify.md plus .sdd/runs/<branch>/verifies/*.md evidence including a StageCollaborationContract.', 'Continue through sdd tasks close --branch <branch> --target verifies --json; runtime must validate refs/frontmatter/hashes/contracts and write only .sdd/runtime.sqlite.', 'Keep direct verifies-stage entry as diagnostic/recovery only, not the normal Phase 9 happy path.', 'Use accepted verify.md to guide later test evidence expectations; do not treat it as runtime-authored evidence.']
-  },
-  test: {
-    summary: 'Use /sdd:test as the user-visible bundle for test -> goal-verify: bind validation intent to an accepted verify.md validation unit, close test-stage evidence, then continue through the same bundle so runtime records truthAlignment before ship.',
-    requiredCommands: ['sdd status', 'sdd instructions test --json', 'sdd test <validation_unit_id-or-validation_text> --branch <branch>', 'write .sdd/runs/<branch>/test/test-execution-vN.md', 'write .sdd/runs/<branch>/test/test-review-vN.md', 'write .sdd/runs/<branch>/test/test-manager-vN.md', 'write .sdd/runs/<branch>/test/test-collaboration-contract-vN.md', 'sdd test close --branch <branch> --json', 'write .sdd/runs/<branch>/goal-verify/goal-verification-vN.md', 'sdd test close --branch <branch> --target goal-verify --json'],
-    allowedSideEffects: ['run declared validation-unit commands', 'write agent-authored .sdd/runs/<branch>/test/*.md evidence', 'write agent-authored .sdd/runs/<branch>/goal-verify/*.md evidence after a runtime handoff to goal-verify', 'update runtime.sqlite validation and closure projections'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'modify source files outside validation command effects', 'author or refresh verify.md', 'auto commit', 'publish or push', 'treat command success alone as semantic PASS'],
-    nextSteps: ['Run sdd status and resolve the verify.md validation-unit boundary plus branch.', 'Confirm accepted verify.md exists for the selected branch; if missing or stale, return through the /sdd:tasks bundle with target=verifies.', 'Run the declared validation unit through sdd test <validation_unit_id-or-validation_text>; PASS command output stays in runtime read models by default, while failure/blocker diagnostics may retain scoped payload refs.', 'Use sdd test task|batch|wave only for explicit low-level diagnostics, replay, or narrowed override flags.', 'Have test-runner/reviewer/test-manager author .sdd/runs/<branch>/test/*.md evidence including a StageCollaborationContract.', 'Run sdd test close --branch <branch> --json; runtime validates evidence refs/contracts and writes only .sdd/runtime.sqlite.', 'If runtime/status targets goal-verify inside the test bundle, have goal-verifier/reviewer author .sdd/runs/<branch>/goal-verify/*.md evidence.', 'Continue with sdd test close --branch <branch> --target goal-verify --json; runtime records truthAlignment before ship readiness.']
-  },
-  do: {
-    summary: 'Semantically bind /sdd:do or sdd do task input to one accepted task boundary, then run do-stage collaboration: implementer/reviewer/do-manager write .sdd/runs/<branch>/do/*.md evidence and runtime reconciles gate truth into SQLite.',
-    requiredCommands: ['sdd status', 'sdd instructions do --json', 'sdd tasks inspect <bound_task_id>', 'write/update source files within the bound task boundary', 'write .sdd/runs/<branch>/do/implementation-vN.md', 'write .sdd/runs/<branch>/do/code-review-vN.md', 'write .sdd/runs/<branch>/do/do-manager-vN.md', 'sdd do task <task_id-or-task-text> --branch <branch>'],
-    allowedSideEffects: ['modify files within selected task boundary', 'write agent-authored .sdd/runs/<branch>/do/*.md evidence files', 'update runtime.sqlite projections and run state'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'background write', 'worktree creation', 'auto commit', 'expand beyond selected task boundary without checkpoint', 'mark missing evidence as PASS'],
-    nextSteps: ['Run sdd status, then let CLI/core bind the user request or recommended next command to exactly one accepted task boundary; task id and accepted task title/text are equivalent when they bind to the same task.', 'If binding is ambiguous, missing, stale, or boundary-expanding, stop and follow the CLI nextAction instead of implementing.', 'Run sdd instructions do --json and sdd tasks inspect <bound_task_id>.', 'Restate only the bound task Boundary, blocking gaps, and validation commands before implementation.', 'Implement only within affected_files and capture changed file refs/hashes in .sdd/runs/<branch>/do/implementation-vN.md frontmatter.', 'Have code-reviewer write .sdd/runs/<branch>/do/code-review-vN.md against the implementation evidence hash, whether approved or blocked.', 'Have do-manager write .sdd/runs/<branch>/do/do-manager-vN.md as a closure request that references the reviewed implementation and review hash.', 'Run sdd do task <task_id-or-task-text> --branch <branch>; runtime must read .sdd/runs/<branch>/do/*.md, validate frontmatter/hash/review/manager closure, and write only SQLite projections/run state.', 'Report run id, final status, binding target, blocking gaps, accepted evidence refs, and next gate; for verification proceed to sdd test <validation_unit_id-or-validation_text> --branch <branch>.']
-  },
-  verify: {
-    summary: 'Run low-level task acceptance coverage from runtime-selected reviewer/validator evidence; `sdd test <validation_unit_id-or-validation_text>` is the primary runtime gate.',
-    requiredCommands: ['sdd status', 'sdd instructions verify --json', 'sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'],
-    allowedSideEffects: ['write acceptance coverage runtime evidence', 'update runtime.sqlite diagnostic verification state'],
-    forbiddenSideEffects: ['auto commit', 'force push', 'auto-fix failures', 'mark completed with blocking validation gaps'],
-    nextSteps: ['Run goal-level verify without --run for the latest eligible partition/task run, unless inspecting an explicit run.', 'Use sdd test <validation_unit_id-or-validation_text> for primary lifecycle judgment.']
+  execute: {
+    summary: 'Use /sdd:execute to consume accepted tasks.md ref/hash and the selected task brief, then implement or validate from readable task context without reinterpreting spec.md or plan.md.',
+    requiredCommands: ['sdd status', 'sdd instructions execute --json', 'sdd tasks inspect <bound_task_id>', 'sdd execute --branch <branch> --json', 'sdd execute close --branch <branch> --json'],
+    allowedSideEffects: ['modify files within selected task boundaries', 'run declared validation commands', 'write optional agent-authored execute side evidence under .sdd/runs/<branch>/execute/', 'update runtime.sqlite projections and run state through runtime commands'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'background write', 'worktree creation', 'auto commit', 'expand beyond selected task boundary without checkpoint', 'treat command success alone as semantic PASS', 'publish or push'],
+    nextSteps: ['Run sdd status and confirm the active public stage is execute or the recommended next command routes to execute.', 'Use the accepted tasks -> execute handoff and selected task brief as the primary input; read spec.md/plan.md only as shallow constraints for ambiguity, acceptance mapping, and goal validation.', 'If the current tasks.md hash differs from the accepted tasks ref/hash, stop and route back to tasks close/repair before implementation.', 'Use implementation board lanes for implementation/review/debug work and validation/checkpoint/evidence-judgment work; report them as execute lane state, not separate public stages.', 'Start from task context: why the task exists, where to start, allowed/forbidden boundary, completion evidence, validation handoff, and failure route. Do not repair tasks.md during execute unless runtime routes back to tasks.', 'Close the public stage through sdd execute close --branch <branch> --json; execute close validates accepted tasks ref/hash and projections, not fixed execute Markdown evidence files.', 'Stop and route back to tasks/plan/spec if the task brief still lacks boundary, validation, checkpoint, acceptance, or routing context after reading the accepted tasks artifact.']
   },
   ship: {
     summary: 'Close ship readiness through agent-authored .sdd/runs/<branch>/ship/*.md evidence; optional release.md is ship-agent authored, not runtime-authored.',
     requiredCommands: ['sdd status', 'sdd instructions ship --json', 'write .sdd/runs/<branch>/ship/ship-readiness-vN.md', 'write .sdd/runs/<branch>/ship/release-review-vN.md', 'write .sdd/runs/<branch>/ship/ship-manager-vN.md', 'write .sdd/runs/<branch>/ship/ship-collaboration-contract-vN.md', 'sdd ship close --branch <branch> --json', 'npm run build', 'npm pack --dry-run --json', 'git status'],
     allowedSideEffects: ['read project status', 'read SDD documents and run evidence', 'write agent-authored .sdd/runs/<branch>/ship/*.md evidence', 'write optional agent-authored specs/<branch>/release.md', 'run local validation commands', 'record runtime ship projections in .sdd/runtime.sqlite'],
     forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'npm publish', 'git push', 'git tag', 'create GitHub release', 'force push', 'auto commit', 'skip failed gates', 'treat historical doctor debt as a release blocker unless it affects current run evidence'],
-    nextSteps: ['Run sdd status and confirm goal-verify has recorded aligned truthAlignment or validated reconciliation truth.', 'Have ship-manager/release agent author .sdd/runs/<branch>/ship/*.md evidence including a StageCollaborationContract; write specs/<branch>/release.md only as an explicit ship-agent artifact if needed.', 'Run sdd ship close --branch <branch> --json; runtime validates readiness refs/contracts/truthAlignment and writes only .sdd/runtime.sqlite.', 'Run package/build dry-run gates when preparing a real release.', 'Report PASS/BLOCKED by runtime ship readiness and local package checks.', 'Stop before npm publish, git push, git tag, or external release creation unless the user explicitly approves that separate action.']
+    nextSteps: ['Run sdd status and confirm execute has accepted implementation, validation, checkpoint, and evidence-judgment evidence for the branch.', 'Have ship-manager/release agent author .sdd/runs/<branch>/ship/*.md evidence including a StageCollaborationContract; write specs/<branch>/release.md only as an explicit ship-agent artifact if needed.', 'Run sdd ship close --branch <branch> --json; runtime validates readiness refs/contracts/truthAlignment and writes only .sdd/runtime.sqlite.', 'Run package/build dry-run gates when preparing a real release.', 'Report PASS/BLOCKED by runtime ship readiness and local package checks.', 'Stop before npm publish, git push, git tag, or external release creation unless the user explicitly approves that separate action.']
   },
-  'run-task': {
-    summary: 'Compatibility entry for running one task through do-stage runtime closure.',
-    requiredCommands: ['sdd tasks inspect <task_id>', 'sdd do task <task_id> --branch <branch>'],
-    allowedSideEffects: ['write agent-authored .sdd/runs/<branch>/do/*.md evidence', 'update runtime.sqlite run state'],
-    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'background write', 'worktree creation', 'auto commit'],
-    nextSteps: ['Inspect the task.', 'Run do-stage closure through sdd do task with .sdd/runs/<branch>/do/*.md evidence.']
-  },
-  'verify-task': {
-    summary: 'Verify task acceptance coverage using runtime-selected evidence and partition-aware run resolution.',
-    requiredCommands: ['sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'],
-    allowedSideEffects: ['write acceptance coverage runtime evidence', 'update .sdd run state'],
-    forbiddenSideEffects: ['auto commit', 'force push'],
-    nextSteps: ['Run goal-level verify without --run for the latest eligible partition/task run, unless inspecting an explicit run.', 'Use sdd test task for primary lifecycle judgment.']
-  }
   };
 
 
@@ -154,5 +118,5 @@ export function renderSddInstructions(payload: SddInstructionPayload): string {
 }
 
 function isInstructionAction(action: string): action is InstructionAction {
-  return action === 'overview' || action === 'init' || action === 'doctor' || action === 'update' || action === 'spec' || action === 'plan' || action === 'tasks' || action === 'verifies' || action === 'test' || action === 'do' || action === 'verify' || action === 'ship' || action === 'run-task' || action === 'verify-task';
+  return action === 'overview' || action === 'init' || action === 'doctor' || action === 'update' || action === 'spec' || action === 'plan' || action === 'tasks' || action === 'execute' || action === 'ship';
 }

package/node_modules/@sdd-agent-platform/core/src/lifecycle/decision-gate.test.ts

@@ -1,174 +1,174 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { initProject } from '../config/init-project.js';
-import { readRunEvents } from '../run-state/events.js';
-import { createRun, readRunState } from '../run-state/run-state.js';
-import { evaluateLifecycleDecisionGate, recordLifecycleDecision } from './decision-gate.js';
-import { renderLifecycleDecisionGate } from './rendering.js';
-import { extractLifecycleRiskSignalsFromText } from './risk-signals.js';
-
-test('lifecycle decision gate allows direct only through conservative whitelist', () => {
-  const result = evaluateLifecycleDecisionGate({
-    intent_clarity: 'high',
-    acceptance_clarity: 'high',
-    estimated_change_size: 'tiny',
-    task_count_estimate: 1,
-    file_count_estimate: 1,
-    impact_confidence: 'high',
-    risk_tags: [],
-    reversibility: 'reversible',
-    validation_clarity: 'clear',
-    validation_available: true,
-    validation_cost: 'cheap',
-    requires_agents: false,
-    handoff_count: 0,
-    artifact_dependency: false,
-    runtime_recovery_need: false,
-    orchestration_uncertainty: 'low'
-  }, new Date('2026-05-01T00:00:00.000Z'));
-
-  assert.equal(result.record.decision.profile, 'direct');
-  assert.equal(result.record.decision.confidence, 'high');
-  assert.equal(result.record.decision.hard_gate_hits.length, 0);
-  assert.equal(result.record.decision.human_checkpoint_required, false);
-  assert.equal(result.record.decision.skipped_stages.includes('full-spec'), true);
-});
-
-test('lifecycle hard gates force full profile for contract and state risks', () => {
-  const result = evaluateLifecycleDecisionGate({
-    intent_clarity: 'high',
-    acceptance_clarity: 'high',
-    impact_confidence: 'high',
-    validation_clarity: 'clear',
-    validation_available: true,
-    validation_cost: 'cheap',
-    reversibility: 'reversible',
-    affected_contracts: ['public-api'],
-    risk_tags: ['state-machine']
-  });
-
-  assert.equal(result.record.decision.profile, 'full');
-  assert.equal(result.record.decision.hard_gate_hits.includes('api_schema_contract'), true);
-  assert.equal(result.record.decision.hard_gate_hits.includes('state_machine_concurrency_liveness'), true);
-  assert.equal(result.record.decision.required_stages.includes('test'), true);
-});
-
-test('lifecycle database risk forces full hard gate and human checkpoint', () => {
-  const result = evaluateLifecycleDecisionGate({
-    intent_clarity: 'high',
-    acceptance_clarity: 'high',
-    impact_confidence: 'high',
-    validation_clarity: 'clear',
-    validation_available: true,
-    validation_cost: 'cheap',
-    reversibility: 'reversible',
-    risk_tags: ['database']
-  });
-
-  assert.equal(result.record.decision.profile, 'full');
-  assert.equal(result.record.decision.hard_gate_hits.includes('database_or_data_loss'), true);
-  assert.equal(result.record.decision.human_checkpoint_required, true);
-  assert.equal(result.checkpointRequired, true);
-});
-
-test('Phase 5.1 lifecycle risk extraction maps Chinese hard-gate text', () => {
-  const extraction = extractLifecycleRiskSignalsFromText('三线程状态流转，并发更新，SQL 拼接，数据一致性风险');
-  const categories = extraction.evidence.map((item) => item.category);
-  const result = evaluateLifecycleDecisionGate(extraction.signals);
-  const rendered = renderLifecycleDecisionGate(result);
-
-  assert.equal(extraction.source, 'from_text');
-  assert.equal(extraction.riskTags.includes('state-machine'), true);
-  assert.equal(extraction.riskTags.includes('concurrency'), true);
-  assert.equal(extraction.riskTags.includes('database'), true);
-  assert.equal(categories.includes('state_machine'), true);
-  assert.equal(categories.includes('concurrency'), true);
-  assert.equal(categories.includes('sql'), true);
-  assert.equal(categories.includes('database_data_loss'), true);
-  assert.equal(result.record.decision.profile, 'full');
-  assert.equal(result.record.decision.hard_gate_hits.includes('state_machine_concurrency_liveness'), true);
-  assert.equal(result.record.decision.hard_gate_hits.includes('database_or_data_loss'), true);
-  assert.equal(result.autonomyCeiling, 'full_sdd_with_checkpoint');
-  assert.equal(rendered.includes('Lifecycle checkpoint is required.'), true);
-  assert.equal(rendered.includes('Why:'), true);
-  assert.equal(rendered.includes('Next:'), true);
-});
-
-test('lifecycle checkpoint triggers are recorded without executing workflow', () => {
-  const result = evaluateLifecycleDecisionGate({
-    intent_clarity: 'high',
-    acceptance_clarity: 'high',
-    impact_confidence: 'high',
-    validation_clarity: 'clear',
-    validation_available: true,
-    validation_cost: 'cheap',
-    reversibility: 'reversible',
-    policy_hits: ['git_commit'],
-    permission_required: ['dependency_install'],
-    human_checkpoint_required: true
-  });
-
-  assert.equal(result.record.decision.profile, 'compact');
-  assert.equal(result.record.decision.human_checkpoint_required, true);
-  assert.equal(result.record.decision.hard_gate_hits.includes('policy_or_permission_checkpoint'), true);
-  assert.match(result.boundaries.join('\n'), /must not execute Phase 1.8 task implementation loop/);
-});
-
-test('lifecycle research gate handles unscoutable unknown impact', () => {
-  const result = evaluateLifecycleDecisionGate({
-    impact_confidence: 'low',
-    can_scout_impact: false
-  });
-
-  assert.equal(result.record.decision.profile, 'research');
-  assert.equal(result.record.decision.confidence, 'low');
-  assert.equal(result.record.decision.hard_gate_hits.includes('low_impact_confidence_unscoutable'), true);
-  assert.equal(result.record.decision.required_stages[0], 'research');
-});
-
-test('lifecycle decision gate emits canonical Phase 1.3 contract id for new records', () => {
-  const result = evaluateLifecycleDecisionGate({
-    intent_clarity: 'high',
-    acceptance_clarity: 'high',
-    impact_confidence: 'high',
-    validation_clarity: 'clear',
-    validation_available: true,
-    validation_cost: 'cheap',
-    reversibility: 'reversible'
-  });
-
-  assert.equal(result.record.contract, 'sdd-lifecycle-decision-v1');
-  assert.equal(result.record.version, '1.3.0');
-});
-
-test('recordLifecycleDecision persists command gate output to run state and events', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-lifecycle-'));
-  try {
-    await initProject(root);
-    const state = await createRun(root, { runId: 'run-1' });
-    const result = evaluateLifecycleDecisionGate({
-      intent_clarity: 'high',
-      acceptance_clarity: 'high',
-      impact_confidence: 'high',
-      validation_clarity: 'clear',
-      validation_available: true,
-      validation_cost: 'cheap',
-      reversibility: 'reversible',
-      risk_tags: ['database']
-    }, new Date('2026-05-01T00:00:00.000Z'));
-
-    await recordLifecycleDecision(root, state.runId, result.record);
-    const restored = await readRunState(root, state.runId);
-    const events = await readRunEvents(root, state.runId);
-    assert.equal(restored.lifecycleDecision?.decision.profile, 'full');
-    assert.equal(restored.lifecycleDecision?.decision.hard_gate_hits.includes('database_or_data_loss'), true);
-    assert.equal(restored.lifecycleDecision?.decision.human_checkpoint_required, true);
-    assert.equal(events.some((event) => /Lifecycle decision recorded by Phase 1.7 command gate/.test(event.summary ?? '')), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { initProject } from '../config/init-project.js';
+import { readRunEvents } from '../run-state/events.js';
+import { createRun, readRunState } from '../run-state/run-state.js';
+import { evaluateLifecycleDecisionGate, recordLifecycleDecision } from './decision-gate.js';
+import { renderLifecycleDecisionGate } from './rendering.js';
+import { extractLifecycleRiskSignalsFromText } from './risk-signals.js';
+
+test('lifecycle decision gate allows direct only through conservative whitelist', () => {
+  const result = evaluateLifecycleDecisionGate({
+    intent_clarity: 'high',
+    acceptance_clarity: 'high',
+    estimated_change_size: 'tiny',
+    task_count_estimate: 1,
+    file_count_estimate: 1,
+    impact_confidence: 'high',
+    risk_tags: [],
+    reversibility: 'reversible',
+    validation_clarity: 'clear',
+    validation_available: true,
+    validation_cost: 'cheap',
+    requires_agents: false,
+    handoff_count: 0,
+    artifact_dependency: false,
+    runtime_recovery_need: false,
+    orchestration_uncertainty: 'low'
+  }, new Date('2026-05-01T00:00:00.000Z'));
+
+  assert.equal(result.record.decision.profile, 'direct');
+  assert.equal(result.record.decision.confidence, 'high');
+  assert.equal(result.record.decision.hard_gate_hits.length, 0);
+  assert.equal(result.record.decision.human_checkpoint_required, false);
+  assert.equal(result.record.decision.skipped_stages.includes('full-spec'), true);
+});
+
+test('lifecycle hard gates force full profile for contract and state risks', () => {
+  const result = evaluateLifecycleDecisionGate({
+    intent_clarity: 'high',
+    acceptance_clarity: 'high',
+    impact_confidence: 'high',
+    validation_clarity: 'clear',
+    validation_available: true,
+    validation_cost: 'cheap',
+    reversibility: 'reversible',
+    affected_contracts: ['public-api'],
+    risk_tags: ['state-machine']
+  });
+
+  assert.equal(result.record.decision.profile, 'full');
+  assert.equal(result.record.decision.hard_gate_hits.includes('api_schema_contract'), true);
+  assert.equal(result.record.decision.hard_gate_hits.includes('state_machine_concurrency_liveness'), true);
+  assert.equal(result.record.decision.required_stages.includes('verify'), true);
+});
+
+test('lifecycle database risk forces full hard gate and human checkpoint', () => {
+  const result = evaluateLifecycleDecisionGate({
+    intent_clarity: 'high',
+    acceptance_clarity: 'high',
+    impact_confidence: 'high',
+    validation_clarity: 'clear',
+    validation_available: true,
+    validation_cost: 'cheap',
+    reversibility: 'reversible',
+    risk_tags: ['database']
+  });
+
+  assert.equal(result.record.decision.profile, 'full');
+  assert.equal(result.record.decision.hard_gate_hits.includes('database_or_data_loss'), true);
+  assert.equal(result.record.decision.human_checkpoint_required, true);
+  assert.equal(result.checkpointRequired, true);
+});
+
+test('Phase 5.1 lifecycle risk extraction maps Chinese hard-gate text', () => {
+  const extraction = extractLifecycleRiskSignalsFromText('三线程状态流转，并发更新，SQL 拼接，数据一致性风险');
+  const categories = extraction.evidence.map((item) => item.category);
+  const result = evaluateLifecycleDecisionGate(extraction.signals);
+  const rendered = renderLifecycleDecisionGate(result);
+
+  assert.equal(extraction.source, 'from_text');
+  assert.equal(extraction.riskTags.includes('state-machine'), true);
+  assert.equal(extraction.riskTags.includes('concurrency'), true);
+  assert.equal(extraction.riskTags.includes('database'), true);
+  assert.equal(categories.includes('state_machine'), true);
+  assert.equal(categories.includes('concurrency'), true);
+  assert.equal(categories.includes('sql'), true);
+  assert.equal(categories.includes('database_data_loss'), true);
+  assert.equal(result.record.decision.profile, 'full');
+  assert.equal(result.record.decision.hard_gate_hits.includes('state_machine_concurrency_liveness'), true);
+  assert.equal(result.record.decision.hard_gate_hits.includes('database_or_data_loss'), true);
+  assert.equal(result.autonomyCeiling, 'full_sdd_with_checkpoint');
+  assert.equal(rendered.includes('Lifecycle checkpoint is required.'), true);
+  assert.equal(rendered.includes('Why:'), true);
+  assert.equal(rendered.includes('Next:'), true);
+});
+
+test('lifecycle checkpoint triggers are recorded without executing workflow', () => {
+  const result = evaluateLifecycleDecisionGate({
+    intent_clarity: 'high',
+    acceptance_clarity: 'high',
+    impact_confidence: 'high',
+    validation_clarity: 'clear',
+    validation_available: true,
+    validation_cost: 'cheap',
+    reversibility: 'reversible',
+    policy_hits: ['git_commit'],
+    permission_required: ['dependency_install'],
+    human_checkpoint_required: true
+  });
+
+  assert.equal(result.record.decision.profile, 'compact');
+  assert.equal(result.record.decision.human_checkpoint_required, true);
+  assert.equal(result.record.decision.hard_gate_hits.includes('policy_or_permission_checkpoint'), true);
+  assert.match(result.boundaries.join('\n'), /must not execute Phase 1.8 task implementation loop/);
+});
+
+test('lifecycle research gate handles unscoutable unknown impact', () => {
+  const result = evaluateLifecycleDecisionGate({
+    impact_confidence: 'low',
+    can_scout_impact: false
+  });
+
+  assert.equal(result.record.decision.profile, 'research');
+  assert.equal(result.record.decision.confidence, 'low');
+  assert.equal(result.record.decision.hard_gate_hits.includes('low_impact_confidence_unscoutable'), true);
+  assert.equal(result.record.decision.required_stages[0], 'research');
+});
+
+test('lifecycle decision gate emits canonical Phase 1.3 contract id for new records', () => {
+  const result = evaluateLifecycleDecisionGate({
+    intent_clarity: 'high',
+    acceptance_clarity: 'high',
+    impact_confidence: 'high',
+    validation_clarity: 'clear',
+    validation_available: true,
+    validation_cost: 'cheap',
+    reversibility: 'reversible'
+  });
+
+  assert.equal(result.record.contract, 'sdd-lifecycle-decision-v1');
+  assert.equal(result.record.version, '1.3.0');
+});
+
+test('recordLifecycleDecision persists command gate output to run state and events', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-lifecycle-'));
+  try {
+    await initProject(root);
+    const state = await createRun(root, { runId: 'run-1' });
+    const result = evaluateLifecycleDecisionGate({
+      intent_clarity: 'high',
+      acceptance_clarity: 'high',
+      impact_confidence: 'high',
+      validation_clarity: 'clear',
+      validation_available: true,
+      validation_cost: 'cheap',
+      reversibility: 'reversible',
+      risk_tags: ['database']
+    }, new Date('2026-05-01T00:00:00.000Z'));
+
+    await recordLifecycleDecision(root, state.runId, result.record);
+    const restored = await readRunState(root, state.runId);
+    const events = await readRunEvents(root, state.runId);
+    assert.equal(restored.lifecycleDecision?.decision.profile, 'full');
+    assert.equal(restored.lifecycleDecision?.decision.hard_gate_hits.includes('database_or_data_loss'), true);
+    assert.equal(restored.lifecycleDecision?.decision.human_checkpoint_required, true);
+    assert.equal(events.some((event) => /Lifecycle decision recorded by Phase 1.7 command gate/.test(event.summary ?? '')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});