vgxness 1.20.0 → 1.20.2

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

@@ -168,7 +168,7 @@ Coordinate SDD; keep chat thin, use VGXNESS MCP state, delegate to exact SDD sub
 - Before phase advancement, call \`vgxness_sdd_status\`/\`vgxness_sdd_next\` plus \`vgxness_sdd_ready\` or \`vgxness_sdd_get_readiness\`.
 - Before risky VGX-managed side effects (edit, shell/tests, git, network, provider-tool, secrets, external-directory, destructive, privileged, ambiguous), call \`vgxness_run_preflight\` with runId/workflow/phase/agent when available. Stop on approval/block; never invent approval.
 - Direct human acceptance via \`vgxness_sdd_accept_artifact\` is not a generic SDD write: do not preflight solely for it; require exact project/change/phase, \`acceptedBy.type\` \`"human"\`, non-empty \`acceptedBy.id\`, and eligible status/readiness. Shortcut only for acceptance/trusted draft autorun; excludes edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
-- manager native repo tools are disabled in config (read/glob/edit/write/bash); report config-level enforcement, not proof of host runtime behavior. Subagents keep phase tools.
+- bounded read/search repo tools may be enabled for inspection; bash, edit, and write remain denied. Diagnostics are config-level evidence, not host runtime proof.
 - Do not mutate provider/global OpenCode config. Do not publish packages unless explicitly requested. Never revert/overwrite unrelated user work. Preserve \`permission.task\` deny-by-default with only exact known SDD subagents.
 - Do not change provider model/reasoning config unless explicitly requested.
 

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

@@ -137,7 +137,7 @@ function openCodeManagerPermissionsFor(agent) {
         ...openCodePermissionsFor(agent, { task: createCanonicalOpenCodeSddTaskPermissions() }),
         bash: 'deny',
         edit: 'deny',
-        read: 'deny',
+        read: 'allow',
         write: 'deny',
     };
 }
@@ -148,9 +148,9 @@ function openCodeManagerTools() {
         delegation_list: true,
         delegation_read: true,
         edit: false,
-        glob: false,
-        grep: false,
-        read: false,
+        glob: true,
+        grep: true,
+        read: true,
         write: false,
     };
 }

package/dist/agents/renderers/opencode-renderer.js

@@ -15,7 +15,7 @@ const openCodeCapabilities = {
         'instructions',
         'mode',
         'adapter model',
-        'adapter config keys: variant, temperature, top_p, hidden, options, color, steps, permission',
+        'adapter config keys: variant, temperature, top_p, hidden, options, color, steps, permission, tools',
     ],
     skillInjectionModes: ['external preview services may inject skill payloads before rendering; renderer does not resolve skills'],
     permissionCategories: ['registry permission metadata mapped from adapter permission config'],
@@ -78,6 +78,7 @@ function openCodeAgentConfig(agent) {
     copyString(config, rendered, 'color');
     copyNumber(config, rendered, 'steps');
     copyJson(config, rendered, 'permission');
+    copyJson(config, rendered, 'tools');
     return rendered;
 }
 function copyString(source, target, key) {

package/dist/mcp/client-install-opencode-contract.js

@@ -197,7 +197,11 @@ function warningsForScope(scope, overwriteVgxness, agentPlan, bashPermissionPoli
             `Reinstall/overwrite is enabled: existing VGXNESS-managed OpenCode entries will be replaced (${agentPlan.installsAgents ? 'mcp.vgxness, default_agent, instructions AGENTS.md, and known VGXNESS agents' : 'mcp.vgxness only'}); unrelated OpenCode config is preserved.`,
         ]
         : [];
-    const bashWarnings = bashPermissionPolicy.manager === 'deny' ? ['OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent denies bash while SDD subagents keep explicit phase permissions.'] : ['OpenCode top-level permission.bash is set to ask.'];
+    const bashWarnings = bashPermissionPolicy.manager === 'deny'
+        ? [
+            'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; SDD subagents keep explicit phase permissions. This is config-level evidence only and does not verify provider runtime enforcement.',
+        ]
+        : ['OpenCode top-level permission.bash is set to ask.'];
     return [
         'Restart OpenCode after installation so it reloads the user MCP config.',
         'OpenCode project config may override user config for a workspace; check project-level config if vgxness is not visible.',

package/dist/mcp/client-install-opencode.js

@@ -214,7 +214,10 @@ function confirmationRequiredMessage(scope) {
     return `\`mcp install opencode\` requires explicit --yes before any ${scope} config write.`;
 }
 function warnings() {
-    return ['Restart OpenCode after installation so it reloads the project MCP config.', 'OpenCode top-level permission.bash is set to ask; the VGXNESS manager agent denies bash while SDD subagents keep explicit phase permissions.'];
+    return [
+        'Restart OpenCode after installation so it reloads the project MCP config.',
+        'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; SDD subagents keep explicit phase permissions. This is config-level evidence only and does not verify provider runtime enforcement.',
+    ];
 }
 function manualTest(databasePath, source) {
     return {

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-doctor.js

@@ -40,6 +40,7 @@ export class ProviderDoctorService {
             configReadableCheck(readableJson.length, paths.filter((path) => path.exists).length),
             mcpEntryCheck(config),
             defaultAgentCheck(config),
+            managerNativeCapabilityCheck(config),
             subagentsCheck(config),
             delegationCheck(config),
             { id: 'mcp-current-call', status: 'pass', detail: 'Current MCP call reached the VGXNESS control-plane.' },
@@ -255,6 +256,35 @@ function defaultAgentCheck(config) {
         return { id: 'opencode-default-agent', status: 'fail', detail: 'OpenCode default_agent is not vgxness-manager or the manager config is missing.' };
     return { id: 'opencode-default-agent', status: 'pass', detail: 'OpenCode default agent points to vgxness-manager.' };
 }
+function managerNativeCapabilityCheck(config) {
+    const manager = isRecord(config?.agent) && isRecord(config.agent[vgxnessOpenCodeDefaultAgent]) ? config.agent[vgxnessOpenCodeDefaultAgent] : undefined;
+    const permission = isRecord(manager?.permission) ? manager.permission : undefined;
+    const tools = isRecord(manager?.tools) ? manager.tools : undefined;
+    const problems = [];
+    if (permission?.read !== 'allow')
+        problems.push('permission.read is not allow');
+    for (const tool of ['read', 'glob', 'grep']) {
+        if (tools?.[tool] !== true)
+            problems.push(`tools.${tool} is not enabled`);
+    }
+    for (const tool of ['bash', 'edit', 'write']) {
+        if (tools?.[tool] !== false)
+            problems.push(`tools.${tool} is not disabled`);
+    }
+    const evidenceSuffix = 'This is config-level evidence only; host runtime/tool presence is not verified.';
+    if (problems.length > 0)
+        return {
+            id: 'opencode-manager-native-capability',
+            status: 'fail',
+            detail: `Manager native capability drift detected: ${problems.join('; ')}. ${evidenceSuffix}`,
+            remediation: 'Re-run explicit OpenCode setup/install only after reviewing provider config drift; doctor does not auto-repair or write config.',
+        };
+    return {
+        id: 'opencode-manager-native-capability',
+        status: 'pass',
+        detail: `Manager config allows read/glob/grep inspection and denies bash/edit/write native tools. ${evidenceSuffix}`,
+    };
+}
 function subagentsCheck(config) {
     const agents = isRecord(config?.agent) ? config.agent : undefined;
     const missing = vgxnessOpenCodeSddSubagents.filter((name) => !isRecord(agents?.[name]) || agents[name]?.hidden !== true);

package/dist/mcp/provider-status.js

@@ -27,10 +27,11 @@ export class ProviderStatusService {
         const mcpEntry = inspectOpenCodeMcpEntry(paths);
         const providerConfig = readFirstParsedConfig(paths);
         const managerConfigured = hasConfiguredManager(providerConfig);
+        const managerNativeCapabilityStatus = inspectManagerNativeCapability(providerConfig);
         const subagentsConfigured = hasConfiguredSubagents(providerConfig);
         const tools = requiredToolPresence();
         const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: paths.length > 0 });
-        const configStatus = resolveConfigStatus(paths, mcpEntry, managerConfigured, subagentsConfigured);
+        const configStatus = resolveConfigStatus(paths, mcpEntry, managerConfigured, managerNativeCapabilityStatus, subagentsConfigured);
         const status = rollupProviderHealth([canonicalAgentManifest.status, configStatus, ...tools.map((tool) => (tool.present ? 'pass' : 'fail'))]);
         const sdd = normalized.change.length > 0 ? this.readSdd(normalized.project, normalized.change) : undefined;
         const generatedAt = 'read-only-snapshot';
@@ -38,14 +39,14 @@ export class ProviderStatusService {
             ? paths.map((path) => path.path)
             : paths.filter((path) => path.exists || path.status !== 'not-configured').map((path) => path.path);
         const verboseShape = {
-            config: { status: configStatus, paths, mcpEntry },
+            config: { status: configStatus, paths, mcpEntry, managerNativeCapability: managerNativeCapabilityStatus },
             canonicalAgentManifest,
             providerEvidence: evidence,
             sdd,
             mcpRequiredTools: tools,
         };
         const compactShape = {
-            config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') },
+            config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact'), managerNativeCapability: managerNativeCapabilityStatus },
             canonicalAgentManifest,
             providerEvidence: evidence,
             sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'),
@@ -86,13 +87,32 @@ export class ProviderStatusService {
         return {
             ok: true,
             value: normalized.payloadMode === 'verbose'
-                ? { ...reportBase, payloadMode: 'verbose', config: { status: configStatus, paths: compactPaths(paths, 'verbose'), mcpEntry: compactMcpEntry(mcpEntry, 'verbose') } }
-                : { ...reportBase, payloadMode: 'compact', config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') } },
+                ? { ...reportBase, payloadMode: 'verbose', config: { status: configStatus, paths: compactPaths(paths, 'verbose'), mcpEntry: compactMcpEntry(mcpEntry, 'verbose'), managerNativeCapability: managerNativeCapabilityStatus } }
+                : { ...reportBase, payloadMode: 'compact', config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact'), managerNativeCapability: managerNativeCapabilityStatus } },
         };
     }
     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 +277,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;
@@ -349,12 +394,12 @@ function requiredToolPresence() {
         diagnostic: 'Static VGXNESS manifest expects this MCP tool; provider host tool presence was not verified.',
     }));
 }
-function resolveConfigStatus(paths, mcpEntry, managerConfigured, subagentsConfigured) {
+function resolveConfigStatus(paths, mcpEntry, managerConfigured, managerNativeCapabilityStatus, subagentsConfigured) {
     if (paths.some((path) => path.status === 'fail') || mcpEntry.status === 'fail')
         return 'fail';
     if (mcpEntry.status === 'not-configured')
         return 'not-configured';
-    if (!managerConfigured || !subagentsConfigured)
+    if (!managerConfigured || managerNativeCapabilityStatus === 'warn' || !subagentsConfigured)
         return 'warn';
     if (hasProjectConfigAlongsideUser(paths))
         return 'warn';
@@ -405,6 +450,17 @@ function hasConfiguredManager(config) {
         isRecord(agent?.[vgxnessOpenCodeDefaultAgent]) &&
         promptContractVersion(agent[vgxnessOpenCodeDefaultAgent]) === vgxnessOpenCodePromptContractVersion);
 }
+function inspectManagerNativeCapability(config) {
+    if (config === undefined)
+        return 'not-configured';
+    const agent = isRecord(config.agent) ? config.agent : undefined;
+    const manager = isRecord(agent?.[vgxnessOpenCodeDefaultAgent]) ? agent[vgxnessOpenCodeDefaultAgent] : undefined;
+    const permission = isRecord(manager?.permission) ? manager.permission : undefined;
+    const tools = isRecord(manager?.tools) ? manager.tools : undefined;
+    const readSearchEnabled = permission?.read === 'allow' && tools?.read === true && tools.glob === true && tools.grep === true;
+    const writeShellDenied = tools?.bash === false && tools.edit === false && tools.write === false;
+    return readSearchEnabled && writeShellDenied ? 'pass' : 'warn';
+}
 function hasConfiguredSubagents(config) {
     if (config === undefined)
         return false;

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.2",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {