vgxness 1.9.2 → 1.9.4

package/dist/runs/run-service.js

@@ -1,5 +1,6 @@
 import { evaluatePermission } from '../permissions/policy-evaluator.js';
 import { isRiskyPermissionCategory } from '../permissions/schema.js';
+import { normalizeSddPhaseInput } from '../sdd/schema.js';
 import { planExecutionIsolation } from './execution-planning.js';
 import { evaluateOperationRetry as evaluateOperationRetryPolicy } from './operation-retry.js';
 import { RunRepository, } from './repositories/runs.js';
@@ -28,7 +29,7 @@ export class RunService {
         this.runs = new RunRepository(database);
     }
     createRun(input) {
-        return this.runs.create(input);
+        return this.runs.create({ ...input, phase: canonicalRunPhase(input.workflow, input.phase) ?? input.phase });
     }
     getRun(id) {
         return this.runs.getDetails(id);
@@ -44,6 +45,53 @@ export class RunService {
     listRuns(filters = {}) {
         return this.runs.list(filters);
     }
+    listRecentInterruptedRuns(input) {
+        const runs = this.runs.list({ project: input.project, statuses: ['failed', 'blocked', 'needs-human'], limit: input.limit ?? 5 });
+        if (!runs.ok)
+            return runs;
+        const candidates = [];
+        for (const run of runs.value) {
+            const details = this.runs.getDetails(run.id);
+            if (!details.ok)
+                return details;
+            const latestCheckpoint = details.value.checkpoints.at(-1);
+            const userIntent = details.value.userIntent.trim();
+            candidates.push({
+                runId: details.value.id,
+                status: details.value.status,
+                workflow: details.value.workflow,
+                phase: details.value.phase,
+                ...(userIntent.length === 0 ? {} : { userIntent }),
+                ...(latestCheckpoint === undefined ? {} : { latestCheckpointLabel: latestCheckpoint.label }),
+            });
+        }
+        return { ok: true, value: candidates };
+    }
+    findRelatedInterruptedSddRun(input) {
+        const runs = this.runs.list({ project: input.project, statuses: ['failed', 'blocked', 'needs-human'], limit: input.limit ?? 25 });
+        if (!runs.ok)
+            return runs;
+        for (const run of runs.value) {
+            const details = this.runs.getDetails(run.id);
+            if (!details.ok)
+                return details;
+            const hasMatchingCheckpoint = details.value.checkpoints.some((checkpoint) => checkpointHasChangeId(checkpoint.state, input.change));
+            if (!hasMatchingCheckpoint)
+                continue;
+            const latestCheckpoint = details.value.checkpoints.at(-1);
+            return {
+                ok: true,
+                value: {
+                    runId: details.value.id,
+                    status: details.value.status,
+                    workflow: details.value.workflow,
+                    phase: details.value.phase,
+                    ...(latestCheckpoint === undefined ? {} : { latestCheckpointLabel: latestCheckpoint.label }),
+                },
+            };
+        }
+        return { ok: true, value: undefined };
+    }
     appendEvent(input) {
         return this.runs.appendEvent(input);
     }
@@ -695,10 +743,11 @@ export class RunService {
         const run = this.runs.getById(input.runId);
         if (!run.ok)
             return { ok: false, error: run.error };
-        const phase = input.phase ?? canonicalRunPhase(run.value.phase);
+        const workflow = input.workflow ?? run.value.workflow;
+        const phase = canonicalRunPhase(workflow, input.phase) ?? canonicalRunPhase(run.value.workflow, run.value.phase);
         const merged = {
             ...input,
-            workflow: input.workflow ?? run.value.workflow,
+            workflow,
             ...(phase === undefined ? {} : { phase }),
             agentId: input.agentId ?? input.agent?.id ?? run.value.selectedAgentId,
         };
@@ -799,6 +848,9 @@ export class RunService {
         return { ok: true, value: resolved[0] };
     }
 }
+function checkpointHasChangeId(state, change) {
+    return typeof state === 'object' && state !== null && !Array.isArray(state) && state.changeId === change;
+}
 function preflightOutcome(decision) {
     if (decision.decision === 'allow')
         return 'allowed';
@@ -883,10 +935,15 @@ function resumeGateManualNextCommands(approval, details, operation) {
         commands.push(`Review operation manually: ${operation.category} ${operation.operation}`);
     return commands;
 }
-function canonicalRunPhase(phase) {
+function canonicalRunPhase(workflow, phase) {
     if (phase === undefined || phase.trim().length === 0)
         return undefined;
-    return phase === 'apply' ? 'apply-progress' : phase;
+    if (!isSddWorkflow(workflow))
+        return phase;
+    return normalizeSddPhaseInput(phase) ?? phase;
+}
+function isSddWorkflow(workflow) {
+    return workflow?.trim().toLowerCase() === 'sdd';
 }
 function operationMetadata(input) {
     const metadata = { category: input.category, name: input.operation };

package/dist/sdd/schema.js

@@ -98,6 +98,14 @@ export const sddPrerequisites = {
 export function isSddPhase(value) {
     return sddPhases.includes(value);
 }
+export function normalizeSddPhaseInput(value) {
+    const normalized = value.trim();
+    if (normalized === 'apply')
+        return 'apply-progress';
+    if (isSddPhase(normalized))
+        return normalized;
+    return undefined;
+}
 export function sddTopicKey(change, phase) {
     return `sdd/${change}/${phase}`;
 }

package/dist/sdd/sdd-continuation-plan.js

@@ -0,0 +1,81 @@
+export function sddContinuationPlanFrom(input) {
+    const nextPhase = input.next.nextPhase;
+    const dbFlag = continuationDbFlag(input.explicitDatabasePath);
+    const inspectCommand = `vgxness sdd cockpit --project ${input.project} --change ${input.next.change} --json${dbFlag}`;
+    const suggestedCommand = suggestedContinuationCommand(input.project, input.next, inspectCommand, dbFlag);
+    const blockerGuidance = input.next.blockerGuidance ?? [];
+    const blockerActions = blockerGuidance.map((blocker) => continuationBlockerAction(input.project, input.next.change, input.next.nextPhase, blocker, dbFlag));
+    const hasDraftRunAction = blockerActions.some((action) => action.draftRunCommand !== undefined);
+    const relatedRunContext = relatedRunContextView(input.project, input.relatedRunContext, dbFlag);
+    return {
+        kind: 'sdd-continuation-plan',
+        project: input.project,
+        change: input.next.change,
+        status: input.next.status,
+        ...(nextPhase === undefined ? {} : { nextPhase }),
+        ...(input.cockpit.actionablePhase === undefined ? {} : { actionablePhase: input.cockpit.actionablePhase }),
+        recommendedAction: input.cockpit.recommendedAction,
+        reason: input.next.reason,
+        suggestedCommand,
+        inspectCommand,
+        blockerActions,
+        ...(relatedRunContext === undefined ? {} : { relatedRunContext }),
+        ...(input.explicitDatabasePath === undefined ? {} : { explicitDatabasePath: input.explicitDatabasePath }),
+        safety: [
+            'Read-only planner: this command does not execute providers or mutate SDD artifacts, runs, provider config, or openspec/ files.',
+            'Human acceptance remains explicit; artifact presence is not treated as acceptance.',
+            ...(hasDraftRunAction ? [draftRunWarning()] : []),
+            'No openspec/ files are created or written.',
+        ],
+    };
+}
+function relatedRunContextView(project, relatedRunContext, dbFlag) {
+    if (relatedRunContext === undefined)
+        return undefined;
+    return {
+        ...relatedRunContext,
+        recommendation: 'Related interrupted run found by checkpoint changeId; inspect or resume it before starting duplicate SDD work. Advisory only.',
+        resumeCommand: `vgxness resume --project ${project} --run-id ${relatedRunContext.runId}${dbFlag}`,
+    };
+}
+function suggestedContinuationCommand(project, next, fallbackInspectCommand, dbFlag) {
+    if (next.status === 'runnable' && next.nextPhase !== undefined)
+        return runPhaseCommand(project, next.change, next.nextPhase, dbFlag);
+    return fallbackInspectCommand;
+}
+function continuationBlockerAction(project, change, blockedPhase, blocker, dbFlag) {
+    const draftRunCommand = blocker.reason === 'draft' && isDraftRunPlanningPhase(blockedPhase) ? draftRunPhaseCommand(project, change, blockedPhase, dbFlag) : undefined;
+    return {
+        phase: blocker.phase,
+        topicKey: blocker.topicKey,
+        reason: blocker.reason,
+        action: blocker.action,
+        command: blockerCommand(project, change, blocker, dbFlag),
+        ...(draftRunCommand === undefined ? {} : { draftRunCommand, warning: draftRunWarning() }),
+        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+    };
+}
+function blockerCommand(project, change, blocker, dbFlag) {
+    if (blocker.reason === 'missing')
+        return runPhaseCommand(project, change, blocker.phase, dbFlag);
+    if (blocker.reason === 'draft' || blocker.reason === 'legacy')
+        return `vgxness sdd accept-artifact --project ${project} --change ${change} --phase ${blocker.phase} --actor <human-id>${dbFlag}`;
+    if (blocker.reason === 'rejected')
+        return `vgxness sdd reopen-artifact --project ${project} --change ${change} --phase ${blocker.phase} --actor <human-id>${dbFlag}`;
+    return `vgxness sdd get-artifact --project ${project} --change ${change} --phase ${blocker.phase} --json${dbFlag}`;
+}
+function runPhaseCommand(project, change, phase, dbFlag) {
+    return `vgxness code sdd ${change} ${phase} --project ${project} --save-artifact${dbFlag}`;
+}
+function draftRunPhaseCommand(project, change, phase, dbFlag) {
+    return `vgxness code sdd ${change} ${phase} --project ${project} --draft-run --save-artifact${dbFlag}`;
+}
+function isDraftRunPlanningPhase(phase) {
+    return phase === 'explore' || phase === 'proposal' || phase === 'spec' || phase === 'design' || phase === 'tasks';
+}
+function draftRunWarning() {
+    return 'Draft-run is planning-only; human acceptance is still required; apply-progress remains gated.';
+}
+function continuationDbFlag(explicitDatabasePath) {
+    return explicitDatabasePath === undefined ? '' : ` --db ${explicitDatabasePath}`;
+}

package/dist/sdd/sdd-workflow-service.js

@@ -1,5 +1,5 @@
 import { summarizePayloadContent } from '../payload/payload-summary.js';
-import { isSddPhase, normalizeSddArtifact, sddPhases, sddPrerequisites, sddTopicKey, } from './schema.js';
+import { normalizeSddArtifact, normalizeSddPhaseInput, sddPhases, sddPrerequisites, sddTopicKey, } from './schema.js';
 const defaultContext = { actor: 'sdd-workflow-service' };
 const validChangePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function readAutoAdvanceFromEnv() {
@@ -103,7 +103,7 @@ export class SddWorkflowService {
         const artifacts = cockpitPhases.map((phase) => phase.artifact).filter((artifact) => artifact !== undefined);
         const aggregateBlockers = dedupeCockpitBlockers([
             ...cockpitPhases.flatMap((phase) => phase.blockers),
-            ...next.missingArtifactTopicKeys.map((topicKey) => blockerFromTopicKey(validated.value.change, topicKey)),
+            ...(next.missingPrerequisiteTopicKeys ?? []).map((topicKey) => blockerFromTopicKey(validated.value.change, topicKey)),
             ...(next.blockedPrerequisites ?? []).map((blocker) => ({
                 kind: 'readiness',
                 phase: blocker.phase,
@@ -314,9 +314,10 @@ export class SddWorkflowService {
         const validated = validateProjectAndChange(input.project, input.change);
         if (!validated.ok)
             return validated;
-        if (!isSddPhase(input.phase))
+        const phase = normalizeSddPhaseInput(input.phase);
+        if (phase === undefined)
             return validationFailure(`Unknown SDD phase: ${input.phase}`);
-        return { ok: true, value: { ...validated.value, phase: input.phase } };
+        return { ok: true, value: { ...validated.value, phase } };
     }
     getPhaseStatuses(project, change) {
         const snapshot = this.loadPhaseSnapshot(project, change);
@@ -367,9 +368,11 @@ export function nextDecisionFromStatuses(change, phases, options = {}) {
             status: 'blocked',
             nextPhase: blockedPresentPhase.phase,
             missingArtifactTopicKeys: readiness.missingArtifactTopicKeys,
+            missingPrerequisiteTopicKeys: readiness.missingPrerequisiteTopicKeys ?? [],
             blockedPrerequisites: blockers,
+            blockerGuidance: readiness.blockerGuidance ?? [],
             reason: `${blockedPresentPhase.phase} is blocked by prerequisite artifacts that are not accepted: ${formatBlockers(blockers)}.`,
-            recommendedAction: `Create, restore, or accept ${readiness.missingArtifactTopicKeys.join(', ')} before continuing.`,
+            recommendedAction: blockedRecommendedAction(readiness, 'continuing'),
         };
     }
     const nextMissingPhase = phases.find((status) => !status.present)?.phase;
@@ -381,6 +384,7 @@ export function nextDecisionFromStatuses(change, phases, options = {}) {
                 status: 'blocked',
                 nextPhase: firstUnacceptedPhase.phase,
                 missingArtifactTopicKeys: [firstUnacceptedPhase.topicKey],
+                missingPrerequisiteTopicKeys: [],
                 blockedPrerequisites: [
                     {
                         phase: firstUnacceptedPhase.phase,
@@ -389,8 +393,9 @@ export function nextDecisionFromStatuses(change, phases, options = {}) {
                         ...(firstUnacceptedPhase.artifactId === undefined ? {} : { artifactId: firstUnacceptedPhase.artifactId }),
                     },
                 ],
+                blockerGuidance: [blockerGuidanceForPhaseStatus(firstUnacceptedPhase)],
                 reason: `${firstUnacceptedPhase.phase} is present but ${firstUnacceptedPhase.state ?? 'draft'}; accepted governance status is required before the change is complete.`,
-                recommendedAction: `Accept or replace ${firstUnacceptedPhase.topicKey} before archiving this SDD change.`,
+                recommendedAction: `${blockerActionForStatus(firstUnacceptedPhase)} before archiving this SDD change.`,
             };
         }
         return {
@@ -410,9 +415,11 @@ export function nextDecisionFromStatuses(change, phases, options = {}) {
             status: 'blocked',
             nextPhase: nextMissingPhase,
             missingArtifactTopicKeys: readiness.missingArtifactTopicKeys,
+            missingPrerequisiteTopicKeys: readiness.missingPrerequisiteTopicKeys ?? [],
             blockedPrerequisites: blockers,
+            blockerGuidance: readiness.blockerGuidance ?? [],
             reason: `${nextMissingPhase} is blocked by prerequisite artifacts that are not accepted: ${formatBlockers(blockers)}.`,
-            recommendedAction: `Create, restore, or accept ${readiness.missingArtifactTopicKeys.join(', ')} before running ${nextMissingPhase}.`,
+            recommendedAction: blockedRecommendedAction(readiness, `running ${nextMissingPhase}`),
         };
     }
     return {
@@ -439,7 +446,9 @@ function statusFromPhases(change, phases, options = {}) {
 function getReadinessFromStatuses(change, phase, phases, options = {}) {
     const satisfiedPrerequisites = [];
     const missingArtifactTopicKeys = [];
+    const missingPrerequisiteTopicKeys = [];
     const blockedPrerequisites = [];
+    const blockerGuidance = [];
     const useAutoAdvance = options.autoAdvance === true;
     for (const prerequisite of sddPrerequisites[phase]) {
         const status = phases.find((candidate) => candidate.phase === prerequisite);
@@ -449,19 +458,26 @@ function getReadinessFromStatuses(change, phase, phases, options = {}) {
             continue;
         }
         const topicKey = status?.topicKey ?? sddTopicKey(change, prerequisite);
+        const reason = status === undefined ? 'missing' : blockerReasonForStatus(status);
         missingArtifactTopicKeys.push(topicKey);
-        blockedPrerequisites.push({
+        if (reason === 'missing')
+            missingPrerequisiteTopicKeys.push(topicKey);
+        const blocker = {
             phase: prerequisite,
             topicKey,
-            reason: status === undefined ? 'missing' : blockerReasonForStatus(status),
+            reason,
             ...(status?.artifactId === undefined ? {} : { artifactId: status.artifactId }),
-        });
+        };
+        blockedPrerequisites.push(blocker);
+        blockerGuidance.push(blockerGuidanceForBlocker(blocker, phase));
     }
     return {
         ready: blockedPrerequisites.length === 0,
         satisfiedPrerequisites,
         missingArtifactTopicKeys,
+        missingPrerequisiteTopicKeys,
         blockedPrerequisites,
+        blockerGuidance,
     };
 }
 function compactArtifactProjection(artifact, change, phase, readiness) {
@@ -518,13 +534,20 @@ function compactGovernanceArtifact(artifact) {
 function cockpitBlockersForPhase(status, readiness) {
     const blockers = [];
     if (!status.present)
-        blockers.push({ kind: 'missing-topic-key', phase: status.phase, topicKey: status.topicKey, reason: 'Canonical SDD artifact is missing.' });
+        blockers.push({
+            kind: 'missing-topic-key',
+            phase: status.phase,
+            topicKey: status.topicKey,
+            reason: 'Canonical SDD artifact is missing.',
+            action: blockerActionForBlocker({ phase: status.phase, topicKey: status.topicKey, reason: 'missing' }),
+        });
     if (status.present && status.accepted !== true)
         blockers.push({
             kind: 'unaccepted-phase',
             phase: status.phase,
             topicKey: status.topicKey,
             reason: `${status.phase} is ${status.state ?? 'draft'}; explicit human acceptance is required.`,
+            action: blockerActionForStatus(status),
             ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }),
         });
     if (status.legacy === true)
@@ -533,6 +556,7 @@ function cockpitBlockersForPhase(status, readiness) {
             phase: status.phase,
             topicKey: status.topicKey,
             reason: 'Artifact has legacy or missing governance metadata and is treated as not accepted.',
+            action: blockerActionForStatus(status),
             ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }),
         });
     for (const blocker of readiness.blockedPrerequisites ?? []) {
@@ -541,6 +565,7 @@ function cockpitBlockersForPhase(status, readiness) {
             phase: blocker.phase,
             topicKey: blocker.topicKey,
             reason: blocker.reason,
+            action: blockerActionForBlocker(blocker),
             ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
         });
     }
@@ -548,7 +573,13 @@ function cockpitBlockersForPhase(status, readiness) {
 }
 function blockerFromTopicKey(change, topicKey) {
     const phase = phaseFromTopicKey(change, topicKey);
-    return { kind: 'missing-topic-key', phase, topicKey, reason: 'Required SDD topic key is missing or not accepted.' };
+    return {
+        kind: 'missing-topic-key',
+        phase,
+        topicKey,
+        reason: 'Required SDD topic key is missing or not accepted.',
+        action: blockerActionForBlocker({ phase, topicKey, reason: 'missing' }),
+    };
 }
 function dedupeCockpitBlockers(blockers) {
     const seen = new Set();
@@ -567,16 +598,72 @@ function cockpitRecommendedAction(next, blockers) {
         return next.recommendedAction;
     const legacy = blockers.find((blocker) => blocker.kind === 'legacy-artifact');
     if (legacy !== undefined)
-        return `Review and explicitly accept or replace legacy artifact ${legacy.topicKey}.`;
+        return legacy.action ?? `Inspect and explicitly accept or replace legacy artifact ${legacy.topicKey}.`;
     const unaccepted = blockers.find((blocker) => blocker.kind === 'unaccepted-phase');
     if (unaccepted !== undefined)
-        return `Accept or replace ${unaccepted.topicKey} before continuing.`;
+        return unaccepted.action ?? `Accept or replace ${unaccepted.topicKey} before continuing.`;
     return next.recommendedAction;
 }
+function blockedRecommendedAction(readiness, context) {
+    const firstGuidance = readiness.blockerGuidance?.[0];
+    if (firstGuidance !== undefined)
+        return `${firstGuidance.action} before ${context}.`;
+    const firstBlocker = readiness.blockedPrerequisites?.[0];
+    if (firstBlocker !== undefined)
+        return `${blockerActionForBlocker(firstBlocker)} before ${context}.`;
+    return `Resolve prerequisite blockers before ${context}.`;
+}
+function blockerGuidanceForPhaseStatus(status) {
+    return blockerGuidanceForBlocker({
+        phase: status.phase,
+        topicKey: status.topicKey,
+        reason: blockerReasonForStatus(status),
+        ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }),
+    });
+}
+function blockerGuidanceForBlocker(blocker, blockedPhase) {
+    return {
+        phase: blocker.phase,
+        topicKey: blocker.topicKey,
+        reason: blocker.reason,
+        action: blockerActionForBlocker(blocker, blockedPhase),
+        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+    };
+}
+function blockerActionForStatus(status) {
+    return blockerActionForBlocker({
+        phase: status.phase,
+        topicKey: status.topicKey,
+        reason: blockerReasonForStatus(status),
+        ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }),
+    });
+}
+function blockerActionForBlocker(blocker, blockedPhase) {
+    switch (blocker.reason) {
+        case 'missing':
+            return `Run or create the ${blocker.phase} SDD phase artifact at ${blocker.topicKey}`;
+        case 'draft':
+            if (blockedPhase !== undefined && isDraftRunPlanningPhase(blockedPhase))
+                return `Accept ${blocker.topicKey} if it is ready, or intentionally continue planning ${blockedPhase} with --draft-run; draft-run is planning-only, human acceptance is still required, and apply-progress remains gated`;
+            return `Accept ${blocker.topicKey}, or continue and re-run the ${blocker.phase} phase if the draft is incomplete`;
+        case 'accepted':
+            return `Inspect ${blocker.topicKey}; it is marked accepted but still appears in blocker data`;
+        case 'legacy':
+            return `Inspect ${blocker.topicKey} and explicitly accept or replace the legacy artifact`;
+        case 'rejected':
+            return `Reopen ${blocker.topicKey} for revision, or replace it with a new accepted artifact`;
+        case 'superseded':
+            return `Use the current replacement for ${blocker.topicKey}, or create and accept a new canonical ${blocker.phase} artifact`;
+    }
+}
+function isDraftRunPlanningPhase(phase) {
+    return phase === 'explore' || phase === 'proposal' || phase === 'spec' || phase === 'design' || phase === 'tasks';
+}
 function phaseFromTopicKey(change, topicKey) {
     const suffix = topicKey.slice(`sdd/${change}/`.length);
-    if (isSddPhase(suffix))
-        return suffix;
+    const phase = normalizeSddPhaseInput(suffix);
+    if (phase !== undefined)
+        return phase;
     return 'explore';
 }
 function blockerReasonForStatus(status) {

package/dist/skills/skill-resolver.js

@@ -1,3 +1,4 @@
+import { normalizeSddPhaseInput } from '../sdd/schema.js';
 export class SkillResolver {
     skills;
     agents;
@@ -113,10 +114,13 @@ export class SkillResolver {
             targets.push({ targetType: agent.mode, targetKey: agent.name });
             targets.push({ targetType: agent.mode, targetKey: `${agent.project}/${agent.scope}/${agent.name}` });
         }
-        if (input.workflow !== undefined && input.phase !== undefined)
-            targets.push({ targetType: 'workflow-phase', targetKey: `${input.workflow}:${input.phase}` });
-        if (input.phase !== undefined)
-            targets.push({ targetType: 'workflow-phase', targetKey: input.phase });
+        const phases = phaseTargetKeys(input.workflow, input.phase);
+        if (input.workflow !== undefined) {
+            for (const phase of phases)
+                targets.push({ targetType: 'workflow-phase', targetKey: `${input.workflow}:${phase}` });
+        }
+        for (const phase of phases)
+            targets.push({ targetType: 'workflow-phase', targetKey: phase });
         if (input.providerAdapter !== undefined)
             targets.push({ targetType: 'provider-adapter', targetKey: input.providerAdapter });
         return dedupeTargets(targets);
@@ -212,6 +216,19 @@ function dedupeTargets(targets) {
         return true;
     });
 }
+function phaseTargetKeys(workflow, phase) {
+    if (phase === undefined)
+        return [];
+    if (!isSddWorkflow(workflow))
+        return [phase];
+    const normalized = normalizeSddPhaseInput(phase);
+    if (normalized === 'apply-progress')
+        return ['apply-progress', 'apply'];
+    return normalized === undefined || normalized === phase ? [phase] : [normalized, phase];
+}
+function isSddWorkflow(workflow) {
+    return workflow?.trim().toLowerCase() === 'sdd';
+}
 function stringMetadata(value) {
     return typeof value === 'string' && value.trim() ? value : undefined;
 }

package/dist/status/product-status.js

@@ -0,0 +1,121 @@
+import { basename, resolve } from 'node:path';
+export function buildProductStatus(input) {
+    const project = resolveProject(input);
+    const baseSafety = [
+        'Read-only cockpit: does not execute providers, edit files, write provider config, or mutate SDD artifacts.',
+        'Human acceptance remains explicit; saved artifacts do not imply acceptance.',
+    ];
+    if (input.change === undefined) {
+        return {
+            version: 1,
+            kind: 'product-status',
+            project,
+            status: [`Project: ${project.value} (${project.source === 'flag' ? 'from --project' : 'inferred from cwd'})`, 'Change: not selected'],
+            blockers: ['No --change was provided, so VGXNESS cannot inspect SDD phase state yet.'],
+            next: ['Choose the active change id, then re-run status for the SDD cockpit view.'],
+            command: `vgxness status --project ${project.value} --change <change>`,
+            safety: ['Did not open the local memory store because no change was selected.', ...baseSafety],
+        };
+    }
+    if (input.databaseError !== undefined) {
+        return blockedStatus({
+            project,
+            change: input.change,
+            blocker: `Unable to read local memory store${input.databasePath === undefined ? '' : ` at ${input.databasePath}`}: ${input.databaseError}`,
+            next: 'Check --db, VGXNESS_DB_PATH, or run setup/status commands with the installed Bun runtime.',
+            command: `vgxness status --project ${project.value} --change ${input.change} --db <path>`,
+            safety: baseSafety,
+        });
+    }
+    if (input.sdd === undefined) {
+        return blockedStatus({
+            project,
+            change: input.change,
+            blocker: 'SDD cockpit service is not available for this status request.',
+            next: 'Use the installed CLI or provide a readable local memory store.',
+            command: `vgxness sdd cockpit --project ${project.value} --change ${input.change}`,
+            safety: baseSafety,
+        });
+    }
+    const cockpit = input.sdd.getCockpit({ project: project.value, change: input.change });
+    if (!cockpit.ok) {
+        return blockedStatus({
+            project,
+            change: input.change,
+            blocker: cockpit.error.message,
+            next: 'Review the project/change flags and local memory store, then re-run status.',
+            command: `vgxness sdd cockpit --project ${project.value} --change ${input.change}`,
+            safety: baseSafety,
+        });
+    }
+    const relatedRunContext = findRelatedRunContext({
+        project: project.value,
+        change: input.change,
+        ...(input.runs === undefined ? {} : { runs: input.runs }),
+        ...(input.explicitDatabasePath === undefined ? {} : { explicitDatabasePath: input.explicitDatabasePath }),
+    });
+    return fromSddCockpit(cockpit.value, project, baseSafety, relatedRunContext);
+}
+function resolveProject(input) {
+    if (input.project !== undefined && input.project.trim().length > 0)
+        return { value: input.project.trim(), source: 'flag' };
+    const directoryName = basename(resolve(input.cwd));
+    return { value: directoryName.length > 0 ? directoryName : 'unknown-project', source: 'cwd' };
+}
+function fromSddCockpit(cockpit, project, baseSafety, relatedRunContext) {
+    const nextLabel = cockpit.next.nextPhase === undefined ? cockpit.next.status : `${cockpit.next.status} / ${cockpit.next.nextPhase}`;
+    const command = cockpit.next.status === 'runnable' && cockpit.next.nextPhase !== undefined
+        ? `vgxness code sdd ${cockpit.change} ${cockpit.next.nextPhase} --project ${cockpit.project} --save-artifact`
+        : `vgxness sdd cockpit --project ${cockpit.project} --change ${cockpit.change} --json`;
+    return {
+        version: 1,
+        kind: 'product-status',
+        project,
+        change: cockpit.change,
+        status: [
+            `Project: ${cockpit.project}`,
+            `Change: ${cockpit.change}`,
+            `Next: ${nextLabel}`,
+            `Accepted: ${cockpit.acceptedCount}/${cockpit.phases.length}`,
+            `Legacy artifacts: ${cockpit.legacyCount}`,
+        ],
+        blockers: cockpit.aggregateBlockers.length === 0
+            ? ['none']
+            : cockpit.aggregateBlockers.map((blocker) => `${blocker.phase}: ${blocker.reason} at ${blocker.topicKey}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`),
+        next: [
+            cockpit.next.status === 'runnable' && cockpit.next.nextPhase !== undefined
+                ? `Continue the ${cockpit.next.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`
+                : cockpit.recommendedAction,
+        ],
+        command,
+        sddNextStatus: cockpit.next.status,
+        ...(relatedRunContext === undefined ? {} : { relatedRunContext }),
+        safety: baseSafety,
+    };
+}
+function findRelatedRunContext(input) {
+    if (input.runs === undefined)
+        return undefined;
+    const relatedRun = input.runs.findRelatedInterruptedSddRun({ project: input.project, change: input.change });
+    if (!relatedRun.ok || relatedRun.value === undefined)
+        return undefined;
+    const dbFlag = input.explicitDatabasePath === undefined ? '' : ` --db ${input.explicitDatabasePath}`;
+    return {
+        ...relatedRun.value,
+        recommendation: 'Related interrupted run found by checkpoint changeId; inspect or resume it before starting duplicate SDD work. Advisory only.',
+        resumeCommand: `vgxness resume --project ${input.project} --run-id ${relatedRun.value.runId}${dbFlag}`,
+    };
+}
+function blockedStatus(input) {
+    return {
+        version: 1,
+        kind: 'product-status',
+        project: input.project,
+        change: input.change,
+        status: [`Project: ${input.project.value}`, `Change: ${input.change}`, 'Status: blocked'],
+        blockers: [input.blocker],
+        next: [input.next],
+        command: input.command,
+        safety: input.safety,
+    };
+}

package/docs/architecture.md

@@ -625,7 +625,7 @@ The code runtime layers a second, finer-grained decision on top of the policy ev
 
 CLI surface groups are documented in [CLI reference](./cli.md). The plural form is canonical — singular shortcuts are not added.
 
-MCP tools mirror the same core services for agent use. The full, current list of 38 tools is in [MCP tools](./mcp.md) and `SUPPORTED_VGX_MCP_TOOL_NAMES` (`src/mcp/schema.ts`); treat that array as the source of truth. The CLI and TUI are human/operator control surfaces. MCP is the agent-facing control surface. Provider integrations and the code runtime sit on the execution plane.
+MCP tools mirror the same core services for agent use. The full, current list of 41 tools is in [MCP tools](./mcp.md) and `SUPPORTED_VGX_MCP_TOOL_NAMES` (`src/mcp/schema.ts`); treat that array as the source of truth. The CLI and TUI are human/operator control surfaces. MCP is the agent-facing control surface. Provider integrations and the code runtime sit on the execution plane.
 
 ## Evaluation strategy