vgxness 1.9.2 → 1.9.4

package/dist/cli/commands/memory-sdd-dispatcher.js

@@ -6,14 +6,15 @@ import { planMemoryImportDryRun, validateMemoryImportPackage, writeMemoryImportO
 import { MemoryService } from '../../memory/memory-service.js';
 import { createNaturalLanguagePlan } from '../../orchestrator/natural-language-planner.js';
 import { OpenCodeInjectionPreviewService } from '../../providers/opencode/injection-preview.js';
+import { RunService } from '../../runs/run-service.js';
 import { ArtifactPortabilityService } from '../../sdd/artifact-portability-service.js';
-import { isSddPhase, sddPhases } from '../../sdd/schema.js';
+import { normalizeSddArtifact, normalizeSddPhaseInput, sddPhases } from '../../sdd/schema.js';
 import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
 import { SkillRegistryService } from '../../skills/skill-registry-service.js';
 import { acceptedAtFlag, databasePathSelectionFor, optionalNumberFlag, optionalScopeFlag, optionalStringFlag, optionalTrimmedFlag, requiredFlag, requiredTrimmedFlag, scopeFlag, } from '../cli-flags.js';
 import { okText, usageFailure, validationFailure } from '../cli-help.js';
 import { formatMemoryImportValidationErrors, jsonResult, openCliDatabase, readJsonFile, resultFailure, validateMemoryImportMode, writeJsonFile, } from '../cli-helpers.js';
-import { renderSddArtifactAccepted, renderSddCockpit, renderSddArtifactDetail, renderSddArtifactList, renderSddNext, renderSddStatus, } from '../sdd-renderer.js';
+import { renderSddArtifactAccepted, renderSddArtifactReopened, renderSddCockpit, renderSddArtifactDetail, renderSddArtifactList, renderSddContinuationPlan, renderSddNext, renderSddStatus, sddContinuationPlanFrom, } from '../sdd-renderer.js';
 export function runMemoryCommand(command, parsed, database) {
     const handlers = createMemoryToolHandlers({ service: new MemoryService(database), config: { localMemoryEnabled: true } });
     const context = { actor: 'cli' };
@@ -122,6 +123,26 @@ export function runSddCommand(command, parsed, database, environment) {
             return jsonResult(next);
         return okText(renderSddNext({ project: project.value, decision: next.value }));
     }
+    if (command === 'continue') {
+        const next = service.getNext({ project: project.value, change: change.value });
+        if (!next.ok)
+            return jsonResult(next);
+        const cockpit = service.getCockpit({ project: project.value, change: change.value });
+        if (!cockpit.ok)
+            return jsonResult(cockpit);
+        const explicitDatabasePath = optionalStringFlag(parsed.flags, 'db');
+        const relatedRun = new RunService(database).findRelatedInterruptedSddRun({ project: project.value, change: change.value });
+        if (!relatedRun.ok)
+            return jsonResult(relatedRun);
+        const plan = sddContinuationPlanFrom({
+            project: project.value,
+            next: next.value,
+            cockpit: cockpit.value,
+            ...(relatedRun.value === undefined ? {} : { relatedRunContext: relatedRun.value }),
+            ...(explicitDatabasePath === undefined ? {} : { explicitDatabasePath }),
+        });
+        return parsed.flags.json === true ? jsonResult({ ok: true, value: plan }) : okText(renderSddContinuationPlan(plan));
+    }
     if (command === 'cockpit') {
         const cockpit = service.getCockpit({ project: project.value, change: change.value });
         if (!cockpit.ok || parsed.flags.json === true)
@@ -159,7 +180,8 @@ export function runSddCommand(command, parsed, database, environment) {
             return resultFailure(note);
         if (!acceptedAt.ok)
             return resultFailure(acceptedAt);
-        if (!isSddPhase(phase.value))
+        const canonicalPhase = normalizeSddPhaseInput(phase.value);
+        if (canonicalPhase === undefined)
             return resultFailure(validationFailure(`Unknown SDD phase: ${phase.value}. Expected one of: ${sddPhases.join(', ')}`));
         const acceptedBy = {
             type: 'human',
@@ -169,7 +191,7 @@ export function runSddCommand(command, parsed, database, environment) {
         const accepted = service.acceptArtifact({
             project: project.value,
             change: change.value,
-            phase: phase.value,
+            phase: canonicalPhase,
             acceptedBy,
             acceptedAt: acceptedAt.value,
             ...(note.value === undefined ? {} : { note: note.value }),
@@ -179,7 +201,7 @@ export function runSddCommand(command, parsed, database, environment) {
         const view = {
             project: accepted.value.project,
             change: change.value,
-            phase: phase.value,
+            phase: canonicalPhase,
             topicKey: accepted.value.topicKey,
             artifactId: accepted.value.id,
             status: 'accepted',
@@ -189,6 +211,50 @@ export function runSddCommand(command, parsed, database, environment) {
         };
         return parsed.flags.json === true ? jsonResult({ ok: true, value: view }) : okText(renderSddArtifactAccepted(view));
     }
+    if (command === 'reopen-artifact') {
+        const phase = requiredTrimmedFlag(parsed.flags, 'phase');
+        const actor = requiredTrimmedFlag(parsed.flags, 'actor');
+        const displayName = optionalTrimmedFlag(parsed.flags, 'display-name');
+        const note = optionalTrimmedFlag(parsed.flags, 'note');
+        if (!phase.ok)
+            return resultFailure(phase);
+        if (!actor.ok)
+            return resultFailure(actor);
+        if (!displayName.ok)
+            return resultFailure(displayName);
+        if (!note.ok)
+            return resultFailure(note);
+        const canonicalPhase = normalizeSddPhaseInput(phase.value);
+        if (canonicalPhase === undefined)
+            return resultFailure(validationFailure(`Unknown SDD phase: ${phase.value}. Expected one of: ${sddPhases.join(', ')}`));
+        const reopenedBy = {
+            type: 'human',
+            id: actor.value,
+            displayName: displayName.value ?? actor.value,
+        };
+        const reopened = service.reopenArtifact({
+            project: project.value,
+            change: change.value,
+            phase: canonicalPhase,
+            reopenedBy,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        });
+        if (!reopened.ok)
+            return resultFailure(reopened);
+        const normalized = normalizeSddArtifact(reopened.value);
+        const view = {
+            project: reopened.value.project,
+            change: change.value,
+            phase: canonicalPhase,
+            topicKey: reopened.value.topicKey,
+            artifactId: reopened.value.id,
+            status: normalized.metadata.status,
+            reopenedBy,
+            reopenedAt: normalized.metadata.reopen?.reopenedAt ?? normalized.metadata.updatedAt ?? reopened.value.updatedAt,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        };
+        return parsed.flags.json === true ? jsonResult({ ok: true, value: view }) : okText(renderSddArtifactReopened(view));
+    }
     if (command === 'get-artifact') {
         const phase = requiredFlag(parsed.flags, 'phase');
         if (!phase.ok)

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

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 import { AgentRegistryService } from '../../agents/agent-registry-service.js';
+import { computeEffectiveManagerInstructions } from '../../agents/manager-profile-overlay-service.js';
 import { resolveAgentProfileModel } from '../../agents/profile-model-routing.js';
 import { installOpenCodeMcpClient } from '../../mcp/client-install-opencode.js';
 import { createMcpClientSetupPreview } from '../../mcp/client-setup-preview.js';
@@ -144,16 +145,27 @@ export async function applySetupPlanInput(input, environment) {
                 plan: plan.value,
             },
         };
-    const result = await installOpenCodeMcpClient({
-        cwd: environment.cwd,
-        databasePath: plan.value.db.path,
-        databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
-        scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
-        env: environment.env,
-        confirmed: true,
-        mcpOnly: input.installMode === 'mcp-only',
-        ...(input.overwriteVgxness === undefined ? {} : { overwriteVgxness: input.overwriteVgxness }),
-    });
+    const opened = openCliDatabase(plan.value.db.path);
+    if (!opened.ok)
+        return opened;
+    let result;
+    try {
+        const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value, input.project);
+        result = await installOpenCodeMcpClient({
+            cwd: environment.cwd,
+            databasePath: plan.value.db.path,
+            databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
+            scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
+            env: environment.env,
+            confirmed: true,
+            mcpOnly: input.installMode === 'mcp-only',
+            ...(input.overwriteVgxness === undefined ? {} : { overwriteVgxness: input.overwriteVgxness }),
+            ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+        });
+    }
+    finally {
+        opened.value.close();
+    }
     return result.status === 'installed'
         ? {
             ok: true,

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,81 @@
+export function renderProductStatus(status) {
+    const commandHeading = productCommandHeading(status);
+    const lines = [
+        'Status',
+        ...status.status.map((line) => `- ${line}`),
+        '',
+        'Blockers',
+        ...status.blockers.map((line) => `- ${line}`),
+        '',
+        'Next',
+        ...status.next.map((line) => `- ${line}`),
+        '',
+        commandHeading,
+        `- ${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 commandHeading = next.blocked ? 'Recovery/diagnostic command' : 'Manual fallback command';
+    const lines = [
+        'Next',
+        ...next.next.map((line) => `- ${line}`),
+        '',
+        'Why',
+        ...next.why.map((line) => `- ${line}`),
+        ...(next.blockers.length === 0 ? [] : ['', 'Blockers', ...next.blockers.map((line) => `- ${line}`)]),
+        '',
+        commandHeading,
+        `- ${next.command}`,
+        '',
+        ...(next.relatedRunContext === undefined ? [] : relatedRunContextLines(next.relatedRunContext, true)),
+        'Safety',
+        ...next.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+function productCommandHeading(status) {
+    if (status.sddNextStatus === 'runnable')
+        return 'Manual fallback command';
+    return 'Recovery/diagnostic command';
+}
+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);
@@ -9,7 +10,8 @@ export function renderSddStatus(input) {
         ? 'No next SDD phase remains for this change.'
         : input.status.nextReadyPhase === undefined
             ? 'Review blockers or accept present draft artifacts before continuing.'
-            : `Run or draft the ${input.status.nextReadyPhase} phase with ${directPhaseCommand}.`;
+            : `Continue the ${input.status.nextReadyPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`;
+    const commandLabel = directPhaseCommand === undefined ? 'Diagnostic command' : 'Manual fallback command';
     const lines = [
         'SDD Status',
         `Project: ${input.project}`,
@@ -27,17 +29,22 @@ export function renderSddStatus(input) {
         ...(missing.length === 0 ? ['- none'] : missing.map((topicKey) => `- ${topicKey}`)),
         '',
         `Recommended action: ${recommendedAction}`,
-        `Command: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
+        `${commandLabel}: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
         `JSON: vgxness sdd status --project ${input.project} --change ${input.status.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
 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`
         : `vgxness sdd status --project ${input.project} --change ${input.decision.change}`;
+    const commandLabel = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined ? 'Manual fallback command' : 'Diagnostic command';
+    const primaryAction = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
+        ? `Continue the ${input.decision.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`
+        : input.decision.recommendedAction;
     const lines = [
         'SDD Next',
         `Project: ${input.project}`,
@@ -47,17 +54,71 @@ 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}`)),
         '',
-        `Recommended action: ${input.decision.recommendedAction}`,
-        `Command: ${commandGuidance}`,
+        '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: ${primaryAction}`,
+        `${commandLabel}: ${commandGuidance}`,
         `JSON: vgxness sdd next --project ${input.project} --change ${input.decision.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
+export function renderSddContinuationPlan(plan) {
+    const suggestedCommandLabel = plan.status === 'runnable' ? 'Manual fallback command' : 'Diagnostic command';
+    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.status === 'runnable' && plan.nextPhase !== undefined ? `Continue the ${plan.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.` : plan.recommendedAction}`,
+        `- ${suggestedCommandLabel}: ${plan.suggestedCommand}`,
+        `- Diagnostic command: ${plan.inspectCommand}`,
+        '',
+        'Blocker-specific next actions:',
+        ...(plan.blockerActions.length === 0
+            ? ['- none']
+            : plan.blockerActions.map((item) => {
+                const draftRun = item.draftRunCommand === undefined ? '' : `; manualFallbackCommand=${item.draftRunCommand}`;
+                const warning = item.warning === undefined ? '' : `; warning=${item.warning}`;
+                return `- ${item.phase}: ${item.action}; recoveryCommand=${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 +132,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 +159,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;