sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -62,15 +62,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      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/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']
+    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',
@@ -87,15 +87,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      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 artifact reference'],
-    forbiddenUses: ['start background worker', 'claim queue item', 'mark delegation completed without artifact evidence']
+    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',
@@ -112,15 +112,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      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 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']
+    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']
   }
 ];
 

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

@@ -51,10 +51,10 @@ const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
     command: 'sdd instructions tasks --json',
     requiredInputs: ['approved spec', 'approved plan', 'task boundary candidates'],
     allowedAgents: ['planner', 'reviewer'],
-    requiredArtifacts: ['specs/<branch>/tasks.md'],
-    gateConditions: ['each task has boundary', 'affected files declared when knowable', 'validation declared'],
+    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: 'Create executable sdd-task blocks, then run sdd tasks gaps --branch <branch>.'
+    nextAction: 'Close tasks, then close verifies through the /sdd:tasks bundle when runtime handoff targets verifies.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,
@@ -62,21 +62,21 @@ const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
     command: 'sdd do task <task_id>',
     requiredInputs: ['selected task', 'boundary', 'acceptance', 'declared validation'],
     allowedAgents: ['scout', 'implementer', 'reviewer', 'debugger', 'validator'],
-    requiredArtifacts: ['artifacts/implement-<task>.md', 'artifacts/review-<task>.md', 'artifacts/validation-<task>.md'],
-    gateConditions: ['single selected task', 'no blocking task gaps', 'artifact template available'],
-    gapClosureBehavior: 'Block on missing boundary, missing validation, invalid artifact, or expanded scope.',
-    nextAction: 'Run inside the selected task boundary and record sdd-result artifacts before test.'
+    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 task <task_id> | sdd test batch <batch_id> | sdd test wave',
-    requiredInputs: ['task, batch, or wave boundary', 'validation command ledger', 'validation evidence'],
+    command: 'sdd test <validation_unit_id-or-validation_text>',
+    requiredInputs: ['verify.md validation unit boundary', 'validation command ledger', 'validation evidence'],
     allowedAgents: ['validator', 'reviewer'],
-    requiredArtifacts: ['artifacts/validation-<task>.md', 'workflow gate decision when PASS'],
-    gateConditions: ['acceptance mapped to evidence', 'validation gaps explicit', 'workflow gate policy known'],
+    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: 'Proceed to decision card if policy requires one, otherwise ship dry-run after PASS.'
+    nextAction: 'Close test evidence, then close goal-verify before ship readiness.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,

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

@@ -30,7 +30,7 @@ export interface RequiredEvidence {
   id: string;
   acceptanceRef: string;
   kind: 'command' | 'artifact' | 'review' | 'runtime-projection' | 'manual';
-  requiredBefore: 'sync-back' | 'ship' | 'handoff';
+  requiredBefore: 'ship' | 'handoff';
   refs: RuntimeRef[];
   reasons: string[];
 }
@@ -38,7 +38,7 @@ export interface RequiredEvidence {
 export interface RequiredReview {
   id: string;
   kind: 'source-boundary' | 'runtime-state' | 'security' | 'evidence' | 'release';
-  requiredBefore: 'handoff' | 'sync-back' | 'ship';
+  requiredBefore: 'handoff' | 'ship';
   reasons: string[];
 }
 

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

@@ -130,10 +130,10 @@ function requiredStagesForProfile(profile: LifecycleRiskProfile): LifecycleRiskD
     return ['do', 'test'];
   }
   if (profile === 'compact') {
-    return ['tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back'];
+    return ['tasks', 'verifies', 'do', 'test', 'goal-verify'];
   }
   if (profile === 'full') {
-    return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back'];
+    return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
   }
   if (profile === 'research') {
     return ['spec', 'plan', 'verifies'];
@@ -157,7 +157,7 @@ function requiredEvidenceFor(profile: LifecycleRiskProfile, signals: CodingRiskS
     id: 'phase8-risk:command-evidence',
     acceptanceRef: 'phase8-risk-decision',
     kind: 'command',
-    requiredBefore: 'sync-back',
+    requiredBefore: 'ship',
     refs,
     reasons: uniqueStrings(reasons)
   }];
@@ -221,7 +221,7 @@ function decisionReasons(input: LifecycleRiskDecisionInput, profile: LifecycleRi
 }
 
 function allStages(): LifecycleRiskDecision['requiredStages'] {
-  return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back', 'ship'];
+  return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
 }
 
 function uniqueStrings<T extends string>(values: T[]): T[] {

package/node_modules/@sdd-agent-platform/core/src/risk/legacy-adapters.ts

@@ -172,9 +172,6 @@ function legacyStageToSddStage(stage: string): SddStage | null {
   if (['goal-verify', 'verify', 'acceptance-verify', 'evidence-judgment'].includes(normalized)) {
     return 'goal-verify';
   }
-  if (['sync-back', 'sync-back-proposal'].includes(normalized)) {
-    return 'sync-back';
-  }
   if (normalized === 'ship') {
     return 'ship';
   }
@@ -186,10 +183,10 @@ function defaultStagesForProfile(profile: LifecycleRiskProfile): SddStage[] {
     return ['do', 'test'];
   }
   if (profile === 'compact') {
-    return ['tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back'];
+    return ['tasks', 'verifies', 'do', 'test', 'goal-verify'];
   }
   if (profile === 'full') {
-    return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back'];
+    return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
   }
   if (profile === 'research') {
     return ['spec', 'plan', 'verifies'];
@@ -205,7 +202,7 @@ function lifecycleRequiredEvidence(requiredStages: SddStage[], inputRefs: Runtim
     id: 'legacy-lifecycle:test-evidence',
     acceptanceRef: 'legacy-lifecycle-decision',
     kind: 'command',
-    requiredBefore: 'sync-back',
+    requiredBefore: 'ship',
     refs: inputRefs,
     reasons: hardGateHits.length > 0 ? [`Legacy lifecycle hard gates require command evidence: ${hardGateHits.join(', ')}.`] : ['Legacy lifecycle requires validation evidence.']
   }];
@@ -250,7 +247,7 @@ function lifecycleApprovalPolicy(profile: LifecycleRiskProfile, checkpointRequir
 }
 
 function allSddStages(): SddStage[] {
-  return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back', 'ship'];
+  return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
 }
 
 function uniqueStages(values: SddStage[]): SddStage[] {

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

@@ -4,7 +4,7 @@ import type { ApprovalPolicy, LifecycleRiskDecision, LifecycleRiskProfile } from
 
 export type LifecycleWorkflowGate =
   | 'direct'
-  | 'review-before-sync-back'
+  | 'review-before-ship'
   | 'review-before-test'
   | 'approval-before-test'
   | 'research-before-implementation'
@@ -32,7 +32,7 @@ export function evaluateTaskWorkflowGate(input: {
   const riskProfile = input.task ? buildTaskRiskProfile(input.task) : null;
   const lifecycleGate = selectLifecycleGate(riskProfile, input.riskDecision ?? null);
   const primaryReason = primaryReasonForGate(lifecycleGate, input.taskId, riskProfile, input.riskDecision ?? null);
-  const nextAction = nextActionForGate(lifecycleGate, input.taskId, Boolean(input.approved));
+  const nextAction = nextActionForGate(lifecycleGate, input.taskId, Boolean(input.approved), input.riskDecision ?? null);
   const blocksRoute = routeBlockedByGate(lifecycleGate, Boolean(input.approved));
   const blocksTest = testBlockedByGate(lifecycleGate, Boolean(input.approved), Boolean(input.reviewerCheckpointSatisfied));
 
@@ -55,7 +55,7 @@ export function verifyContractBlockedGate(taskId: string): LifecycleWorkflowGate
     approvalPolicy: 'blocked',
     requiredStages: [],
     primaryReason: `verify.md is missing, stale, or invalid, so validation commands cannot run for ${taskId}.`,
-    nextAction: `Run sdd instructions verify --json, fix or refresh verify.md for ${taskId}, then rerun sdd test task ${taskId}.`,
+    nextAction: `Run sdd instructions verify --json, fix or refresh verify.md for ${taskId}, then rerun sdd test task-${taskId}.`,
     blocksRoute: false,
     blocksTest: true
   };
@@ -71,7 +71,7 @@ export function testBlockedByGate(gate: LifecycleWorkflowGate, approved = false,
   return ['review-before-test', 'approval-before-test', 'research-before-implementation', 'clarify-before-routing', 'verify-contract-blocked'].includes(gate);
 }
 
-export function gateRequiresSyncBackReview(gate: LifecycleWorkflowGate): boolean {
+export function gateRequiresShipReview(gate: LifecycleWorkflowGate): boolean {
   return gate !== 'direct';
 }
 
@@ -106,7 +106,7 @@ function selectLifecycleGate(riskProfile: TaskRiskProfile | null, riskDecision:
       candidates.push('review-before-test');
     }
     if (tags.has('validation-only') || riskProfile.contextRisk || riskProfile.tokenRisk || riskProfile.performanceRisk) {
-      candidates.push('review-before-sync-back');
+      candidates.push('review-before-ship');
     }
   }
 
@@ -129,7 +129,7 @@ function gateRank(gate: LifecycleWorkflowGate): number {
       return 3;
     case 'review-before-test':
       return 4;
-    case 'review-before-sync-back':
+    case 'review-before-ship':
       return 5;
     case 'direct':
       return 6;
@@ -147,7 +147,7 @@ function primaryReasonForGate(gate: LifecycleWorkflowGate, taskId: string, riskP
   switch (gate) {
     case 'clarify-before-routing':
       return riskDecision?.profile === 'blocked' || riskDecision?.approvalPolicy === 'blocked'
-        ? `Task ${taskId} is missing clear intent, acceptance, validation, or routable task data.`
+        ? riskDecision.reasons[0] ?? `Task ${taskId} is blocked by lifecycle routing.`
         : `Task ${taskId} contains unknown risk and needs clarification before routing.`;
     case 'research-before-implementation':
       return `Task ${taskId} depends on external or low-confidence impact and needs research before implementation.`;
@@ -155,8 +155,8 @@ function primaryReasonForGate(gate: LifecycleWorkflowGate, taskId: string, riskP
       return `Task ${taskId} includes security, token/secret, database, data-loss, or similarly high-impact risk that needs human approval before validation.`;
     case 'review-before-test':
       return `Task ${taskId} touches source, runtime state, API/schema, state/concurrency, or CI/build boundaries that need review before validation.`;
-    case 'review-before-sync-back':
-      return `Task ${taskId} can be validated, but ${reviewBeforeSyncBackReason(riskProfile)} requires review before applying status.`;
+    case 'review-before-ship':
+      return `Task ${taskId} can be validated, but ${reviewBeforeShipReason(riskProfile)} requires review before ship readiness.`;
     case 'direct':
       return `No high-risk lifecycle gate applies to ${taskId}.`;
     case 'verify-contract-blocked':
@@ -164,7 +164,7 @@ function primaryReasonForGate(gate: LifecycleWorkflowGate, taskId: string, riskP
   }
 }
 
-function reviewBeforeSyncBackReason(riskProfile: TaskRiskProfile | null): string {
+function reviewBeforeShipReason(riskProfile: TaskRiskProfile | null): string {
   if (riskProfile?.validationOnly) {
     return 'validation/evidence-only work';
   }
@@ -177,24 +177,26 @@ function reviewBeforeSyncBackReason(riskProfile: TaskRiskProfile | null): string
   return 'the lifecycle gate';
 }
 
-function nextActionForGate(gate: LifecycleWorkflowGate, taskId: string, approved: boolean): string {
+function nextActionForGate(gate: LifecycleWorkflowGate, taskId: string, approved: boolean, riskDecision: LifecycleRiskDecision | null): string {
   switch (gate) {
     case 'clarify-before-routing':
-      return `Update ${taskId} with clear intent, boundary, acceptance, validation, and impact, then rerun sdd tasks route ${taskId}.`;
+      return riskDecision?.profile === 'blocked' || riskDecision?.approvalPolicy === 'blocked'
+        ? 'Run /sdd or /sdd:spec to create or refresh the lifecycle decision before using stage-local entries.'
+        : `Update ${taskId} with clear intent, boundary, acceptance, validation, and impact, then rerun sdd tasks route ${taskId}.`;
     case 'research-before-implementation':
       return `Record research evidence for ${taskId}, document impact and validation, then rerun sdd tasks route ${taskId}.`;
     case 'approval-before-test':
       return approved
         ? `Run or continue validation for ${taskId} with the recorded approval.`
-        : `Have a human review the risk, affected files, and validation commands; if accepted, rerun sdd test task ${taskId} --approved.`;
+        : `Have a human review the risk, affected files, and validation commands; if accepted, rerun sdd test task-${taskId} --approved.`;
     case 'review-before-test':
-      return `Have a reviewer inspect affected files and validation commands for ${taskId}, record the checkpoint, then rerun sdd test task ${taskId}.`;
-    case 'review-before-sync-back':
-      return `Run validation for ${taskId}, then inspect the sync-back proposal before applying status.`;
+      return `Have a reviewer inspect affected files and validation commands for ${taskId}, record the checkpoint, then rerun sdd test task-${taskId}.`;
+    case 'review-before-ship':
+      return `Run validation for ${taskId}, then review accepted evidence before ship readiness.`;
     case 'direct':
-      return `Run validation for ${taskId}; sync-back can be direct after PASS.`;
+      return `Run validation for ${taskId}; proceed to goal-verify and ship after PASS.`;
     case 'verify-contract-blocked':
-      return `Run sdd instructions verify --json, fix or refresh verify.md for ${taskId}, then rerun sdd test task ${taskId}.`;
+      return `Run sdd instructions verify --json, fix or refresh verify.md for ${taskId}, then rerun sdd test task-${taskId}.`;
   }
 }
 

package/node_modules/@sdd-agent-platform/core/src/router/agent-runtime-config.ts

@@ -276,7 +276,7 @@ function skillCapabilityEvidenceTypeField(value: string | undefined): SkillCapab
 }
 
 function capabilitySourceKindField(value: string | undefined): CapabilitySourceKind {
-  return value === 'native_host' || value === 'mcp_tool' || value === 'open_source_material' || value === 'mechanism_reference' || value === 'future_adapter' || value === 'project_material' ? value : 'project_material';
+  return value === 'native_host' || value === 'mcp_tool' || value === 'cli_tool' || value === 'user_global_material' || value === 'open_source_material' || value === 'mechanism_reference' || value === 'future_adapter' || value === 'project_material' ? value : 'project_material';
 }
 
 function capabilitySourceQuarantineStatusField(value: string | undefined, fallback: CapabilitySourceQuarantineStatus): CapabilitySourceQuarantineStatus {

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

@@ -13,6 +13,7 @@ import {
 import type { LifecycleAutonomyCeiling } from '../lifecycle/decision-gate.js';
 import type { ArtifactResultIngestionStatus } from '../artifacts/ingestion.js';
 import type { SddResultStatus } from '../artifacts/sdd-result.js';
+import type { StageRouteBinding } from './stage-route-binding.js';
 import type { RouteCacheMetadata, RuntimeProfileSpan, TeamModeActivation } from './route-cache.js';
 import type { ApprovalPolicy, LifecycleRiskProfile, LifecycleWorkflowGate } from '../risk.js';
 import type { AgentCapabilityAuthority, AgentCapabilityDomain, AgentCapabilityMaterialPack, MaterialPackLoadPolicy } from '../registries/agent-capability-catalog.js';
@@ -350,6 +351,7 @@ export interface AgentRouterDecision {
   requiredArtifacts: string[];
   blockedReason: string | null;
   nextAction: string;
+  stageRouteBinding?: StageRouteBinding;
   capabilityDecision: AgentCapabilityRouteDecision;
   registrySources?: RuntimeRegistryEntrySource[];
   resolvedAliases?: AgentRuntimeAliasResolution[];

package/node_modules/@sdd-agent-platform/core/src/router/route-projection.ts

@@ -176,7 +176,7 @@ export function buildToolPermissionSpec(task: SddTask, profile: AgentProfileId,
     profile,
     risk: [...task.risk],
     toolGroups,
-    fileScope: task.affectedFiles.length > 0 ? [...task.affectedFiles] : ['declared task boundary', 'artifacts/<task>.md'],
+    fileScope: task.affectedFiles.length > 0 ? [...task.affectedFiles] : ['declared task boundary', '.sdd/runs/<branch>/<stage>/<task>.md'],
     policy: highRisk || autonomyCeiling === 'full_sdd_with_checkpoint' || autonomyCeiling === 'research_before_implementation' ? 'ask' : 'allow',
     approvalPolicy: highRisk ? 'human checkpoint required before write or external side effect' : 'host approval policy applies',
     runtimeValidationRequired: highRisk || profile === 'implementer' || profile === 'validator',