sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/registries/worker-adapters.ts

@@ -1,144 +1,144 @@
-import { readFile } from 'node:fs/promises';
-import { parseProjectConfig } from '../config/project-config.js';
-import { getProjectConfigPath } from '../runtime-paths.js';
-import type { ToolCapabilitySideEffect } from './tool-capabilities.js';
-
-export type WorkerAdapterKind = 'claude_code_subagent' | 'sdd_cli_task' | 'manual_handoff';
-export type WorkerAdapterExitStatus = 'completed' | 'failed' | 'cancelled' | 'timed_out' | 'blocked';
-export type WorkerAdapterTerminalStatus = 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'CANCELLED';
-
-export interface WorkerAdapterPayloadContract {
-  queueItemId: string;
-  runId: string;
-  taskId: string;
-  delegationId: string;
-  stateMachineVersion: string;
-}
-
-export interface WorkerAdapterOutputContract {
-  artifactReference: string;
-  terminalStatus: WorkerAdapterTerminalStatus[];
-  exitStatuses: WorkerAdapterExitStatus[];
-  requiredEvents: string[];
-}
-
-export interface WorkerAdapterContract {
-  id: string;
-  title: string;
-  version: string;
-  kind: WorkerAdapterKind;
-  capabilityId: string;
-  pluginContractId: string;
-  input: WorkerAdapterPayloadContract;
-  output: WorkerAdapterOutputContract;
-  sideEffect: ToolCapabilitySideEffect;
-  permissionPrompt: string;
-  requiredEvidence: string[];
-  forbiddenUses: string[];
-}
-
-export interface WorkerAdapterContractRegistry {
-  version: string;
-  adapters: WorkerAdapterContract[];
-}
-
-export const WORKER_ADAPTER_CONTRACT_REGISTRY_VERSION = 'phase-3.5-worker-adapter-contract-v1';
-
-const DELEGATION_STATE_MACHINE_VERSION = 'phase-3.4-delegation-state-machine-v1';
-
-const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
-  {
-    id: 'claude-code-subagent-worker',
-    title: 'Claude Code subagent worker adapter',
-    version: '1.0.0',
-    kind: 'claude_code_subagent',
-    capabilityId: 'sdd-cli',
-    pluginContractId: 'sdd-cli-runtime',
-    input: {
-      queueItemId: '<run_id>:<delegation_id>',
-      runId: '<run_id>',
-      taskId: '<task_id>',
-      delegationId: '<delegation_id>',
-      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
-    },
-    output: {
-      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
-      terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
-      exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
-      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
-    },
-    sideEffect: 'command_execution',
-    permissionPrompt: 'Run a Claude Code/subagent task for one queued delegation and persist only declared run events/stage evidence references.',
-    requiredEvidence: ['queue item id', 'delegation state transition event', 'stage evidence reference'],
-    forbiddenUses: ['bypass Claude Code permission prompts', 'execute undeclared wave scheduling', 'write outside declared .sdd/runs/<branch>/<stage> evidence or approved task scope', 'reopen terminal delegation ids']
-  },
-  {
-    id: 'manual-handoff-worker',
-    title: 'Manual handoff worker adapter',
-    version: '1.0.0',
-    kind: 'manual_handoff',
-    capabilityId: 'sdd-cli',
-    pluginContractId: 'sdd-cli-runtime',
-    input: {
-      queueItemId: '<run_id>:<delegation_id>',
-      runId: '<run_id>',
-      taskId: '<task_id>',
-      delegationId: '<delegation_id>',
-      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
-    },
-    output: {
-      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
-      terminalStatus: ['COMPLETED', 'FAILED', 'CANCELLED'],
-      exitStatuses: ['completed', 'failed', 'cancelled', 'blocked'],
-      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_cancelled']
-    },
-    sideEffect: 'read_only',
-    permissionPrompt: 'Prepare a manual delegation handoff without starting a background process.',
-    requiredEvidence: ['queue item id', 'manual handoff instructions', 'expected stage evidence reference'],
-    forbiddenUses: ['start background worker', 'claim queue item', 'mark delegation completed without stage evidence']
-  },
-  {
-    id: 'sdd-cli-task-worker',
-    title: 'SDD CLI task worker adapter',
-    version: '1.0.0',
-    kind: 'sdd_cli_task',
-    capabilityId: 'artifact-run-hygiene',
-    pluginContractId: 'artifact-run-hygiene-tools',
-    input: {
-      queueItemId: '<run_id>:<delegation_id>',
-      runId: '<run_id>',
-      taskId: '<task_id>',
-      delegationId: '<delegation_id>',
-      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
-    },
-    output: {
-      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
-      terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
-      exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
-      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
-    },
-    sideEffect: 'local_write',
-    permissionPrompt: 'Run a bounded SDD CLI task adapter and write only declared stage evidence/runtime metadata.',
-    requiredEvidence: ['queue item id', 'command output', 'sdd-result stage evidence reference'],
-    forbiddenUses: ['unapproved truth-alignment approval', 'dynamic plugin execution', 'background wave execution', 'write undeclared stage evidence']
-  }
-];
-
-export async function listWorkerAdapterContracts(projectRoot: string): Promise<WorkerAdapterContractRegistry> {
-  await assertProjectConfigReadable(projectRoot);
-  return {
-    version: WORKER_ADAPTER_CONTRACT_REGISTRY_VERSION,
-    adapters: [...BUILT_IN_WORKER_ADAPTER_CONTRACTS].sort((left, right) => left.id.localeCompare(right.id))
-  };
-}
-
-export async function inspectWorkerAdapterContract(projectRoot: string, adapterId: string): Promise<WorkerAdapterContract | null> {
-  const registry = await listWorkerAdapterContracts(projectRoot);
-  return registry.adapters.find((adapter) => adapter.id === adapterId) ?? null;
-}
-
-async function assertProjectConfigReadable(projectRoot: string): Promise<void> {
-  const configPath = getProjectConfigPath(projectRoot);
-  const raw = await readFile(configPath, 'utf8');
-  parseProjectConfig(raw, configPath);
-}
+import { readFile } from 'node:fs/promises';
+import { parseProjectConfig } from '../config/project-config.js';
+import { getProjectConfigPath } from '../runtime-paths.js';
+import type { ToolCapabilitySideEffect } from './tool-capabilities.js';
+
+export type WorkerAdapterKind = 'claude_code_subagent' | 'sdd_cli_task' | 'manual_handoff';
+export type WorkerAdapterExitStatus = 'completed' | 'failed' | 'cancelled' | 'timed_out' | 'blocked';
+export type WorkerAdapterTerminalStatus = 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'CANCELLED';
+
+export interface WorkerAdapterPayloadContract {
+  queueItemId: string;
+  runId: string;
+  taskId: string;
+  delegationId: string;
+  stateMachineVersion: string;
+}
+
+export interface WorkerAdapterOutputContract {
+  artifactReference: string;
+  terminalStatus: WorkerAdapterTerminalStatus[];
+  exitStatuses: WorkerAdapterExitStatus[];
+  requiredEvents: string[];
+}
+
+export interface WorkerAdapterContract {
+  id: string;
+  title: string;
+  version: string;
+  kind: WorkerAdapterKind;
+  capabilityId: string;
+  pluginContractId: string;
+  input: WorkerAdapterPayloadContract;
+  output: WorkerAdapterOutputContract;
+  sideEffect: ToolCapabilitySideEffect;
+  permissionPrompt: string;
+  requiredEvidence: string[];
+  forbiddenUses: string[];
+}
+
+export interface WorkerAdapterContractRegistry {
+  version: string;
+  adapters: WorkerAdapterContract[];
+}
+
+export const WORKER_ADAPTER_CONTRACT_REGISTRY_VERSION = 'phase-3.5-worker-adapter-contract-v1';
+
+const DELEGATION_STATE_MACHINE_VERSION = 'phase-3.4-delegation-state-machine-v1';
+
+const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
+  {
+    id: 'claude-code-subagent-worker',
+    title: 'Claude Code subagent worker adapter',
+    version: '1.0.0',
+    kind: 'claude_code_subagent',
+    capabilityId: 'sdd-cli',
+    pluginContractId: 'sdd-cli-runtime',
+    input: {
+      queueItemId: '<run_id>:<delegation_id>',
+      runId: '<run_id>',
+      taskId: '<task_id>',
+      delegationId: '<delegation_id>',
+      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
+    },
+    output: {
+      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
+      exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
+      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
+    },
+    sideEffect: 'command_execution',
+    permissionPrompt: 'Run a Claude Code/subagent task for one queued delegation and persist only declared run events/artifact references.',
+    requiredEvidence: ['queue item id', 'delegation state transition event', 'sdd-result artifact reference'],
+    forbiddenUses: ['bypass Claude Code permission prompts', 'execute undeclared wave scheduling', 'write outside .sdd/runs or declared artifacts', 'reopen terminal delegation ids']
+  },
+  {
+    id: 'manual-handoff-worker',
+    title: 'Manual handoff worker adapter',
+    version: '1.0.0',
+    kind: 'manual_handoff',
+    capabilityId: 'sdd-cli',
+    pluginContractId: 'sdd-cli-runtime',
+    input: {
+      queueItemId: '<run_id>:<delegation_id>',
+      runId: '<run_id>',
+      taskId: '<task_id>',
+      delegationId: '<delegation_id>',
+      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
+    },
+    output: {
+      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      terminalStatus: ['COMPLETED', 'FAILED', 'CANCELLED'],
+      exitStatuses: ['completed', 'failed', 'cancelled', 'blocked'],
+      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_cancelled']
+    },
+    sideEffect: 'read_only',
+    permissionPrompt: 'Prepare a manual delegation handoff without starting a background process.',
+    requiredEvidence: ['queue item id', 'manual handoff instructions', 'expected artifact reference'],
+    forbiddenUses: ['start background worker', 'claim queue item', 'mark delegation completed without artifact evidence']
+  },
+  {
+    id: 'sdd-cli-task-worker',
+    title: 'SDD CLI task worker adapter',
+    version: '1.0.0',
+    kind: 'sdd_cli_task',
+    capabilityId: 'artifact-run-hygiene',
+    pluginContractId: 'artifact-run-hygiene-tools',
+    input: {
+      queueItemId: '<run_id>:<delegation_id>',
+      runId: '<run_id>',
+      taskId: '<task_id>',
+      delegationId: '<delegation_id>',
+      stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
+    },
+    output: {
+      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
+      exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
+      requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
+    },
+    sideEffect: 'local_write',
+    permissionPrompt: 'Run a bounded SDD CLI task adapter and write only declared artifact/run evidence.',
+    requiredEvidence: ['queue item id', 'command output', 'sdd-result artifact reference'],
+    forbiddenUses: ['unapproved complex sync-back apply', 'dynamic plugin execution', 'background wave execution', 'write undeclared artifacts']
+  }
+];
+
+export async function listWorkerAdapterContracts(projectRoot: string): Promise<WorkerAdapterContractRegistry> {
+  await assertProjectConfigReadable(projectRoot);
+  return {
+    version: WORKER_ADAPTER_CONTRACT_REGISTRY_VERSION,
+    adapters: [...BUILT_IN_WORKER_ADAPTER_CONTRACTS].sort((left, right) => left.id.localeCompare(right.id))
+  };
+}
+
+export async function inspectWorkerAdapterContract(projectRoot: string, adapterId: string): Promise<WorkerAdapterContract | null> {
+  const registry = await listWorkerAdapterContracts(projectRoot);
+  return registry.adapters.find((adapter) => adapter.id === adapterId) ?? null;
+}
+
+async function assertProjectConfigReadable(projectRoot: string): Promise<void> {
+  const configPath = getProjectConfigPath(projectRoot);
+  const raw = await readFile(configPath, 'utf8');
+  parseProjectConfig(raw, configPath);
+}

package/node_modules/@sdd-agent-platform/core/src/registries/workflow-gates.ts

@@ -1,111 +1,111 @@
-import { readFile } from 'node:fs/promises';
-import { WORKFLOW_GATE_CONTRACT_VERSION } from '../contracts.js';
-import { parseProjectConfig } from '../config/project-config.js';
-import { getProjectConfigPath } from '../runtime-paths.js';
-
-export type WorkflowGateId = 'spec' | 'plan' | 'tasks' | 'do' | 'test' | 'doctor';
-
-export interface WorkflowGateContract {
-  version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
-  id: WorkflowGateId;
-  command: string;
-  requiredInputs: string[];
-  allowedAgents: string[];
-  requiredArtifacts: string[];
-  gateConditions: string[];
-  gapClosureBehavior: string;
-  nextAction: string;
-}
-
-export interface WorkflowGateRegistry {
-  version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
-  workflows: WorkflowGateContract[];
-}
-
-const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'spec',
-    command: 'sdd instructions spec --json',
-    requiredInputs: ['user intent or revision request', 'existing specs/<branch>/spec.md when present'],
-    allowedAgents: ['scout', 'spec-reviewer'],
-    requiredArtifacts: ['specs/<branch>/spec.md', 'spec checkpoint notes'],
-    gateConditions: ['explicit scope', 'verifiable acceptance', 'open questions listed'],
-    gapClosureBehavior: 'Stop at spec gaps; do not advance to plan until scope and acceptance are explicit.',
-    nextAction: 'Run lifecycle gate when risk is unclear, then refine specs/<branch>/spec.md.'
-  },
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'plan',
-    command: 'sdd instructions plan --json',
-    requiredInputs: ['approved spec', 'impact/risk context', 'architecture context', 'validation constraints'],
-    allowedAgents: ['scout', 'planner', 'spec-reviewer'],
-    requiredArtifacts: ['specs/<branch>/plan.md'],
-    gateConditions: ['technical solution selected', 'current and target state described', 'risk-driven design sections completed', 'validation matrix defined', 'task breakdown rationale stated'],
-    gapClosureBehavior: 'Return to spec or research when plan inputs, architecture context, risk controls, or validation evidence are ambiguous.',
-    nextAction: 'Refine specs/<branch>/plan.md as the technical solution document and stop before task writing if plan gaps remain.'
-  },
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'tasks',
-    command: 'sdd instructions tasks --json',
-    requiredInputs: ['approved spec', 'approved plan', 'task boundary candidates'],
-    allowedAgents: ['planner', 'reviewer'],
-    requiredArtifacts: ['specs/<branch>/tasks.md', '.sdd/runs/<branch>/tasks/*.md', 'specs/<branch>/verify.md', '.sdd/runs/<branch>/verifies/*.md'],
-    gateConditions: ['each task has boundary', 'affected files declared when knowable', 'validation declared', 'verifies closes only after tasks handoff'],
-    gapClosureBehavior: 'Run sdd tasks gaps and fix blocking task metadata before implementation.',
-    nextAction: 'Close tasks, then close verifies through the /sdd:tasks bundle when runtime handoff targets verifies.'
-  },
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'do',
-    command: 'sdd do task <task_id>',
-    requiredInputs: ['selected task', 'boundary', 'acceptance', 'declared validation'],
-    allowedAgents: ['scout', 'implementer', 'reviewer', 'debugger', 'validator'],
-    requiredArtifacts: ['.sdd/runs/<branch>/do/implementation-vN.md', '.sdd/runs/<branch>/do/code-review-vN.md', '.sdd/runs/<branch>/do/do-manager-vN.md'],
-    gateConditions: ['single selected task', 'no blocking task gaps', 'reviewed implementation evidence', 'manager closure request'],
-    gapClosureBehavior: 'Block on missing boundary, missing validation, invalid stage evidence, or expanded scope.',
-    nextAction: 'Run inside the selected task boundary and record .sdd/runs/<branch>/do/*.md evidence before test.'
-  },
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'test',
-    command: 'sdd test <validation_unit_id-or-validation_text>',
-    requiredInputs: ['verify.md validation unit boundary', 'validation command ledger', 'validation evidence'],
-    allowedAgents: ['validator', 'reviewer'],
-    requiredArtifacts: ['.sdd/runs/<branch>/test/*.md', '.sdd/runs/<branch>/goal-verify/*.md', 'truthAlignment projection when goal-verify closes'],
-    gateConditions: ['acceptance mapped to evidence', 'validation gaps explicit', 'workflow gate policy known', 'goal-verify closes before ship'],
-    gapClosureBehavior: 'Return PASS, FAIL, or BLOCKED when command execution or acceptance evidence is incomplete.',
-    nextAction: 'Close test evidence, then close goal-verify before ship readiness.'
-  },
-  {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    id: 'doctor',
-    command: 'sdd doctor',
-    requiredInputs: ['project config', 'managed AI entries', 'run evidence'],
-    allowedAgents: ['scout'],
-    requiredArtifacts: ['doctor report'],
-    gateConditions: ['config readable', 'managed entries current', 'run evidence consistent'],
-    gapClosureBehavior: 'Report maintenance action instead of mutating source files automatically.',
-    nextAction: 'Run the recommended maintenance command or return to status when healthy.'
-  }
-];
-
-export async function listWorkflowGates(projectRoot: string): Promise<WorkflowGateRegistry> {
-  await assertProjectConfigReadable(projectRoot);
-  return {
-    version: WORKFLOW_GATE_CONTRACT_VERSION,
-    workflows: [...BUILT_IN_WORKFLOW_GATES].sort((left, right) => left.id.localeCompare(right.id))
-  };
-}
-
-export async function inspectWorkflowGate(projectRoot: string, workflowId: string): Promise<WorkflowGateContract | null> {
-  const registry = await listWorkflowGates(projectRoot);
-  return registry.workflows.find((workflow) => workflow.id === workflowId) ?? null;
-}
-
-async function assertProjectConfigReadable(projectRoot: string): Promise<void> {
-  const configPath = getProjectConfigPath(projectRoot);
-  const raw = await readFile(configPath, 'utf8');
-  parseProjectConfig(raw, configPath);
-}
+import { readFile } from 'node:fs/promises';
+import { WORKFLOW_GATE_CONTRACT_VERSION } from '../contracts.js';
+import { parseProjectConfig } from '../config/project-config.js';
+import { getProjectConfigPath } from '../runtime-paths.js';
+
+export type WorkflowGateId = 'spec' | 'plan' | 'tasks' | 'execute' | 'ship' | 'doctor';
+
+export interface WorkflowGateContract {
+  version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
+  id: WorkflowGateId;
+  command: string;
+  requiredInputs: string[];
+  allowedAgents: string[];
+  requiredArtifacts: string[];
+  gateConditions: string[];
+  gapClosureBehavior: string;
+  nextAction: string;
+}
+
+export interface WorkflowGateRegistry {
+  version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
+  workflows: WorkflowGateContract[];
+}
+
+const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'spec',
+    command: 'sdd instructions spec --json',
+    requiredInputs: ['user intent or revision request', 'existing specs/<branch>/spec.md when present'],
+    allowedAgents: ['scout', 'spec-reviewer'],
+    requiredArtifacts: ['specs/<branch>/spec.md', 'spec checkpoint notes'],
+    gateConditions: ['explicit scope', 'verifiable acceptance', 'open questions listed'],
+    gapClosureBehavior: 'Stop at spec gaps; do not advance to plan until scope and acceptance are explicit.',
+    nextAction: 'Run lifecycle gate when risk is unclear, then refine specs/<branch>/spec.md.'
+  },
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'plan',
+    command: 'sdd instructions plan --json',
+    requiredInputs: ['approved spec', 'impact/risk context', 'architecture context', 'validation constraints'],
+    allowedAgents: ['plan-manager', 'plan-scout', 'plan-review-agent'],
+    requiredArtifacts: ['specs/<branch>/plan.md'],
+    gateConditions: ['technical solution selected', 'current and target state described', 'risk-driven design sections completed', 'validation matrix defined', 'task breakdown rationale stated'],
+    gapClosureBehavior: 'Return to spec or research when plan inputs, architecture context, risk controls, or validation evidence are ambiguous.',
+    nextAction: 'Refine specs/<branch>/plan.md as the technical solution document and stop before task writing if plan gaps remain.'
+  },
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'tasks',
+    command: 'sdd instructions tasks --json',
+    requiredInputs: ['approved spec', 'approved plan', 'task boundary candidates'],
+    allowedAgents: ['tasks-manager', 'task-slicer', 'task-review-agent'],
+    requiredArtifacts: ['specs/<branch>/tasks.md'],
+    gateConditions: ['each task has boundary', 'affected files declared when knowable', 'validation declared'],
+    gapClosureBehavior: 'Run sdd tasks gaps and fix blocking task metadata before implementation.',
+    nextAction: 'Create executable sdd-task blocks, then run sdd tasks gaps --branch <branch>.'
+  },
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'execute',
+    command: 'sdd execute --branch <branch> --json',
+    requiredInputs: ['accepted tasks ref/hash', 'TaskUnitProjection', 'ExecutionLaneProjection'],
+    allowedAgents: ['implementer', 'reviewer', 'debugger', 'validator'],
+    requiredArtifacts: ['optional execute side evidence under .sdd/runs/<branch>/execute/'],
+    gateConditions: ['accepted task projections exist', 'implementation work units routed', 'test work units routed'],
+    gapClosureBehavior: 'Block on missing accepted tasks projection, invalid task unit projection, or missing implementation/test work units.',
+    nextAction: 'Coordinate implementation and validation work units, then run sdd execute close --branch <branch> --json.'
+  },
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'ship',
+    command: 'sdd ship --branch <branch> --dry-run',
+    requiredInputs: ['completed execute stage', 'accepted implementation and validation evidence'],
+    allowedAgents: ['reviewer'],
+    requiredArtifacts: ['ship readiness report'],
+    gateConditions: ['execute closed', 'blocking validation gaps absent', 'release risks explicit'],
+    gapClosureBehavior: 'Block ship when execute evidence or release readiness is incomplete.',
+    nextAction: 'Run sdd ship --branch <branch> --dry-run before final release action.'
+  },
+  {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    id: 'doctor',
+    command: 'sdd doctor',
+    requiredInputs: ['project config', 'managed AI entries', 'run evidence'],
+    allowedAgents: ['scout'],
+    requiredArtifacts: ['doctor report'],
+    gateConditions: ['config readable', 'managed entries current', 'run evidence consistent'],
+    gapClosureBehavior: 'Report maintenance action instead of mutating source files automatically.',
+    nextAction: 'Run the recommended maintenance command or return to status when healthy.'
+  }
+];
+
+export async function listWorkflowGates(projectRoot: string): Promise<WorkflowGateRegistry> {
+  await assertProjectConfigReadable(projectRoot);
+  return {
+    version: WORKFLOW_GATE_CONTRACT_VERSION,
+    workflows: [...BUILT_IN_WORKFLOW_GATES].sort((left, right) => left.id.localeCompare(right.id))
+  };
+}
+
+export async function inspectWorkflowGate(projectRoot: string, workflowId: string): Promise<WorkflowGateContract | null> {
+  const registry = await listWorkflowGates(projectRoot);
+  return registry.workflows.find((workflow) => workflow.id === workflowId) ?? null;
+}
+
+async function assertProjectConfigReadable(projectRoot: string): Promise<void> {
+  const configPath = getProjectConfigPath(projectRoot);
+  const raw = await readFile(configPath, 'utf8');
+  parseProjectConfig(raw, configPath);
+}

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

@@ -1,42 +1,42 @@
-export * from './registries/agent-registry.js';
-export * from './registries/agent-runtime-static.js';
-export * from './registries/agent-capability-catalog.js';
-export * from './registries/command-team-runtime.js';
-export * from './registries/capability-sources.js';
-export * from './registries/skill-capabilities.js';
-export * from './registries/tool-capabilities.js';
-export * from './registries/tool-plugins.js';
-export * from './registries/worker-adapters.js';
-export * from './registries/workflow-gates.js';
-export {
-  inspectHarnessLearningContract,
-  inspectProjectContextPackContract,
-  inspectSkillAgentEvalContract,
-  validateHarnessLearningContract,
-  validateProjectContextPackContract,
-  validateSkillAgentEvalContract
-} from './registries/eval-learning-context.js';
-export type {
-  ContractValidationIssue as EvalLearningContractValidationIssue,
-  HarnessLearningContract,
-  HarnessLearningSink,
-  HarnessLearningSinkId,
-  HarnessLearningValidation,
-  ProjectContextPackContract,
-  ProjectContextPackValidation,
-  SkillAgentEvalContract,
-  SkillAgentEvalDimension,
-  SkillAgentEvalDimensionId,
-  SkillAgentEvalValidation
-} from './registries/eval-learning-context.js';
-export {
-  inspectQueryStatusContract,
-  validateQueryStatusContract
-} from './registries/query-status.js';
-export type {
-  ContractValidationIssue as QueryStatusContractValidationIssue,
-  QueryStatusContract,
-  QueryStatusSurface,
-  QueryStatusValidation,
-  QuerySurfaceId
-} from './registries/query-status.js';
+export * from './registries/agent-registry.js';
+export * from './registries/agent-runtime-static.js';
+export * from './registries/agent-capability-catalog.js';
+export * from './registries/command-team-runtime.js';
+export * from './registries/capability-sources.js';
+export * from './registries/skill-capabilities.js';
+export * from './registries/tool-capabilities.js';
+export * from './registries/tool-plugins.js';
+export * from './registries/worker-adapters.js';
+export * from './registries/workflow-gates.js';
+export {
+  inspectHarnessLearningContract,
+  inspectProjectContextPackContract,
+  inspectSkillAgentEvalContract,
+  validateHarnessLearningContract,
+  validateProjectContextPackContract,
+  validateSkillAgentEvalContract
+} from './registries/eval-learning-context.js';
+export type {
+  ContractValidationIssue as EvalLearningContractValidationIssue,
+  HarnessLearningContract,
+  HarnessLearningSink,
+  HarnessLearningSinkId,
+  HarnessLearningValidation,
+  ProjectContextPackContract,
+  ProjectContextPackValidation,
+  SkillAgentEvalContract,
+  SkillAgentEvalDimension,
+  SkillAgentEvalDimensionId,
+  SkillAgentEvalValidation
+} from './registries/eval-learning-context.js';
+export {
+  inspectQueryStatusContract,
+  validateQueryStatusContract
+} from './registries/query-status.js';
+export type {
+  ContractValidationIssue as QueryStatusContractValidationIssue,
+  QueryStatusContract,
+  QueryStatusSurface,
+  QueryStatusValidation,
+  QuerySurfaceId
+} from './registries/query-status.js';