vgxness 1.20.0 → 1.20.1

package/dist/mcp/control-plane.js

@@ -308,19 +308,16 @@ function governanceSddServices(services) {
     };
 }
 function sddContinueEnvelope(input, services) {
-    const next = services.sdd.getNext({ project: input.project, change: input.change });
-    if (!next.ok)
-        return errorEnvelope(next.error.code, next.error.message, 'vgxness_sdd_continue');
-    const cockpit = services.sdd.getCockpit({ project: input.project, change: input.change });
-    if (!cockpit.ok)
-        return errorEnvelope(cockpit.error.code, cockpit.error.message, 'vgxness_sdd_continue');
+    const context = services.sdd.getContinuationContext({ project: input.project, change: input.change });
+    if (!context.ok)
+        return errorEnvelope(context.error.code, context.error.message, 'vgxness_sdd_continue');
     const relatedRun = services.runs.findRelatedInterruptedSddRun({ project: input.project, change: input.change });
     if (!relatedRun.ok)
         return errorEnvelope(relatedRun.error.code, relatedRun.error.message, 'vgxness_sdd_continue');
     return successEnvelope('vgxness_sdd_continue', sddContinuationPlanFrom({
         project: input.project,
-        next: next.value,
-        cockpit: cockpit.value,
+        next: context.value.next,
+        cockpit: context.value.cockpit,
         ...(relatedRun.value === undefined ? {} : { relatedRunContext: relatedRun.value }),
     }));
 }

package/dist/mcp/opencode-handoff-preview.js

@@ -70,23 +70,42 @@ export class OpenCodeHandoffPreviewService {
             return { summary: { ...summary, unavailableReason: reason }, inspection: notInspectedSdd(reason) };
         }
         const status = this.deps.sdd.getStatus({ project: input.project, change: input.change });
-        const next = this.deps.sdd.getNext({ project: input.project, change: input.change });
-        const inspection = { inspected: true, statusQueried: true, nextQueried: true, readinessQueried: false };
+        const inspection = { inspected: true, statusQueried: true, nextQueried: true, readinessQueried: input.phase !== undefined };
         if (status.ok)
             summary.status = status.value;
         else
             warnings.push(`SDD status unavailable: ${status.error.message}`);
-        if (next.ok)
-            summary.next = next.value;
-        else
-            warnings.push(`SDD next phase unavailable: ${next.error.message}`);
-        if (input.phase !== undefined) {
-            const ready = this.deps.sdd.getReady({ project: input.project, change: input.change, phase: input.phase });
-            inspection.readinessQueried = true;
-            if (ready.ok)
-                summary.readiness = ready.value;
+        const continuation = this.deps.sdd.getContinuationContext?.({ project: input.project, change: input.change });
+        if (continuation !== undefined) {
+            if (continuation.ok) {
+                const continuationNext = continuationNextValue(continuation.value);
+                if (continuationNext !== undefined)
+                    summary.next = continuationNext;
+                if (input.phase !== undefined) {
+                    const continuationReadiness = continuationReadinessValue(continuation.value, input.phase);
+                    if (continuationReadiness !== undefined)
+                        summary.readiness = continuationReadiness;
+                }
+            }
+            else {
+                warnings.push(`SDD continuation context unavailable: ${continuation.error.message}`);
+            }
+        }
+        if (summary.next === undefined) {
+            const next = this.deps.sdd.getNext({ project: input.project, change: input.change });
+            if (next.ok)
+                summary.next = next.value;
             else
-                warnings.push(`SDD readiness unavailable: ${ready.error.message}`);
+                warnings.push(`SDD next phase unavailable: ${next.error.message}`);
+        }
+        if (input.phase !== undefined) {
+            if (summary.readiness === undefined) {
+                const ready = this.deps.sdd.getReady({ project: input.project, change: input.change, phase: input.phase });
+                if (ready.ok)
+                    summary.readiness = ready.value;
+                else
+                    warnings.push(`SDD readiness unavailable: ${ready.error.message}`);
+            }
         }
         return { summary, inspection };
     }
@@ -108,6 +127,47 @@ export class OpenCodeHandoffPreviewService {
 function notInspectedSdd(reason) {
     return { inspected: false, statusQueried: false, nextQueried: false, readinessQueried: false, notInspectedReason: reason };
 }
+function continuationNextValue(value) {
+    const record = asRecord(value);
+    if (record === undefined)
+        return undefined;
+    const next = record.next;
+    return next === null ? undefined : next;
+}
+function continuationReadinessValue(value, phase) {
+    const record = asRecord(value);
+    if (record === undefined)
+        return undefined;
+    return readinessFromPhaseEntries(asRecord(record.cockpit)?.phases, phase) ?? readinessFromPhaseEntries(record.phases, phase) ?? readinessFromPhaseEntries(asRecord(record.readModel)?.phases, phase) ?? readinessFromReadinessMap(record.readinessByPhase, phase) ?? readinessFromReadinessMap(record.phaseReadiness, phase) ?? matchingReadiness(record.readiness, phase);
+}
+function readinessFromPhaseEntries(value, phase) {
+    if (!Array.isArray(value))
+        return undefined;
+    for (const entry of value) {
+        const record = asRecord(entry);
+        if (record?.phase === phase)
+            return record.readiness === null ? undefined : record.readiness;
+    }
+    return undefined;
+}
+function readinessFromReadinessMap(value, phase) {
+    const record = asRecord(value);
+    if (record === undefined)
+        return undefined;
+    const readiness = record[phase];
+    return readiness === null ? undefined : readiness;
+}
+function matchingReadiness(value, phase) {
+    const record = asRecord(value);
+    if (record === undefined)
+        return undefined;
+    if (record.phase !== undefined && record.phase !== phase)
+        return undefined;
+    return value;
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
 function managerInput(input, scope) {
     return { project: input.project, scope, agentName: input.agentName ?? 'vgxness-manager', ...(input.agentId === undefined ? {} : { agentId: input.agentId }), ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }), ...(input.maxSourceBytes === undefined ? {} : { maxSourceBytes: input.maxSourceBytes }), payloadMode: 'compact' };
 }

package/dist/mcp/provider-status.js

@@ -93,6 +93,25 @@ export class ProviderStatusService {
     readSdd(project, change) {
         if (this.deps.sdd === undefined)
             return { change };
+        const continuation = this.deps.sdd.getContinuationContext?.({ project, change });
+        if (continuation?.ok === true && isRecord(continuation.value)) {
+            const continuationNext = isRecord(continuation.value.next) ? continuation.value.next : undefined;
+            const continuationStatus = projectSddCockpitStatus(continuation.value.cockpit, change, continuationNext);
+            if (continuationNext !== undefined) {
+                if (continuationStatus !== undefined)
+                    return { change, status: continuationStatus, next: continuationNext };
+                const status = this.deps.sdd.getStatus({ project, change });
+                return { change, ...(status.ok ? { status: status.value } : {}), next: continuationNext };
+            }
+            if (continuationStatus !== undefined) {
+                const next = this.deps.sdd.getNext({ project, change });
+                return {
+                    change,
+                    status: projectSddCockpitStatus(continuation.value.cockpit, change, next.ok && isRecord(next.value) ? next.value : undefined),
+                    ...(next.ok && isRecord(next.value) ? { next: next.value } : {}),
+                };
+            }
+        }
         const status = this.deps.sdd.getStatus({ project, change });
         const next = this.deps.sdd.getNext({ project, change });
         return { change, ...(status.ok ? { status: status.value } : {}), ...(next.ok ? { next: next.value } : {}) };
@@ -257,6 +276,31 @@ function compactSdd(sdd, mode) {
         ...(sdd.next === undefined ? {} : { next: compactUnknown(sdd.next) }),
     };
 }
+function projectSddCockpitStatus(cockpit, change, next) {
+    if (!isRecord(cockpit) || !Array.isArray(cockpit.phases))
+        return undefined;
+    const phases = cockpit.phases.map((phase) => projectSddPhaseStatus(phase));
+    if (phases.some((phase) => phase === undefined))
+        return undefined;
+    return {
+        change,
+        phases,
+        ...(next?.status === 'runnable' && typeof next.nextPhase === 'string' ? { nextReadyPhase: next.nextPhase } : {}),
+    };
+}
+function projectSddPhaseStatus(phase) {
+    if (!isRecord(phase) || typeof phase.phase !== 'string' || typeof phase.topicKey !== 'string' || typeof phase.present !== 'boolean')
+        return undefined;
+    return {
+        phase: phase.phase,
+        topicKey: phase.topicKey,
+        present: phase.present,
+        ...(typeof phase.state === 'string' ? { state: phase.state } : {}),
+        ...(typeof phase.accepted === 'boolean' ? { accepted: phase.accepted } : {}),
+        ...(typeof phase.legacy === 'boolean' ? { legacy: phase.legacy } : {}),
+        ...(typeof phase.artifactId === 'string' ? { artifactId: phase.artifactId } : {}),
+    };
+}
 function compactUnknown(value) {
     if (!isRecord(value))
         return value;

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

@@ -80,57 +80,17 @@ export class SddWorkflowService {
         const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
         if (!snapshot.ok)
             return snapshot;
-        const phases = snapshot.value.phases;
-        const next = nextDecisionFromStatuses(validated.value.change, phases, this.options);
-        const cockpitPhases = phases.map((phaseStatus) => {
-            const readiness = {
-                change: validated.value.change,
-                phase: phaseStatus.phase,
-                ...getReadinessFromStatuses(validated.value.change, phaseStatus.phase, phases, this.options),
-            };
-            const artifact = phaseStatus.present ? cockpitArtifactSummaryFromSnapshotItem(phaseStatus) : undefined;
-            const blockers = cockpitBlockersForPhase(phaseStatus, readiness);
-            const gates = phaseGateFromStatus(phaseStatus, readiness);
-            return {
-                phase: phaseStatus.phase,
-                topicKey: phaseStatus.topicKey,
-                present: phaseStatus.present,
-                accepted: phaseStatus.accepted === true,
-                legacy: phaseStatus.legacy === true,
-                state: phaseStatus.state ?? 'missing',
-                readiness,
-                ...(artifact === undefined ? {} : { artifact }),
-                blockers,
-                gates,
-            };
-        });
-        const artifacts = cockpitPhases.map((phase) => phase.artifact).filter((artifact) => artifact !== undefined);
-        const aggregateBlockers = dedupeCockpitBlockers([
-            ...cockpitPhases.flatMap((phase) => phase.blockers),
-            ...(next.missingPrerequisiteTopicKeys ?? []).map((topicKey) => blockerFromTopicKey(validated.value.change, topicKey)),
-            ...(next.blockedPrerequisites ?? []).map((blocker) => ({
-                kind: 'readiness',
-                phase: blocker.phase,
-                topicKey: blocker.topicKey,
-                reason: blocker.reason,
-                ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
-            })),
-        ]);
-        const cockpit = {
-            project: validated.value.project,
-            change: validated.value.change,
-            ...(next.nextPhase === undefined ? {} : { actionablePhase: next.nextPhase }),
-            next,
-            recommendedAction: cockpitRecommendedAction(next, aggregateBlockers),
-            phases: cockpitPhases,
-            artifacts,
-            acceptedCount: cockpitPhases.filter((phase) => phase.accepted).length,
-            legacyCount: cockpitPhases.filter((phase) => phase.legacy).length,
-            aggregateBlockers,
-            gates: cockpitGatesFromPhases(cockpitPhases, next),
-            inspectCommand: `vgxness sdd cockpit --project ${validated.value.project} --change ${validated.value.change} --json`,
-        };
-        return ok(cockpit);
+        return ok(this.cockpitFromSnapshot(snapshot.value));
+    }
+    getContinuationContext(input) {
+        const validated = validateProjectAndChange(input.project, input.change);
+        if (!validated.ok)
+            return validated;
+        const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
+        if (!snapshot.ok)
+            return snapshot;
+        const cockpit = this.cockpitFromSnapshot(snapshot.value);
+        return ok({ next: cockpit.next, cockpit });
     }
     getGovernanceSnapshot(input) {
         const validated = validateProjectAndChange(input.project, input.change);
@@ -306,13 +266,10 @@ export class SddWorkflowService {
                 },
             });
         }
-        const listed = this.memory.listArtifactsByTopicPrefix(validated.value.project, `sdd/${validated.value.change}/`, this.context);
-        if (!listed.ok)
-            return listed;
-        const artifactsByTopicKey = new Map(listed.value.map((artifact) => [artifact.topicKey, artifact]));
-        const artifacts = sddPhases
-            .map((phase) => artifactsByTopicKey.get(sddTopicKey(validated.value.change, phase)))
-            .filter((artifact) => artifact !== undefined);
+        const snapshot = this.loadPhaseSnapshot(validated.value.project, validated.value.change);
+        if (!snapshot.ok)
+            return snapshot;
+        const artifacts = snapshot.value.phases.flatMap((phase) => (phase.artifact === undefined ? [] : [phase.artifact]));
         return ok({ project: validated.value.project, change: validated.value.change, artifacts });
     }
     validatePhaseInput(input) {
@@ -358,6 +315,58 @@ export class SddWorkflowService {
         });
         return ok({ project, change, phases });
     }
+    cockpitFromSnapshot(snapshot) {
+        const phases = snapshot.phases;
+        const next = nextDecisionFromStatuses(snapshot.change, phases, this.options);
+        const cockpitPhases = phases.map((phaseStatus) => {
+            const readiness = {
+                change: snapshot.change,
+                phase: phaseStatus.phase,
+                ...getReadinessFromStatuses(snapshot.change, phaseStatus.phase, phases, this.options),
+            };
+            const artifact = phaseStatus.present ? cockpitArtifactSummaryFromSnapshotItem(phaseStatus) : undefined;
+            const blockers = cockpitBlockersForPhase(phaseStatus, readiness);
+            const gates = phaseGateFromStatus(phaseStatus, readiness);
+            return {
+                phase: phaseStatus.phase,
+                topicKey: phaseStatus.topicKey,
+                present: phaseStatus.present,
+                accepted: phaseStatus.accepted === true,
+                legacy: phaseStatus.legacy === true,
+                state: phaseStatus.state ?? 'missing',
+                readiness,
+                ...(artifact === undefined ? {} : { artifact }),
+                blockers,
+                gates,
+            };
+        });
+        const artifacts = cockpitPhases.map((phase) => phase.artifact).filter((artifact) => artifact !== undefined);
+        const aggregateBlockers = dedupeCockpitBlockers([
+            ...cockpitPhases.flatMap((phase) => phase.blockers),
+            ...(next.missingPrerequisiteTopicKeys ?? []).map((topicKey) => blockerFromTopicKey(snapshot.change, topicKey)),
+            ...(next.blockedPrerequisites ?? []).map((blocker) => ({
+                kind: 'readiness',
+                phase: blocker.phase,
+                topicKey: blocker.topicKey,
+                reason: blocker.reason,
+                ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+            })),
+        ]);
+        return {
+            project: snapshot.project,
+            change: snapshot.change,
+            ...(next.nextPhase === undefined ? {} : { actionablePhase: next.nextPhase }),
+            next,
+            recommendedAction: cockpitRecommendedAction(next, aggregateBlockers),
+            phases: cockpitPhases,
+            artifacts,
+            acceptedCount: cockpitPhases.filter((phase) => phase.accepted).length,
+            legacyCount: cockpitPhases.filter((phase) => phase.legacy).length,
+            aggregateBlockers,
+            gates: cockpitGatesFromPhases(cockpitPhases, next),
+            inspectCommand: `vgxness sdd cockpit --project ${snapshot.project} --change ${snapshot.change} --json`,
+        };
+    }
 }
 export function nextDecisionFromStatuses(change, phases, options = {}) {
     const blockedPresentPhase = phases.find((status) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.20.0",
+  "version": "1.20.1",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {