vgxness 1.9.1 → 1.9.3

package/dist/mcp/control-plane.js

@@ -8,6 +8,7 @@ import { openMemoryDatabase } from '../memory/sqlite/database.js';
 import { prepareMemoryDatabasePath, resolveMemoryDatabasePath } from '../memory/storage-paths.js';
 import { OpenCodeManagerPayloadService } from '../providers/opencode/manager-payload.js';
 import { RunService } from '../runs/run-service.js';
+import { sddContinuationPlanFrom } from '../sdd/sdd-continuation-plan.js';
 import { SddWorkflowService } from '../sdd/sdd-workflow-service.js';
 import { SkillRegistryService } from '../skills/skill-registry-service.js';
 import { VerificationPlanService } from '../verification/index.js';
@@ -32,7 +33,9 @@ export function callVgxTool(call, services) {
         case 'vgxness_sdd_save_artifact':
             return auditedEnvelope(validated.tool, services.sdd.saveArtifact(validated.input), services, sddSaveAuditPayload(validated.input));
         case 'vgxness_sdd_accept_artifact':
-            return auditedEnvelope(validated.tool, services.sdd.acceptArtifact(toAcceptArtifactServiceInput(validated.input)), services, sddAcceptanceAuditPayload(validated.input));
+            return auditedEnvelope(validated.tool, services.sdd.acceptArtifact(validated.input), services, sddAcceptanceAuditPayload(validated.input));
+        case 'vgxness_sdd_reopen_artifact':
+            return auditedEnvelope(validated.tool, services.sdd.reopenArtifact(validated.input), services, sddReopenAuditPayload(validated.input));
         case 'vgxness_sdd_get_artifact':
             return toEnvelope(validated.tool, services.sdd.getArtifact(validated.input));
         case 'vgxness_sdd_list_artifacts':
@@ -41,6 +44,8 @@ export function callVgxTool(call, services) {
             return toEnvelope(validated.tool, services.sdd.getNext(validated.input));
         case 'vgxness_sdd_cockpit':
             return toEnvelope(validated.tool, services.sdd.getCockpit(validated.input));
+        case 'vgxness_sdd_continue':
+            return sddContinueEnvelope(validated.input, services);
         case 'vgxness_governance_report':
             return auditedEnvelope(validated.tool, new GovernanceReportBuilder({
                 sdd: governanceSddServices(services.sdd),
@@ -94,6 +99,8 @@ export function callVgxTool(call, services) {
             return toEnvelope(validated.tool, services.runs.appendCheckpoint(validated.input));
         case 'vgxness_run_finalize':
             return toEnvelope(validated.tool, services.runs.updateFinalStatus(validated.input));
+        case 'vgxness_run_resume_candidates':
+            return runResumeCandidatesEnvelope(validated.input, services);
         case 'vgxness_run_resume_inspect':
             return toEnvelope(validated.tool, services.runs.getRunOperatorResumePlan(validated.input.runId));
         case 'vgxness_run_resume_gate':
@@ -117,10 +124,6 @@ export function callVgxTool(call, services) {
     }
     return errorEnvelope('validation_failed', 'Tool dispatch is not implemented');
 }
-function toAcceptArtifactServiceInput(input) {
-    const note = input.note ?? input.notes ?? input.rationale;
-    return note === undefined ? input : { ...input, note };
-}
 function auditedEnvelope(tool, result, services, audit) {
     if (result.ok && audit.runId !== undefined) {
         services.runs.appendEvent({
@@ -171,6 +174,24 @@ function sddAcceptanceAuditPayload(input) {
         }),
     };
 }
+function sddReopenAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-artifact-reopened',
+        relatedType: 'sdd-artifact',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-artifact-reopened',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            topicKey: value.topicKey,
+            artifactId: value.id,
+            reopenedBy: { type: 'human', id: input.reopenedBy.id },
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
 function sddSaveAuditPayload(input) {
     return {
         runId: input.runId,
@@ -222,6 +243,23 @@ 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 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,
+        ...(relatedRun.value === undefined ? {} : { relatedRunContext: relatedRun.value }),
+    }));
+}
 export function createVgxMcpControlPlane(options = {}) {
     const databasePath = resolveControlPlaneDatabasePath(options);
     if (!databasePath.ok)
@@ -237,6 +275,7 @@ export function createVgxMcpControlPlane(options = {}) {
     let closed = false;
     return {
         callVgxTool: (tool, input) => callVgxTool({ tool, input }, services),
+        database,
         close: () => {
             if (closed)
                 return;
@@ -329,6 +368,40 @@ function listRunsEnvelope(input, services) {
         ? successEnvelope('vgxness_run_list', result.value.slice(0, limit))
         : errorEnvelope(result.error.code, result.error.message, 'vgxness_run_list');
 }
+function runResumeCandidatesEnvelope(input, services) {
+    const limit = input.limit ?? 5;
+    const result = services.runs.listRecentInterruptedRuns({ project: input.project, limit });
+    if (!result.ok)
+        return errorEnvelope(result.error.code, result.error.message, 'vgxness_run_resume_candidates');
+    return successEnvelope('vgxness_run_resume_candidates', {
+        kind: 'run-resume-candidates',
+        version: 1,
+        project: input.project,
+        statuses: ['failed', 'blocked', 'needs-human'],
+        limit,
+        candidates: result.value.map((candidate) => ({
+            ...candidate,
+            recommendation: 'Inspect this interrupted run before deciding whether to continue manually.',
+            inspectTool: 'run_resume_inspect',
+            inspectInput: { runId: candidate.runId },
+            resumeCommand: `vgxness resume --project ${input.project} --run-id ${candidate.runId}`,
+        })),
+        nextStep: result.value.length === 0
+            ? 'No interrupted run candidates were found for this project. Start from the current project status or a known runId.'
+            : 'Call run_resume_inspect with a candidate runId, then use run_resume_gate only when inspect returns a relevant approvalId.',
+        safety: {
+            readOnly: true,
+            runMutation: false,
+            retryAdmitted: false,
+            providerInvoked: false,
+            writesProviderConfig: false,
+            writesArtifacts: false,
+            writesOpenSpec: false,
+            createsSandbox: false,
+            createsWorktree: false,
+        },
+    });
+}
 function toEnvelope(tool, result) {
     return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
 }

package/dist/mcp/provider-status.js

@@ -52,35 +52,36 @@ export class ProviderStatusService {
         const compactBytes = Buffer.byteLength(JSON.stringify(compactShape), 'utf8');
         const issueCount = [canonicalAgentManifest.status, configStatus, ...tools.map((tool) => (tool.present ? 'pass' : 'fail'))].filter((item) => item === 'fail' || item === 'not-configured').length;
         const warningCount = [configStatus, mcpEntry.status, ...paths.map((path) => path.status)].filter((item) => item === 'warn').length;
+        const reportBase = {
+            version: 1,
+            kind: 'provider-status',
+            project: normalized.project,
+            providerAdapter: normalized.providerAdapter,
+            scope: normalized.scope,
+            workspaceRoot: normalized.workspaceRoot,
+            status,
+            overallStatus: status,
+            inspectedPaths: checkedPaths,
+            issueCount,
+            warningCount,
+            summary: summarizeStatus(status, mcpEntry),
+            nextAction: nextActionFor(status, mcpEntry, sdd?.next),
+            checkedPaths,
+            canonicalAgentManifest,
+            ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
+            mcpRequiredTools: tools,
+            originalBytes,
+            compactBytes,
+            verboseAvailable: normalized.payloadMode === 'compact',
+            fullContentRef: `provider-status:${normalized.providerAdapter}:${normalized.workspaceRoot}`,
+            generatedAt,
+            safety: PROVIDER_HEALTH_SAFETY,
+        };
         return {
             ok: true,
-            value: {
-                version: 1,
-                kind: 'provider-status',
-                project: normalized.project,
-                providerAdapter: normalized.providerAdapter,
-                scope: normalized.scope,
-                workspaceRoot: normalized.workspaceRoot,
-                status,
-                payloadMode: normalized.payloadMode,
-                overallStatus: status,
-                inspectedPaths: checkedPaths,
-                issueCount,
-                warningCount,
-                summary: summarizeStatus(status, mcpEntry),
-                nextAction: nextActionFor(status, mcpEntry, sdd?.next),
-                checkedPaths,
-                canonicalAgentManifest,
-                config: { status: configStatus, paths: compactPaths(paths, normalized.payloadMode), mcpEntry: compactMcpEntry(mcpEntry, normalized.payloadMode) },
-                ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
-                mcpRequiredTools: tools,
-                originalBytes,
-                compactBytes,
-                verboseAvailable: normalized.payloadMode === 'compact',
-                fullContentRef: `provider-status:${normalized.providerAdapter}:${normalized.workspaceRoot}`,
-                generatedAt,
-                safety: PROVIDER_HEALTH_SAFETY,
-            },
+            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') } },
         };
     }
     readSdd(project, change) {
@@ -115,35 +116,36 @@ export class ProviderStatusService {
         const compactBytes = Buffer.byteLength(JSON.stringify(compactShape), 'utf8');
         const issueCount = [canonicalAgentManifest.status, configStatus, ...agentStatuses].filter((item) => item === 'fail' || item === 'not-configured').length;
         const warningCount = advisory.length + resolvedScope.value.warnings.length + paths.filter((path) => path.status === 'warn').length;
+        const reportBase = {
+            version: 1,
+            kind: 'provider-status',
+            project: normalized.project,
+            providerAdapter: 'claude',
+            scope: normalized.scope,
+            workspaceRoot: normalized.workspaceRoot,
+            status,
+            overallStatus: status,
+            inspectedPaths: checkedPaths,
+            issueCount,
+            warningCount,
+            summary: summarizeClaudeStatus(status, mcpEntry),
+            nextAction: nextActionFor(status, mcpEntry, sdd?.next),
+            checkedPaths,
+            canonicalAgentManifest,
+            ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
+            mcpRequiredTools: tools,
+            originalBytes,
+            compactBytes,
+            verboseAvailable: normalized.payloadMode === 'compact',
+            fullContentRef: `provider-status:claude:${normalized.workspaceRoot}`,
+            generatedAt: 'read-only-snapshot',
+            safety: PROVIDER_HEALTH_SAFETY,
+        };
         return {
             ok: true,
-            value: {
-                version: 1,
-                kind: 'provider-status',
-                project: normalized.project,
-                providerAdapter: 'claude',
-                scope: normalized.scope,
-                workspaceRoot: normalized.workspaceRoot,
-                status,
-                payloadMode: normalized.payloadMode,
-                overallStatus: status,
-                inspectedPaths: checkedPaths,
-                issueCount,
-                warningCount,
-                summary: summarizeClaudeStatus(status, mcpEntry),
-                nextAction: nextActionFor(status, mcpEntry, sdd?.next),
-                checkedPaths,
-                canonicalAgentManifest,
-                config: { status: configStatus, paths: compactPaths(paths, normalized.payloadMode), mcpEntry: compactMcpEntry(mcpEntry, normalized.payloadMode) },
-                ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
-                mcpRequiredTools: tools,
-                originalBytes,
-                compactBytes,
-                verboseAvailable: normalized.payloadMode === 'compact',
-                fullContentRef: `provider-status:claude:${normalized.workspaceRoot}`,
-                generatedAt: 'read-only-snapshot',
-                safety: PROVIDER_HEALTH_SAFETY,
-            },
+            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') } },
         };
     }
     getClaudeUserGlobalStatus(normalized, canonicalScope = 'user', scopeWarnings = []) {
@@ -162,35 +164,38 @@ export class ProviderStatusService {
         const checkedPaths = normalized.payloadMode === 'verbose' ? [mcpState.path, agents.directoryPath, ...agents.agents.map((agent) => agent.path), userMemory.path] : [mcpState.path, userMemory.path, ...agents.agents.filter((agent) => agent.exists || agent.status !== 'missing').map((agent) => agent.path)];
         const verboseShape = { config: { status: configStatus, paths, mcpEntry }, canonicalAgentManifest, agents, userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, scopeWarnings, sdd, mcpRequiredTools: tools };
         const compactShape = { config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') }, canonicalAgentManifest, agentSummary: summarizeClaudeAgents(agents), userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'), mcpRequiredTools: tools };
+        const originalBytes = Buffer.byteLength(JSON.stringify(verboseShape), 'utf8');
+        const compactBytes = Buffer.byteLength(JSON.stringify(compactShape), 'utf8');
+        const reportBase = {
+            version: 1,
+            kind: 'provider-status',
+            project: normalized.project,
+            providerAdapter: 'claude',
+            scope: normalized.scope,
+            workspaceRoot: normalized.workspaceRoot,
+            status,
+            overallStatus: status,
+            inspectedPaths: checkedPaths,
+            issueCount: [canonicalAgentManifest.status, configStatus, ...agentStatuses].filter((item) => item === 'fail' || item === 'not-configured').length,
+            warningCount: scopeWarnings.length + paths.filter((path) => path.status === 'warn').length + 1,
+            summary: summarizeClaudeStatus(status, mcpEntry),
+            nextAction: nextActionFor(status, mcpEntry, sdd?.next),
+            checkedPaths,
+            canonicalAgentManifest,
+            ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
+            mcpRequiredTools: tools,
+            originalBytes,
+            compactBytes,
+            verboseAvailable: normalized.payloadMode === 'compact',
+            fullContentRef: `provider-status:claude:user-global:${normalized.workspaceRoot}`,
+            generatedAt: 'read-only-snapshot',
+            safety: { ...PROVIDER_HEALTH_SAFETY, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES },
+        };
         return {
             ok: true,
-            value: {
-                version: 1,
-                kind: 'provider-status',
-                project: normalized.project,
-                providerAdapter: 'claude',
-                scope: normalized.scope,
-                workspaceRoot: normalized.workspaceRoot,
-                status,
-                payloadMode: normalized.payloadMode,
-                overallStatus: status,
-                inspectedPaths: checkedPaths,
-                issueCount: [canonicalAgentManifest.status, configStatus, ...agentStatuses].filter((item) => item === 'fail' || item === 'not-configured').length,
-                warningCount: scopeWarnings.length + paths.filter((path) => path.status === 'warn').length + 1,
-                summary: summarizeClaudeStatus(status, mcpEntry),
-                nextAction: nextActionFor(status, mcpEntry, sdd?.next),
-                checkedPaths,
-                canonicalAgentManifest,
-                config: { status: configStatus, paths: compactPaths(paths, normalized.payloadMode), mcpEntry: compactMcpEntry(mcpEntry, normalized.payloadMode) },
-                ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
-                mcpRequiredTools: tools,
-                originalBytes: Buffer.byteLength(JSON.stringify(verboseShape), 'utf8'),
-                compactBytes: Buffer.byteLength(JSON.stringify(compactShape), 'utf8'),
-                verboseAvailable: normalized.payloadMode === 'compact',
-                fullContentRef: `provider-status:claude:user-global:${normalized.workspaceRoot}`,
-                generatedAt: 'read-only-snapshot',
-                safety: { ...PROVIDER_HEALTH_SAFETY, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES },
-            },
+            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') } },
         };
     }
 }
@@ -221,16 +226,12 @@ function claudeProjectMemoryPathStatus(state) {
 function compactPaths(paths, mode) {
     if (mode === 'verbose')
         return paths;
-    return paths.map((path) => path.status === 'pass'
-        ? { ...path, detail: `${path.label}: pass` }
-        : path.status === 'not-configured'
-            ? { ...path, detail: `${path.label}: not configured` }
-            : path);
+    return paths.map((path) => ({ label: path.label, path: path.path, status: path.status }));
 }
 function compactMcpEntry(entry, mode) {
-    if (mode === 'verbose' || entry.status !== 'pass')
+    if (mode === 'verbose')
         return entry;
-    return { ...entry, detail: 'MCP server entry found.' };
+    return { configured: entry.configured, status: entry.status, serverName: entry.serverName };
 }
 function compactSdd(sdd, mode) {
     if (mode === 'verbose')

package/dist/mcp/schema.js

@@ -9,10 +9,12 @@ export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
     'vgxness_sdd_get_readiness',
     'vgxness_sdd_save_artifact',
     'vgxness_sdd_accept_artifact',
+    'vgxness_sdd_reopen_artifact',
     'vgxness_sdd_get_artifact',
     'vgxness_sdd_list_artifacts',
     'vgxness_sdd_next',
     'vgxness_sdd_cockpit',
+    'vgxness_sdd_continue',
     'vgxness_governance_report',
     'vgxness_memory_save',
     'vgxness_memory_search',
@@ -36,6 +38,7 @@ export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
     'vgxness_run_start',
     'vgxness_run_checkpoint',
     'vgxness_run_finalize',
+    'vgxness_run_resume_candidates',
     'vgxness_run_resume_inspect',
     'vgxness_run_resume_gate',
     'vgxness_provider_status',
@@ -49,10 +52,12 @@ export const EXPOSED_VGX_MCP_TOOL_NAMES = [
     'sdd_get_readiness',
     'sdd_save_artifact',
     'sdd_accept_artifact',
+    'sdd_reopen_artifact',
     'sdd_get_artifact',
     'sdd_list_artifacts',
     'sdd_next',
     'sdd_cockpit',
+    'sdd_continue',
     'governance_report',
     'memory_save',
     'memory_search',
@@ -76,6 +81,7 @@ export const EXPOSED_VGX_MCP_TOOL_NAMES = [
     'run_start',
     'run_checkpoint',
     'run_finalize',
+    'run_resume_candidates',
     'run_resume_inspect',
     'run_resume_gate',
     'provider_status',
@@ -102,6 +108,7 @@ const payloadModes = ['compact', 'verbose'];
 const contextCockpitLevels = ['compact', 'expanded', 'verbose'];
 const providerChangePlanProviders = ['opencode', 'claude', 'antigravity', 'custom'];
 const providerChangePlanTypes = ['opencode-mcp-install', 'claude-mcp-install', 'setup', 'install', 'config-preparation'];
+const sddPhaseInputSchema = z.union([z.enum(sddPhases), z.literal('apply')]);
 const jsonValueSchema = z.lazy(() => z.union([z.string(), z.number().finite(), z.boolean(), z.null(), z.array(jsonValueSchema), z.record(z.string(), jsonValueSchema)]));
 export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
     vgxness_sdd_status: z
@@ -114,7 +121,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         .object({
         project: z.string().min(1),
         change: z.string().min(1),
-        phase: z.enum(sddPhases),
+        phase: sddPhaseInputSchema,
         runId: z.string().min(1).optional(),
         agentId: z.string().min(1).optional(),
     })
@@ -123,7 +130,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         .object({
         project: z.string().min(1),
         change: z.string().min(1),
-        phase: z.enum(sddPhases),
+        phase: sddPhaseInputSchema,
         runId: z.string().min(1).optional(),
         agentId: z.string().min(1).optional(),
     })
@@ -132,7 +139,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         .object({
         project: z.string().min(1),
         change: z.string().min(1),
-        phase: z.enum(sddPhases),
+        phase: sddPhaseInputSchema,
         content: z.string().min(1),
     })
         .passthrough(),
@@ -140,7 +147,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         .object({
         project: z.string().min(1),
         change: z.string().min(1),
-        phase: z.enum(sddPhases),
+        phase: sddPhaseInputSchema,
         acceptedBy: z.object({
             type: z.literal('human'),
             id: z.string().min(1),
@@ -148,8 +155,22 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         }),
         acceptedAt: z.string().min(1).optional(),
         note: z.string().min(1).optional(),
-        notes: z.string().min(1).optional(),
-        rationale: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+    })
+        .passthrough(),
+    vgxness_sdd_reopen_artifact: z
+        .object({
+        project: z.string().min(1),
+        change: z.string().min(1),
+        phase: sddPhaseInputSchema,
+        reopenedBy: z.object({
+            type: z.literal('human'),
+            id: z.string().min(1),
+            displayName: z.string().min(1).optional(),
+        }),
+        reopenedAt: z.string().min(1).optional(),
+        note: z.string().min(1).optional(),
         runId: z.string().min(1).optional(),
         agentId: z.string().min(1).optional(),
     })
@@ -158,7 +179,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         .object({
         project: z.string().min(1),
         change: z.string().min(1),
-        phase: z.enum(sddPhases),
+        phase: sddPhaseInputSchema,
         payloadMode: z.enum(payloadModes).optional(),
     })
         .passthrough(),
@@ -181,6 +202,13 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         change: z.string().min(1),
     })
         .passthrough(),
+    vgxness_sdd_continue: z
+        .object({
+        project: z.string().min(1),
+        change: z.string().min(1),
+        payloadMode: z.enum(payloadModes).optional(),
+    })
+        .passthrough(),
     vgxness_governance_report: z
         .object({
         project: z.string().min(1),
@@ -348,7 +376,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         workspaceRoot: z.string().min(1).optional(),
         maxSourceBytes: z.number().int().positive().optional(),
         change: z.string().min(1).optional(),
-        phase: z.enum(sddPhases).optional(),
+        phase: sddPhaseInputSchema.optional(),
     })
         .passthrough(),
     vgxness_run_list: z
@@ -415,6 +443,12 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         outcomeReason: z.string().min(1).optional(),
     })
         .passthrough(),
+    vgxness_run_resume_candidates: z
+        .object({
+        project: z.string().min(1),
+        limit: z.number().int().min(1).max(100).optional(),
+    })
+        .passthrough(),
     vgxness_run_resume_inspect: z
         .object({
         runId: z.string().min(1),

package/dist/mcp/stdio-server.js

@@ -1,9 +1,11 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { runBootAgentSeedUpgrade } from '../agents/boot-upgrade.js';
 import { createVgxMcpControlPlane } from './control-plane.js';
 import { EXPOSED_VGX_MCP_TOOL_NAMES, toInternalVgxMcpToolName, VGX_MCP_TOOL_INPUT_SCHEMAS, } from './schema.js';
 export async function startVgxMcpStdioServer(options = {}) {
     const controlPlane = createVgxMcpControlPlane(options.databasePath === undefined ? {} : { databasePath: options.databasePath });
+    runBootAgentSeedUpgrade(controlPlane.database);
     const mcpServer = new McpServer({ name: 'vgxness', version: '0.1.0' });
     const transport = new StdioServerTransport();
     let closed = false;
@@ -55,6 +57,8 @@ function descriptionForTool(publicToolName) {
         return 'Read-only OpenCode handoff preview; returns context for manual continuation only, does not execute/control OpenCode, write .opencode/provider config, or create runs, checkpoints, events, sessions, or skill-usage records.';
     if (publicToolName === 'verification_plan')
         return 'Read-only verification plan recommendations only; does not execute commands, write provider config, persist results, create checkpoints, or infer SDD acceptance.';
+    if (publicToolName === 'run_resume_candidates')
+        return 'Read-only interrupted run resume candidate discovery by project; lists bounded failed, blocked, and needs-human runs without mutation, retry admission, provider execution, artifact/config/openspec writes, sandboxes, worktrees, or sessions.';
     if (publicToolName === 'run_resume_inspect')
         return 'Read-only run resume advisory inspect; plan-only and does not execute resume logic, invoke providers, write provider config, mutate retry/abandon/attempt state, or reconstruct sandboxes, worktrees, sessions, or transcripts.';
     if (publicToolName === 'run_resume_gate')
@@ -63,6 +67,8 @@ function descriptionForTool(publicToolName) {
         return 'Read-only context cockpit for start/resume/recovery; returns latest restorable session plus bounded memory previews without traces, provider config writes, repository writes, runs, artifacts, or session mutations.';
     if (publicToolName === 'sdd_cockpit')
         return 'Read-only SDD cockpit summary with next decision, explicit acceptance state, metadata-only artifact summaries, and aggregate blockers.';
+    if (publicToolName === 'sdd_continue')
+        return 'Read-only SDD continuation planner; returns blocker actions, safe suggested commands, related interrupted run context, and safety notes without provider execution, run creation, artifact mutation, provider config writes, or openspec writes.';
     const toolName = toInternalVgxMcpToolName(publicToolName);
     return `VGX control-plane tool ${toolName}`;
 }