vgxness 1.9.2 → 1.9.3

package/dist/cli/commands/status-dispatcher.js

@@ -0,0 +1,130 @@
+import { MemoryService } from '../../memory/memory-service.js';
+import { openMemoryDatabase } from '../../memory/sqlite/database.js';
+import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
+import { buildProductStatus } from '../../status/product-status.js';
+import { RunService } from '../../runs/run-service.js';
+import { buildProductResume } from '../../resume/product-resume.js';
+import { databasePathFor, optionalStringFlag, requiredFlag } from '../cli-flags.js';
+import { jsonResult, resultFailure } from '../cli-helpers.js';
+import { okText, usageFailure } from '../cli-help.js';
+import { renderProductResume } from '../product-resume-renderer.js';
+import { buildProductNext, renderProductNext, renderProductStatus } from '../product-status-renderer.js';
+export function runProductStatusCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'status');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const status = buildProductStatusForCli(parsed, environment);
+    if (!status.ok)
+        return status.value;
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: status.value }) : okText(renderProductStatus(status.value));
+}
+export function runProductNextCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'next');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const status = buildProductStatusForCli(parsed, environment);
+    if (!status.ok)
+        return status.value;
+    const next = buildProductNext(status.value);
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: next }) : okText(renderProductNext(next));
+}
+export function runProductResumeCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'resume');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const resume = buildProductResumeForCli(parsed, environment);
+    if (!resume.ok)
+        return resume.value;
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: resume.value }) : okText(renderProductResume(resume.value));
+}
+function rejectExtraPositionals(parsed, command) {
+    const extra = parsed.positionals.slice(1);
+    return extra.length === 0 ? undefined : usageFailure(`${command} does not accept positional arguments: ${extra.join(' ')}`);
+}
+function buildProductStatusForCli(parsed, environment) {
+    const projectFlag = parsed.flags.project === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'project');
+    if (!projectFlag.ok)
+        return { ok: false, value: resultFailure(projectFlag) };
+    const changeFlag = parsed.flags.change === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'change');
+    if (!changeFlag.ok)
+        return { ok: false, value: resultFailure(changeFlag) };
+    const project = projectFlag.value;
+    const change = changeFlag.value;
+    if (change === undefined) {
+        const status = buildProductStatus({ cwd: environment.cwd, ...(project === undefined ? {} : { project }) });
+        return { ok: true, value: status };
+    }
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return { ok: false, value: resultFailure(selectedDatabasePath) };
+    const explicitDatabasePath = optionalStringFlag(parsed.flags, 'db');
+    const opened = openMemoryDatabase({ path: selectedDatabasePath.value, readonly: true });
+    if (!opened.ok) {
+        const status = buildProductStatus({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            change,
+            databasePath: selectedDatabasePath.value,
+            databaseError: opened.error.message,
+        });
+        return { ok: true, value: status };
+    }
+    try {
+        const status = buildProductStatus({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            change,
+            databasePath: selectedDatabasePath.value,
+            ...(explicitDatabasePath === undefined ? {} : { explicitDatabasePath }),
+            sdd: new SddWorkflowService(new MemoryService(opened.value)),
+            runs: new RunService(opened.value),
+        });
+        return { ok: true, value: status };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function buildProductResumeForCli(parsed, environment) {
+    const projectFlag = parsed.flags.project === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'project');
+    if (!projectFlag.ok)
+        return { ok: false, value: resultFailure(projectFlag) };
+    const runIdFlag = parsed.flags['run-id'] === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'run-id');
+    if (!runIdFlag.ok)
+        return { ok: false, value: resultFailure(runIdFlag) };
+    const project = projectFlag.value;
+    const runId = runIdFlag.value;
+    if (runId === undefined && project === undefined) {
+        const resume = buildProductResume({ cwd: environment.cwd, ...(project === undefined ? {} : { project }) });
+        return { ok: true, value: resume };
+    }
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return { ok: false, value: resultFailure(selectedDatabasePath) };
+    const opened = openMemoryDatabase({ path: selectedDatabasePath.value, readonly: true });
+    if (!opened.ok) {
+        const visibleDatabasePath = runId === undefined && parsed.flags.db === undefined ? undefined : selectedDatabasePath.value;
+        const resume = buildProductResume({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            ...(runId === undefined ? {} : { runId }),
+            ...(visibleDatabasePath === undefined ? {} : { databasePath: visibleDatabasePath }),
+            databaseError: opened.error.message,
+        });
+        return { ok: true, value: resume };
+    }
+    try {
+        const flaggedDatabasePath = parsed.flags.db === undefined ? undefined : selectedDatabasePath.value;
+        const resume = buildProductResume({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            ...(runId === undefined ? {} : { runId }),
+            ...(flaggedDatabasePath === undefined ? {} : { databasePath: flaggedDatabasePath }),
+            runs: new RunService(opened.value),
+        });
+        return { ok: true, value: resume };
+    }
+    finally {
+        opened.value.close();
+    }
+}

package/dist/cli/commands/workflow-dispatcher.js

@@ -1,7 +1,8 @@
 import { AgentRegistryService } from '../../agents/agent-registry-service.js';
+import { canonicalOpenCodeDefaultModel } from '../../agents/canonical-agent-manifest.js';
 import { createNaturalLanguagePlan } from '../../orchestrator/natural-language-planner.js';
 import { RunService } from '../../runs/run-service.js';
-import { isSddPhase, sddPhases } from '../../sdd/schema.js';
+import { normalizeSddPhaseInput, sddPhases } from '../../sdd/schema.js';
 import { CommandAllowlistAdapter, commandAllowlistIds } from '../../workflows/command-allowlist-adapter.js';
 import { GuardedProviderWorkflowExecutor, operationMetadataForWorkflowExecution, SafeNonDispatchingWorkflowExecutor, workflowExecutorSafety, } from '../../workflows/workflow-executor.js';
 import { getWorkflowDefinition, listWorkflows } from '../../workflows/workflow-registry.js';
@@ -248,11 +249,16 @@ export function runWorkflowRunCommand(workflow, parsed, database) {
     const selected = getWorkflowDefinition(workflow);
     const planner = createNaturalLanguagePlan({ project, intent: intent.value });
     const recommended = getWorkflowDefinition(planner.workflow);
-    const phase = optionalStringFlag(parsed.flags, 'phase') ?? selected.defaultPhase;
-    if (selected.id === 'sdd' && !isSddPhase(phase))
-        return resultFailure(validationFailure(`Unknown SDD phase: ${phase}. Expected one of: ${sddPhases.join(', ')}`));
+    const phaseInput = optionalStringFlag(parsed.flags, 'phase') ?? selected.defaultPhase;
+    let phase = phaseInput;
+    if (selected.id === 'sdd') {
+        const canonicalPhase = normalizeSddPhaseInput(phaseInput);
+        if (canonicalPhase === undefined)
+            return resultFailure(validationFailure(`Unknown SDD phase: ${phaseInput}. Expected one of: ${sddPhases.join(', ')}`));
+        phase = canonicalPhase;
+    }
     const providerAdapter = optionalStringFlag(parsed.flags, 'provider-adapter') ?? 'opencode';
-    const model = optionalStringFlag(parsed.flags, 'model') ?? 'openai/gpt-5.5';
+    const model = optionalStringFlag(parsed.flags, 'model') ?? canonicalOpenCodeDefaultModel;
     const registry = new AgentRegistryService(database);
     const explicitAgentId = optionalStringFlag(parsed.flags, 'agent-id');
     const selectedAgent = resolveWorkflowRunAgent({

package/dist/cli/dispatcher.js

@@ -5,7 +5,7 @@ import { databasePathFor, parseArgs, requiredFlag } from './cli-flags.js';
 import { okText, usageFailure, visibleHelpText } from './cli-help.js';
 import { openCliDatabase, resultFailure } from './cli-helpers.js';
 import { runBootAgentSeedUpgrade } from '../agents/boot-upgrade.js';
-import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
+import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runProductNextCommand, runProductResumeCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runProductStatusCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
 const _promptBuffers = new WeakMap();
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
@@ -17,6 +17,12 @@ export function dispatchCli(argv, environment) {
     const [area, command] = parsed.positionals;
     if (!area || area === 'help' || area === '--help' || area === '-h')
         return okText(visibleHelpText());
+    if (area === 'status')
+        return runProductStatusCommand(parsed, environment);
+    if (area === 'next')
+        return runProductNextCommand(parsed, environment);
+    if (area === 'resume')
+        return runProductResumeCommand(parsed, environment);
     if (area === 'init')
         return runSetupPlanCommand(parsed, environment);
     if (area === 'doctor')
@@ -192,10 +198,12 @@ function validateCommand(area, command) {
             command === 'execute' ||
             command === 'status' ||
             command === 'next' ||
+            command === 'continue' ||
             command === 'cockpit' ||
             command === 'ready' ||
             command === 'save-artifact' ||
             command === 'accept-artifact' ||
+            command === 'reopen-artifact' ||
             command === 'get-artifact' ||
             command === 'list-artifacts' ||
             command === 'export' ||

package/dist/cli/product-resume-renderer.js

@@ -0,0 +1,32 @@
+export function renderProductResume(resume) {
+    const lines = [
+        'Resume',
+        ...resume.resume.map((line) => `- ${line}`),
+        '',
+        'Why',
+        ...resume.why.map((line) => `- ${line}`),
+        '',
+        'Blockers',
+        ...(resume.blockers.length === 0 ? ['- none'] : resume.blockers.map((line) => `- ${line}`)),
+        ...(resume.candidateRuns.length === 0
+            ? []
+            : [
+                '',
+                'Candidate runs',
+                ...resume.candidateRuns.flatMap((run) => [
+                    `- ${run.runId} [${run.status}] ${run.workflow}/${run.phase}`,
+                    ...(run.userIntent === undefined ? [] : [`  Intent: ${run.userIntent}`]),
+                    `  Latest checkpoint: ${run.latestCheckpointLabel ?? 'none'}`,
+                    `  Resume command: ${run.command}`,
+                ]),
+            ]),
+        '',
+        'Command',
+        `- ${resume.command}`,
+        ...(resume.manualNextCommands.length === 0 ? [] : ['', 'Related commands', ...resume.manualNextCommands.map((line) => `- ${line}`)]),
+        '',
+        'Safety',
+        ...resume.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/cli/product-status-renderer.js

@@ -0,0 +1,74 @@
+export function renderProductStatus(status) {
+    const lines = [
+        'Status',
+        ...status.status.map((line) => `- ${line}`),
+        '',
+        'Blockers',
+        ...status.blockers.map((line) => `- ${line}`),
+        '',
+        'Next',
+        ...status.next.map((line) => `- ${line}`),
+        '',
+        'Command',
+        `- ${status.command}`,
+        '',
+        ...(status.relatedRunContext === undefined ? [] : relatedRunContextLines(status.relatedRunContext, true)),
+        'Safety',
+        ...status.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+export function buildProductNext(status) {
+    const blockers = status.blockers.filter((line) => line !== 'none');
+    const blocked = status.sddNextStatus === undefined ? blockers.length > 0 : status.sddNextStatus === 'blocked';
+    const visibleBlockers = blocked ? blockers : [];
+    const command = blocked ? buildBlockedNextCommand(status) : status.command;
+    return {
+        version: 1,
+        kind: 'product-next',
+        project: status.project,
+        ...(status.change === undefined ? {} : { change: status.change }),
+        blocked,
+        next: status.next,
+        why: status.status,
+        blockers: visibleBlockers,
+        command,
+        ...(status.relatedRunContext === undefined ? {} : { relatedRunContext: status.relatedRunContext }),
+        safety: status.safety,
+    };
+}
+function buildBlockedNextCommand(status) {
+    const change = status.change === undefined ? '<change>' : status.change;
+    const dbHint = status.command.includes('--db <path>') ? ' --db <path>' : '';
+    return `vgxness next --project ${status.project.value} --change ${change}${dbHint}`;
+}
+export function renderProductNext(next) {
+    const lines = [
+        'Next',
+        ...next.next.map((line) => `- ${line}`),
+        '',
+        'Why',
+        ...next.why.map((line) => `- ${line}`),
+        ...(next.blockers.length === 0 ? [] : ['', 'Blockers', ...next.blockers.map((line) => `- ${line}`)]),
+        '',
+        'Command',
+        `- ${next.command}`,
+        '',
+        ...(next.relatedRunContext === undefined ? [] : relatedRunContextLines(next.relatedRunContext, true)),
+        'Safety',
+        ...next.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+function relatedRunContextLines(relatedRunContext, includeTrailingBlank) {
+    return [
+        'Related interrupted run:',
+        `- Run ID: ${relatedRunContext.runId}`,
+        `- Status: ${relatedRunContext.status}`,
+        `- Workflow/phase: ${relatedRunContext.workflow}/${relatedRunContext.phase}`,
+        `- Latest checkpoint: ${relatedRunContext.latestCheckpointLabel ?? 'none'}`,
+        `- Recommendation: ${relatedRunContext.recommendation}`,
+        `- Resume command: ${relatedRunContext.resumeCommand}`,
+        ...(includeTrailingBlank ? [''] : []),
+    ];
+}

package/dist/cli/sdd-renderer.js

@@ -1,4 +1,5 @@
-import { normalizeSddArtifact, sddPhases } from '../sdd/schema.js';
+import { normalizeSddArtifact, sddPhases, } from '../sdd/schema.js';
+export { sddContinuationPlanFrom } from '../sdd/sdd-continuation-plan.js';
 export function renderSddStatus(input) {
     const missing = input.status.phases.filter((phase) => !phase.present).map((phase) => phase.topicKey);
     const blockers = input.status.phases.filter((phase) => phase.present && phase.accepted !== true);
@@ -34,6 +35,7 @@ export function renderSddStatus(input) {
 }
 export function renderSddNext(input) {
     const blockers = input.decision.blockedPrerequisites ?? [];
+    const guidance = input.decision.blockerGuidance ?? [];
     const phase = input.decision.nextPhase ?? 'none';
     const commandGuidance = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
         ? `vgxness code sdd ${input.decision.change} ${input.decision.nextPhase} --save-artifact`
@@ -47,17 +49,70 @@ export function renderSddNext(input) {
         `Reason: ${input.decision.reason}`,
         '',
         'Blockers:',
-        ...(blockers.length === 0 ? ['- none'] : blockers.map((blocker) => `- ${blocker.phase}: ${blocker.reason} at ${blocker.topicKey}`)),
+        ...(blockers.length === 0
+            ? ['- none']
+            : blockers.map((blocker) => `- ${blocker.phase}: ${blocker.reason} at ${blocker.topicKey}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
         '',
         'Missing topic keys:',
         ...(input.decision.missingArtifactTopicKeys.length === 0 ? ['- none'] : input.decision.missingArtifactTopicKeys.map((topicKey) => `- ${topicKey}`)),
         '',
+        'Missing prerequisite topic keys:',
+        ...((input.decision.missingPrerequisiteTopicKeys ?? []).length === 0
+            ? ['- none']
+            : (input.decision.missingPrerequisiteTopicKeys ?? []).map((topicKey) => `- ${topicKey}`)),
+        '',
+        'Next actions:',
+        ...(guidance.length === 0 ? ['- none'] : guidance.map((item) => `- ${item.phase}: ${item.action}`)),
+        '',
         `Recommended action: ${input.decision.recommendedAction}`,
         `Command: ${commandGuidance}`,
         `JSON: vgxness sdd next --project ${input.project} --change ${input.decision.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
+export function renderSddContinuationPlan(plan) {
+    const lines = [
+        'SDD Continue (read-only)',
+        `Project: ${plan.project}`,
+        `Change: ${plan.change}`,
+        `Status: ${plan.status}`,
+        `Next phase: ${plan.nextPhase ?? 'none'}`,
+        `Actionable phase: ${plan.actionablePhase ?? 'none'}`,
+        `Reason: ${plan.reason}`,
+        '',
+        'Recommended plan:',
+        `- ${plan.recommendedAction}`,
+        `- Suggested command: ${plan.suggestedCommand}`,
+        `- Inspect command: ${plan.inspectCommand}`,
+        '',
+        'Blocker-specific next actions:',
+        ...(plan.blockerActions.length === 0
+            ? ['- none']
+            : plan.blockerActions.map((item) => {
+                const draftRun = item.draftRunCommand === undefined ? '' : `; draftRunCommand=${item.draftRunCommand}`;
+                const warning = item.warning === undefined ? '' : `; warning=${item.warning}`;
+                return `- ${item.phase}: ${item.action}; command=${item.command}${draftRun}${warning}`;
+            })),
+        '',
+        ...(plan.relatedRunContext === undefined
+            ? []
+            : [
+                'Related interrupted run:',
+                `- Run ID: ${plan.relatedRunContext.runId}`,
+                `- Status: ${plan.relatedRunContext.status}`,
+                `- Workflow/phase: ${plan.relatedRunContext.workflow}/${plan.relatedRunContext.phase}`,
+                `- Latest checkpoint: ${plan.relatedRunContext.latestCheckpointLabel ?? 'none'}`,
+                `- Recommendation: ${plan.relatedRunContext.recommendation}`,
+                `- Resume command: ${plan.relatedRunContext.resumeCommand}`,
+                '',
+            ]),
+        'Safety:',
+        ...plan.safety.map((line) => `- ${line}`),
+        '',
+        `JSON: vgxness sdd continue --project ${plan.project} --change ${plan.change} --json${continuationDbFlag(plan.explicitDatabasePath)}`,
+    ];
+    return `${lines.join('\n')}\n`;
+}
 export function renderSddCockpit(cockpit) {
     const blockers = cockpit.aggregateBlockers;
     const lines = [
@@ -71,13 +126,18 @@ export function renderSddCockpit(cockpit) {
         `Legacy artifacts: ${cockpit.legacyCount}`,
         '',
         'Aggregate blockers:',
-        ...(blockers.length === 0 ? ['- none'] : blockers.map((blocker) => `- ${blocker.kind}: ${blocker.phase} at ${blocker.topicKey} — ${blocker.reason}`)),
+        ...(blockers.length === 0
+            ? ['- none']
+            : blockers.map((blocker) => `- ${blocker.kind}: ${blocker.phase} at ${blocker.topicKey} - ${blocker.reason}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
         '',
         `Inspect: ${cockpit.inspectCommand}`,
         `Cockpit JSON: ${cockpit.inspectCommand}`,
     ];
     return `${lines.join('\n')}\n`;
 }
+function continuationDbFlag(explicitDatabasePath) {
+    return explicitDatabasePath === undefined ? '' : ` --db ${explicitDatabasePath}`;
+}
 export function renderSddArtifactAccepted(input) {
     const lines = [
         'SDD Artifact Accepted',
@@ -93,6 +153,23 @@ export function renderSddArtifactAccepted(input) {
     ];
     return `${lines.join('\n')}\n`;
 }
+export function renderSddArtifactReopened(input) {
+    const lines = [
+        'SDD Artifact Reopened',
+        `- Project: ${input.project}`,
+        `- Change: ${input.change}`,
+        `- Phase: ${input.phase}`,
+        `- Status: ${input.status}`,
+        `- Topic key: ${input.topicKey}`,
+        `- Artifact ID: ${input.artifactId}`,
+        `- Reopened by: ${input.reopenedBy.displayName} (${input.reopenedBy.id})`,
+        `- Reopened at: ${input.reopenedAt}`,
+        ...(input.note === undefined ? [] : [`- Note: ${input.note}`]),
+        `Next step: update the ${input.phase} artifact, then request human acceptance again.`,
+        `JSON: vgxness sdd reopen-artifact --project ${input.project} --change ${input.change} --phase ${input.phase} --actor ${input.reopenedBy.id} --json`,
+    ];
+    return `${lines.join('\n')}\n`;
+}
 export function renderSddArtifactList(input) {
     const artifactsByPhase = new Map(input.artifacts.map((artifact) => [artifact.phase, artifact]));
     const hasArtifacts = input.artifacts.length > 0;

package/dist/code/cli/code-command.js

@@ -1,3 +1,4 @@
+import { normalizeSddPhaseInput } from '../../sdd/schema.js';
 import { resolveCodeConfig } from '../config/defaults.js';
 import { CodeProviderRegistry } from '../providers/provider-registry.js';
 import { exitCodeForCodeStatus, renderHumanCodeSummary } from '../reporting/summary.js';
@@ -31,11 +32,12 @@ export async function runCodeCommand(input) {
         };
     const intent = input.command === 'sdd' ? `Run SDD ${input.args[1] ?? ''} for ${input.args[0] ?? ''}`.trim() : input.args.join(' ').trim();
     const changeId = input.command === 'sdd' ? input.args[0] : undefined;
-    const phase = input.command === 'sdd' ? input.args[1] : undefined;
-    if (input.command === 'sdd' && (changeId === undefined || phase === undefined))
+    const phaseInput = input.command === 'sdd' ? input.args[1] : undefined;
+    const phase = phaseInput === undefined ? undefined : normalizeSddPhaseInput(phaseInput);
+    if (input.command === 'sdd' && (changeId === undefined || phaseInput === undefined))
         return { exitCode: 1, stdout: '', stderr: 'Missing sdd change and phase\n' };
-    if (input.command === 'sdd' && phase !== undefined && !isSddCodePhase(phase))
-        return { exitCode: 1, stdout: '', stderr: `Unknown SDD phase: ${phase}\n` };
+    if (input.command === 'sdd' && phaseInput !== undefined && phase === undefined)
+        return { exitCode: 1, stdout: '', stderr: `Unknown SDD phase: ${phaseInput}\n` };
     if (!intent)
         return {
             exitCode: 1,
@@ -77,6 +79,7 @@ export async function runCodeCommand(input) {
         cwd: input.cwd,
         ...(changeId === undefined ? {} : { changeId }),
         ...(phase !== undefined && isSddCodePhase(phase) ? { phase } : {}),
+        ...(input.sddRuntimeMode === undefined ? {} : { sddRuntimeMode: input.sddRuntimeMode }),
         ...(input.persistArtifact === undefined ? {} : { persistArtifact: input.persistArtifact }),
         ...(input.sddGateway === undefined ? {} : { sddGateway: input.sddGateway }),
         ...(input.memoryGateway === undefined ? {} : { memoryGateway: input.memoryGateway }),

package/dist/code/reporting/summary.js

@@ -21,7 +21,10 @@ export function renderHumanCodeSummary(summary) {
         ...(summary.sdd === undefined
             ? []
             : [
-                `SDD: ${summary.sdd.changeId}/${summary.sdd.phase} saved=${summary.sdd.artifactSaved ? 'yes' : 'no'}`,
+                `SDD: ${summary.sdd.changeId}/${summary.sdd.phase} mode=${summary.sdd.sddRuntimeMode ?? 'strict'} saved=${summary.sdd.artifactSaved ? 'yes' : 'no'}`,
+                ...(summary.sdd.sddRuntimeMode === 'draft-run'
+                    ? ['SDD draft-run note: draft prerequisites are used for planning only; human acceptance is still required; apply-progress remains gated.']
+                    : []),
                 `Next SDD step: ${summary.sdd.nextRecommendation}`,
             ]),
         `Risks: ${summary.risks.length === 0 ? 'none reported' : summary.risks.join('; ')}`,

package/dist/code/runtime/code-runtime.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { normalizeSddPhaseInput } from '../../sdd/schema.js';
 import { resolveCodeConfig } from '../config/defaults.js';
 import { buildCodePrompt } from '../prompts/prompt-builder.js';
 import { CodeProviderError } from '../providers/provider-adapter.js';
@@ -30,7 +31,13 @@ export class CodeRuntime {
             if (input.changeId === undefined || input.phase === undefined || !isSddCodePhase(input.phase))
                 throw new Error('SDD mode requires a valid changeId and phase');
             const gateway = input.sddGateway ?? new InMemorySddGateway();
-            sddContext = await loadSddContext({ gateway, project, changeId: input.changeId, phase: input.phase });
+            sddContext = await loadSddContext({
+                gateway,
+                project,
+                changeId: input.changeId,
+                phase: input.phase,
+                ...(input.sddRuntimeMode === undefined ? {} : { runtimeMode: input.sddRuntimeMode }),
+            });
         }
         const availableDefinitions = input.mode === 'sdd' && input.phase !== undefined
             ? sddToolDefinitions({ phase: input.phase, persist: input.persistArtifact === true })
@@ -117,6 +124,7 @@ export class CodeRuntime {
                 ...(diagnostics === undefined ? {} : { diagnostics: diagnostics }),
             },
             ...(sddContext === undefined ? {} : { changeId: sddContext.changeId, sddPhase: sddContext.phase }),
+            ...(sddContext === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
         });
         if (sddContext !== undefined) {
             await this.checkpoint(run.id, session, 'sdd-context-loaded', {
@@ -480,7 +488,15 @@ export class CodeRuntime {
             memory,
             ...(sddContext === undefined
                 ? {}
-                : { sdd: { changeId: sddContext.changeId, phase: sddContext.phase, artifactSaved, nextRecommendation: sddContext.next.recommendedAction } }),
+                : {
+                    sdd: {
+                        changeId: sddContext.changeId,
+                        phase: sddContext.phase,
+                        ...(sddContext.runtimeMode === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
+                        artifactSaved,
+                        nextRecommendation: sddContext.next.recommendedAction,
+                    },
+                }),
         };
         const summary = config.transcriptMode === 'off' ? baseSummary : { ...baseSummary, transcript: buildTranscript(config.transcriptMode, session.checkpoints, toolResults) };
         if (sddContext !== undefined)
@@ -533,7 +549,13 @@ export class CodeRuntime {
             verification: { status: 'not-run', reason: 'SDD phase blocked before provider execution.' },
             filesChanged: [],
             risks: [answer],
-            sdd: { changeId: sddContext.changeId, phase: sddContext.phase, artifactSaved: false, nextRecommendation: sddContext.next.recommendedAction },
+            sdd: {
+                changeId: sddContext.changeId,
+                phase: sddContext.phase,
+                ...(sddContext.runtimeMode === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
+                artifactSaved: false,
+                nextRecommendation: sddContext.next.recommendedAction,
+            },
         };
         await this.runGateway.finalize(runId, { status: 'blocked', outcome: 'blocked', outcomeReason: answer });
         return summary;
@@ -641,7 +663,8 @@ export class CodeRuntime {
                     changedFiles: [],
                 };
             if (call.name === 'sdd_read_artifact') {
-                const phase = typeof call.input.phase === 'string' && isSddCodePhase(call.input.phase) ? call.input.phase : context.phase;
+                const requestedPhase = typeof call.input.phase === 'string' ? normalizeSddPhaseInput(call.input.phase) : undefined;
+                const phase = requestedPhase !== undefined && isSddCodePhase(requestedPhase) ? requestedPhase : context.phase;
                 const artifact = await gateway.getArtifact({ project, change: context.changeId, phase });
                 return {
                     result: { toolCallId: call.id, toolName: call.name, ok: true, output: { phase, artifact }, metadata: { capability, truncated: false } },

package/dist/code/runtime/sdd-context.js

@@ -10,6 +10,7 @@ export function shellEnabledForSddPhase(phase) {
     return phase === 'apply-progress' || phase === 'verify';
 }
 export async function loadSddContext(input) {
+    const runtimeMode = input.runtimeMode ?? 'strict';
     const [status, next] = await Promise.all([
         input.gateway.getStatus({ project: input.project, change: input.changeId }),
         input.gateway.getNextPhase({ project: input.project, change: input.changeId }),
@@ -22,7 +23,7 @@ export async function loadSddContext(input) {
         if (artifact !== null)
             artifacts.push(toContextArtifact(input.project, input.changeId, phase, phase === input.phase ? 'active' : 'accepted', artifact.content, phaseStatus));
     }
-    return { changeId: input.changeId, phase: input.phase, status, next, artifacts };
+    return { changeId: input.changeId, phase: input.phase, runtimeMode, status, next, artifacts };
 }
 function toContextArtifact(project, change, phase, role, content, phaseStatus) {
     const bytes = Buffer.byteLength(content, 'utf8');
@@ -98,6 +99,8 @@ export function validateSddReadiness(context) {
                 recommendedAction: `Accept or restore prerequisites before running ${context.phase}.`,
             },
         };
+    if (isDraftRun(context) && isPlanningPhase(context.phase))
+        return { ok: true };
     if (present)
         return { ok: true };
     if (context.status.nextReadyPhase === context.phase)
@@ -123,10 +126,23 @@ export function activeBlockedPrerequisites(context) {
             return [{ phase, topicKey, reason: 'missing' }];
         if (status.accepted === true && status.legacy !== true)
             return [];
-        const reason = status.legacy === true ? 'legacy' : status.state === 'rejected' || status.state === 'superseded' ? status.state : 'draft';
+        if (status.legacy === true)
+            return [{ phase, topicKey, reason: 'legacy', ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }) }];
+        if (draftPrerequisiteAllowed(context, status.state ?? 'draft'))
+            return [];
+        const reason = status.state === 'rejected' || status.state === 'superseded' ? status.state : 'draft';
         return [{ phase, topicKey, reason, ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }) }];
     });
 }
+function draftPrerequisiteAllowed(context, state) {
+    return isDraftRun(context) && isPlanningPhase(context.phase) && state === 'draft';
+}
+function isDraftRun(context) {
+    return context.runtimeMode === 'draft-run';
+}
+function isPlanningPhase(phase) {
+    return phase === 'explore' || phase === 'proposal' || phase === 'spec' || phase === 'design' || phase === 'tasks';
+}
 function acceptedArtifactPhases(active) {
     return prerequisitePhases(active);
 }