vgxness 1.9.1 → 1.9.3

package/dist/agents/canonical-agent-projection.js

@@ -1,4 +1,4 @@
-import { canonicalAgentManifest, canonicalDefaultAgentName, canonicalOpenCodeManagerPrompt, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddSubagentPrompt, createCanonicalOpenCodeSddTaskPermissions, validateCanonicalAgentManifest, } from './canonical-agent-manifest.js';
+import { canonicalAgentManifest, canonicalDefaultAgentName, canonicalOpenCodeManagerReasoningEffort, canonicalOpenCodeManagerPrompt, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddSubagentPrompt, createCanonicalOpenCodeSddTaskPermissions, validateCanonicalAgentManifest, } from './canonical-agent-manifest.js';
 export function canonicalManifestValidationErrors(manifest = canonicalAgentManifest) {
     const validation = validateCanonicalAgentManifest(manifest);
     return validation.ok ? [] : validation.errors;
@@ -19,10 +19,10 @@ export function projectCanonicalAgentManifestToOpenCode(manifest = canonicalAgen
             description: 'VGXNESS SDD Manager - coordinates MCP state and SDD sub-agents, avoids inline execution when delegation is safer',
             mode: 'primary',
             ...(manager.adapters?.opencode?.model !== undefined ? { model: manager.adapters.opencode.model } : {}),
-            options: { reasoningEffort: 'high', vgxnessPromptContractVersion: canonicalPromptContractVersion },
-            permission: { task: createCanonicalOpenCodeSddTaskPermissions() },
+            options: { reasoningEffort: canonicalOpenCodeManagerReasoningEffort, vgxnessPromptContractVersion: canonicalPromptContractVersion },
+            permission: openCodePermissionsFor(manager, { task: createCanonicalOpenCodeSddTaskPermissions() }),
             prompt: canonicalOpenCodeManagerPrompt,
-            reasoningEffort: 'high',
+            reasoningEffort: canonicalOpenCodeManagerReasoningEffort,
             tools: { bash: true, delegate: true, delegation_list: true, delegation_read: true, edit: true, read: true, write: true },
             variant: '',
         },
@@ -38,6 +38,7 @@ export function projectCanonicalAgentManifestToOpenCode(manifest = canonicalAgen
             ...(subagent.adapters?.opencode?.model !== undefined ? { model: subagent.adapters.opencode.model } : {}),
             options: { vgxnessPromptContractVersion: canonicalPromptContractVersion },
             prompt: createCanonicalOpenCodeSddSubagentPrompt(name),
+            permission: openCodePermissionsFor(subagent),
             tools: { bash: true, edit: true, read: true, write: true },
         };
     }
@@ -73,6 +74,13 @@ export function projectCanonicalAgentManifestToClaudeCode(manifest = canonicalAg
     }
     return { defaultAgent: canonicalDefaultAgentName, agents };
 }
+export function withEffectiveManagerInstructions(projection, instructions) {
+    const trimmed = instructions?.trim() ?? '';
+    if (trimmed === '')
+        return projection;
+    const agents = projection.agents.map((agent) => agent.canonicalName === projection.defaultAgent ? { ...agent, instructions: trimmed } : agent);
+    return { defaultAgent: projection.defaultAgent, agents };
+}
 export function projectCanonicalAgentManifestToClaudeProjectMemory(manifest = canonicalAgentManifest) {
     assertValidCanonicalManifest(manifest);
     return {
@@ -105,6 +113,32 @@ function assertValidCanonicalManifest(manifest) {
     if (errors.length > 0)
         throw new Error(`Invalid canonical agent manifest: ${errors.join('; ')}`);
 }
+function openCodePermissionsFor(agent, additional = {}) {
+    const adapterPermission = asRecord(agent.adapters?.opencode?.config?.permission);
+    return { ...adapterPermission, ...additional, ...mapCanonicalPermissionsToOpenCode(agent.permissions) };
+}
+function mapCanonicalPermissionsToOpenCode(permissions) {
+    const mapped = {};
+    if (permissions === undefined)
+        return mapped;
+    for (const [canonical, openCode] of openCodePermissionMappings) {
+        const decision = permissions[canonical];
+        if (decision !== undefined)
+            mapped[openCode] = decision;
+    }
+    return mapped;
+}
+function asRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return value;
+}
+const openCodePermissionMappings = [
+    ['read', 'read'],
+    ['edit', 'edit'],
+    ['shell', 'bash'],
+    ['external-directory', 'external_directory'],
+];
 function toSeedAgent(agent) {
     const seed = {
         name: agent.name,

package/dist/agents/manager-profile-overlay-service.js

@@ -1,3 +1,5 @@
+import { AgentRegistryService } from './agent-registry-service.js';
+import { ManagerProfileOverlayRepository } from './repositories/manager-profile-overlays.js';
 export class ManagerProfileOverlayService {
     dependencies;
     constructor(dependencies) {
@@ -36,3 +38,15 @@ function ok(value) {
 function validationFailure(message) {
     return { ok: false, error: { code: 'validation_failed', message } };
 }
+export function computeEffectiveManagerInstructions(database, project = 'vgxness', scope = 'project', managerName = 'vgxness-manager') {
+    const registry = new AgentRegistryService(database);
+    const overlays = new ManagerProfileOverlayRepository(database);
+    const service = new ManagerProfileOverlayService({ agents: registry, overlays });
+    const resolved = service.resolveEffectiveManager({ project, scope, managerName });
+    if (!resolved.ok || resolved.value.overlay === undefined)
+        return undefined;
+    const overlayInstructions = resolved.value.overlay.instructions.trim();
+    if (overlayInstructions === '')
+        return undefined;
+    return overlayInstructions;
+}

package/dist/agents/repositories/agent-seed-history.js

@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+export class AgentSeedHistoryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    append(input) {
+        const validation = validate(input);
+        if (!validation.ok)
+            return validation;
+        try {
+            const id = randomUUID();
+            const appliedAt = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO agent_seed_history(id, applied_at, from_version, to_version, agent_name, project, scope, outcome, reason, source)
+        VALUES (@id, @appliedAt, @fromVersion, @toVersion, @agentName, @project, @scope, @outcome, @reason, @source)
+      `)
+                .run({
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            });
+            const entry = {
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            };
+            return ok(entry);
+        }
+        catch (cause) {
+            return fail('Failed to append agent_seed_history entry', cause);
+        }
+    }
+    listRecent(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            for (const [key, column] of [
+                ['project', 'project'],
+                ['scope', 'scope'],
+                ['agentName', 'agent_name'],
+            ]) {
+                const value = filters[key];
+                if (value !== undefined) {
+                    where.push(`${column}=@${key}`);
+                    parameters[key] = value;
+                }
+            }
+            const limit = Math.max(1, Math.min(filters.limit ?? 100, 1000));
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM agent_seed_history
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY applied_at DESC
+        LIMIT ${limit}
+      `)
+                .all(parameters);
+            return ok(rows.map(map));
+        }
+        catch (cause) {
+            return fail('Failed to list agent_seed_history entries', cause);
+        }
+    }
+}
+function validate(input) {
+    if (!input.project.trim())
+        return validationFailure('agent_seed_history project is required');
+    if (input.scope !== 'project' && input.scope !== 'personal')
+        return validationFailure('agent_seed_history scope is invalid');
+    if (!input.agentName.trim())
+        return validationFailure('agent_seed_history agentName is required');
+    if (!Number.isInteger(input.toVersion) || input.toVersion <= 0)
+        return validationFailure('agent_seed_history toVersion must be a positive integer');
+    if (input.fromVersion !== null && (!Number.isInteger(input.fromVersion) || input.fromVersion < 0))
+        return validationFailure('agent_seed_history fromVersion must be null or non-negative integer');
+    if (!input.source.trim())
+        return validationFailure('agent_seed_history source is required');
+    if (input.outcome !== 'created' &&
+        input.outcome !== 'upgraded' &&
+        input.outcome !== 'noop' &&
+        input.outcome !== 'overwrote-custom-instructions' &&
+        input.outcome !== 'validation_failed' &&
+        input.outcome !== 'db_error') {
+        return validationFailure(`agent_seed_history outcome is invalid: ${input.outcome}`);
+    }
+    return ok(undefined);
+}
+function map(row) {
+    return {
+        id: String(row.id),
+        appliedAt: String(row.applied_at),
+        fromVersion: row.from_version === null || row.from_version === undefined ? null : Number(row.from_version),
+        toVersion: Number(row.to_version),
+        agentName: String(row.agent_name),
+        project: String(row.project),
+        scope: row.scope,
+        outcome: String(row.outcome),
+        reason: row.reason === null || row.reason === undefined ? null : String(row.reason),
+        source: String(row.source),
+    };
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}
+function fail(message, cause) {
+    const error = { code: 'validation_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}

package/dist/cli/cli-help.js

@@ -6,6 +6,9 @@ Global flags:
   --version, -v    Print the installed package version.
 
 Areas:
+  status [--project <name>] [--change <id>] [--db <path>] [--json]
+  next [--project <name>] [--change <id>] [--db <path>] [--json]
+  resume [--project <name>] [--run-id <id>] [--db <path>] [--json]
   init [--project <name>] [--provider opencode|claude|none] [--scope user|project] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents] [--json]
   setup plan [--project <name>] [--provider opencode|claude|none] [--scope user|project] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents] [--json]
   setup apply --yes [--project <name>] [--provider opencode|claude|none] [--scope user|project] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents]
@@ -16,6 +19,10 @@ Areas:
   verification plan --type docs-only|test-only|cli|mcp|sdd-storage|provider-setup|package-release|workflow-runs [--json]
   verification report save --project <name> --change <id> --file <report.json> [--db <path>] [--json]
   verification report get --project <name> --change <id> [--db <path>] [--json]
+  Status answers "where am I?" with the human front-door cockpit.
+  Next answers "what should I do now?" with a shorter next-action view.
+  Resume answers "how do I continue interrupted work?" with run inspection guidance.
+  Without --change or --run-id they stay orientation-only and do not open local memory; with --change or --run-id they read SQLite read-only. Pass --json for automation.
   Setup plan/init default to human-readable read-only output; pass --json for automation. Setup apply writes OpenCode config only with --yes and uses the global user DB plus mcp-plus-agents by default.
   Setup status defaults to human-readable read-only output; pass --json for automation. It never writes provider config or executes providers.
   Doctor defaults to human-readable output; pass --json for automation.
@@ -38,8 +45,8 @@ Areas:
   code plan "<task>" [--json|--events-jsonl] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--transcript off|summary|full] [--memory off|ask|auto]
   code craft-preview "<task>" [--events-jsonl] [--provider fake|openai-compatible] [--model <id>] [--stream]
   code craft "<task>" [--json|--events-jsonl --approval-channel stdio] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--approval-policy ask|allow|deny] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
-  code sdd <change> <phase> [--json] [--save-artifact] [--provider fake|openai-compatible] [--model <id>] [--stream] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
-  VGXNESS Code inspect and plan are native read-only repository flows. Craft is bounded edit-capable work with approval-gated edits and shell verification; craft JSONL approvals require explicit --approval-channel stdio. SDD mode follows phase-specific artifact boundaries and saves only with --save-artifact.
+  code sdd <change> <phase> [--json] [--save-artifact] [--draft-run] [--provider fake|openai-compatible] [--model <id>] [--stream] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
+  VGXNESS Code inspect and plan are native read-only repository flows. Craft is bounded edit-capable work with approval-gated edits and shell verification; craft JSONL approvals require explicit --approval-channel stdio. SDD mode follows phase-specific artifact boundaries and saves only with --save-artifact. --draft-run lets planning phases use draft prerequisites only; human acceptance is still required and apply-progress remains gated.
 
   orchestrator preview --project <name> --intent <text> [--change <id>] [--db <path>]
   Orchestrator preview classifies natural-language requests only; it never executes providers, edits files, records runs, or writes provider config.
@@ -103,16 +110,20 @@ Areas:
 
   sdd status --project <name> --change <id> [--json]
   sdd next --project <name> --change <id> [--json]
+  sdd continue --project <name> --change <id> [--db <path>] [--json]
   sdd cockpit --project <name> --change <id> [--json]
   sdd ready --project <name> --change <id> --phase <phase>
   sdd save-artifact --project <name> --change <id> --phase <phase> --content <text>
   sdd accept-artifact --project <name> --change <id> --phase <phase> --actor <human-id> [--display-name <name>] [--note <text>] [--accepted-at <iso>] [--json] [--db <path>]
+  sdd reopen-artifact --project <name> --change <id> --phase <phase> --actor <human-id> [--display-name <name>] [--note <text>] [--json] [--db <path>]
   sdd get-artifact --project <name> --change <id> --phase <phase> [--json] [--db <path>]
   sdd list-artifacts --project <name> --change <id> [--json] [--db <path>]
   SDD artifact reads use the selected local SQLite memory store via --db, VGXNESS_DB_PATH, or the global default.
-  SDD status, next, get-artifact, and list-artifacts default to human-readable output; pass --json for existing automation shapes.
+  SDD status, next, continue, get-artifact, and list-artifacts default to human-readable output; pass --json for existing automation shapes.
+  SDD continue is a read-only continuation planner; it never executes providers, mutates artifacts, creates runs, writes provider config, or creates openspec/.
   SDD cockpit defaults to human-readable read-only output; pass --json for metadata-only artifact summaries.
   SDD accept-artifact records explicit human-only acceptance; save-artifact remains draft-only and never implies acceptance. --accepted-at requires a timezone and is normalized to UTC ISO. Human output is default; pass --json for content-free success output.
+  SDD reopen-artifact records explicit human-only reopening of rejected artifacts only, moving them back to draft so they can be edited and accepted again.
   sdd export --project <name> --change <id> [--file <package.json>]
   sdd import --project <name> --change <id> --file <package.json> [--write] [--overwrite]
 

package/dist/cli/commands/index.js

@@ -3,6 +3,7 @@ export { runCodeCliCommand, runDefaultInteractiveEntrypoint } from './interactiv
 export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand, runMcpInstallCommand, runMcpSetupCommand } from './mcp-dispatcher.js';
 export { runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runSddCommand } from './memory-sdd-dispatcher.js';
 export { runApprovalsCommand, runPermissionsCommand, runRunsCommand } from './run-permission-dispatcher.js';
+export { runProductNextCommand, runProductResumeCommand, runProductStatusCommand } from './status-dispatcher.js';
 export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSetupTuiCommand, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';
 export { runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand } from './workflow-dispatcher.js';
 export { runVerificationPlanCommand, runVerificationReportCommand } from './verification-dispatcher.js';

package/dist/cli/commands/interactive-entrypoint-dispatcher.js

@@ -69,6 +69,12 @@ export async function runCodeCliCommand(parsed, environment) {
         return usageFailure('--approval-channel stdio is supported only for code craft --events-jsonl');
     if (eventsJsonl && command !== 'inspect' && command !== 'plan' && command !== 'craft-preview' && approvalChannel.value !== 'stdio')
         return usageFailure('code craft --events-jsonl requires --approval-channel stdio; JSONL without approvals is currently supported only for read-only inspect, plan, and craft-preview');
+    const draftRunFlag = parsed.flags['draft-run'];
+    if (draftRunFlag !== undefined && command !== 'sdd')
+        return usageFailure('--draft-run is supported only for code sdd');
+    if (draftRunFlag !== undefined && draftRunFlag !== true)
+        return usageFailure('--draft-run does not accept a value; use --draft-run for code sdd draft mode');
+    const sddRuntimeMode = draftRunFlag === true ? 'draft-run' : undefined;
     const maxSourceBytes = optionalNumberFlag(parsed.flags, 'max-source-bytes');
     if (!maxSourceBytes.ok)
         return resultFailure(maxSourceBytes);
@@ -109,6 +115,7 @@ export async function runCodeCliCommand(parsed, environment) {
             ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
             ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),
             ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }),
+            ...(sddRuntimeMode === undefined ? {} : { sddRuntimeMode }),
         });
     }
     const selectedDatabasePath = databasePathFor(parsed.flags, environment);
@@ -135,6 +142,7 @@ export async function runCodeCliCommand(parsed, environment) {
             env: environment.env,
             eventsJsonl,
             persistArtifact: parsed.flags['save-artifact'] === true || parsed.flags.persist === true,
+            ...(sddRuntimeMode === undefined ? {} : { sddRuntimeMode }),
             ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}),
             ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
             ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),

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

@@ -6,7 +6,9 @@ import { createMcpClientSetupPreview, isMcpClientSetupProvider } from '../../mcp
 import { createMcpDoctorReport } from '../../mcp/doctor.js';
 import { createOpenCodeMcpVisibilityReport } from '../../mcp/opencode-visibility.js';
 import { resolveClaudeCodeScope } from '../../mcp/claude-code-scope.js';
+import { computeEffectiveManagerInstructions } from '../../agents/manager-profile-overlay-service.js';
 import { RunService } from '../../runs/run-service.js';
+import { isTerminalRunStatus } from '../../runs/schema.js';
 import { databasePathFor, databasePathSelectionFor, opencodeInstallScopeFlag, optionalNumberFlag, optionalStringFlag } from '../cli-flags.js';
 import { usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
@@ -42,6 +44,7 @@ export function runMcpInstallCommand(parsed, environment) {
                 return resultFailure(opened);
             try {
                 const preflight = createClaudeCodeInstallPreflight(parsed, opened.value, environment);
+                const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value);
                 const result = await installClaudeCodeMcpClient({
                     cwd: environment.cwd,
                     databasePath: databasePath.value.path,
@@ -50,6 +53,7 @@ export function runMcpInstallCommand(parsed, environment) {
                     overwriteVgxness,
                     scope: claudeScope.value,
                     preflight,
+                    ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
                 });
                 return result.status === 'installed' ? jsonResult({ ok: true, value: result }) : resultFailure({ ok: false, error: { code: 'validation_failed', message: `${result.reason}: ${result.message}` } });
             }
@@ -107,6 +111,9 @@ function createClaudeCodeInstallPreflight(parsed, database, environment) {
         const details = service.getRun(runId);
         if (!details.ok)
             return details;
+        if (isTerminalRunStatus(details.value.status)) {
+            return validationFailure(`VGXNESS run ${runId} is in terminal state '${details.value.status}'; Claude Code provider config writes require a live run (created/planned/running/needs-human). Start a new run with \`vgxness run start\` and pass its --run-id.`);
+        }
         const phase = optionalStringFlag(parsed.flags, 'phase') ?? details.value.phase;
         const agentId = optionalStringFlag(parsed.flags, 'agent-id') ?? details.value.selectedAgentId;
         const preflight = service.preflightOperation({

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/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({