vgxness 1.9.2 → 1.9.4

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') } },
         };
     }
 }

package/dist/mcp/schema.js

@@ -14,6 +14,7 @@ export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
     'vgxness_sdd_list_artifacts',
     'vgxness_sdd_next',
     'vgxness_sdd_cockpit',
+    'vgxness_sdd_continue',
     'vgxness_governance_report',
     'vgxness_memory_save',
     'vgxness_memory_search',
@@ -37,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',
@@ -55,6 +57,7 @@ export const EXPOSED_VGX_MCP_TOOL_NAMES = [
     'sdd_list_artifacts',
     'sdd_next',
     'sdd_cockpit',
+    'sdd_continue',
     'governance_report',
     'memory_save',
     'memory_search',
@@ -78,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',
@@ -104,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
@@ -116,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(),
     })
@@ -125,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(),
     })
@@ -134,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(),
@@ -142,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),
@@ -158,7 +163,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,
         reopenedBy: z.object({
             type: z.literal('human'),
             id: z.string().min(1),
@@ -174,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(),
@@ -197,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),
@@ -364,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
@@ -431,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

@@ -57,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')
@@ -65,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}`;
 }

package/dist/mcp/validation.js

@@ -1,6 +1,6 @@
 import { isRiskyPermissionCategory, permissionCategories } from '../permissions/schema.js';
 import { parseOperationRetryPolicy } from '../runs/operation-retry.js';
-import { isSddPhase, sddPhases } from '../sdd/schema.js';
+import { normalizeSddPhaseInput, sddPhases } from '../sdd/schema.js';
 import { workflowIds } from '../workflows/schema.js';
 import { supportedTypeMessage, verificationChangeTypes } from '../verification/index.js';
 import { errorEnvelope, isVgxMcpToolName, } from './schema.js';
@@ -52,6 +52,8 @@ export function validateVgxMcpToolCall(call) {
             return validationSuccess(tool.value, validateSddNextInput(input, tool.value));
         case 'vgxness_sdd_cockpit':
             return validationSuccess(tool.value, validateSddCockpitInput(input, tool.value));
+        case 'vgxness_sdd_continue':
+            return validationSuccess(tool.value, validateSddContinueInput(input, tool.value));
         case 'vgxness_governance_report':
             return validationSuccess(tool.value, validateGovernanceReportInput(input, tool.value));
         case 'vgxness_memory_save':
@@ -98,6 +100,8 @@ export function validateVgxMcpToolCall(call) {
             return validationSuccess(tool.value, validateRunCheckpointInput(input, tool.value));
         case 'vgxness_run_finalize':
             return validationSuccess(tool.value, validateRunFinalizeInput(input, tool.value));
+        case 'vgxness_run_resume_candidates':
+            return validationSuccess(tool.value, validateRunResumeCandidatesInput(input, tool.value));
         case 'vgxness_run_resume_inspect':
             return validationSuccess(tool.value, validateRunResumeInspectInput(input, tool.value));
         case 'vgxness_run_resume_gate':
@@ -240,6 +244,21 @@ function validateSddCockpitInput(input, tool) {
         return record;
     return readProjectAndChange(record.value, tool);
 }
+function validateSddContinueInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'change', 'payloadMode']);
+    if (!record.ok)
+        return record;
+    const base = readProjectAndChange(record.value, tool);
+    if (!base.ok)
+        return base;
+    const payloadMode = readOptionalOneOf(record.value, 'payloadMode', payloadModes, tool);
+    if (!payloadMode.ok)
+        return payloadMode;
+    const result = { ...base.value };
+    if (payloadMode.value !== undefined)
+        result.payloadMode = payloadMode.value;
+    return { ok: true, value: result };
+}
 function validateContextCockpitInput(input, tool) {
     const record = inputRecord(input, tool, ['project', 'change', 'directory', 'limit', 'level']);
     if (!record.ok)
@@ -971,6 +990,22 @@ function validateRunFinalizeInput(input, tool) {
         return copied;
     return { ok: true, value: result };
 }
+function validateRunResumeCandidatesInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    if (record.value.limit !== undefined) {
+        const limit = readBoundedLimit(record.value, tool);
+        if (!limit.ok)
+            return limit;
+        result.limit = limit.value;
+    }
+    return { ok: true, value: result };
+}
 function validateRunResumeInspectInput(input, tool) {
     const record = inputRecord(input, tool, ['runId']);
     if (!record.ok)
@@ -1053,9 +1088,10 @@ function readPhase(record, tool) {
     const phase = readNonEmptyString(record, 'phase', tool);
     if (!phase.ok)
         return phase;
-    if (!isSddPhase(phase.value))
+    const normalized = normalizeSddPhaseInput(phase.value);
+    if (normalized === undefined)
         return validationFailure(`phase must be one of: ${sddPhases.join(', ')}`, tool);
-    return { ok: true, value: phase.value };
+    return { ok: true, value: normalized };
 }
 function copyOptionalStrings(target, record, tool, fields) {
     for (const field of fields) {

package/dist/resume/product-resume.js

@@ -0,0 +1,166 @@
+import { basename, resolve } from 'node:path';
+const candidateLimit = 5;
+const baseSafety = [
+    'Read-only resume cockpit: does not execute providers, retry operations, edit files, write provider config, create sandboxes, or create worktrees.',
+    'This command only helps inspect interrupted work; any continuation remains an explicit human decision.',
+];
+export function buildProductResume(input) {
+    const initialProject = resolveProject(input);
+    if (input.runId === undefined) {
+        return buildOrientationResume(input, initialProject);
+    }
+    if (input.databaseError !== undefined) {
+        return blockedResume({
+            project: initialProject,
+            runId: input.runId,
+            blocker: `Unable to read local memory store${input.databasePath === undefined ? '' : ` at ${input.databasePath}`}: ${input.databaseError}`,
+            why: 'Run inspection requires a readable local memory store.',
+            command: `vgxness resume --project ${initialProject.value} --run-id ${input.runId} --db <path>`,
+            safety: baseSafety,
+        });
+    }
+    if (input.runs?.getRunOperatorResumePlan === undefined) {
+        return blockedResume({
+            project: initialProject,
+            runId: input.runId,
+            blocker: 'Run resume inspection service is not available for this request.',
+            why: 'Use the installed CLI or provide a readable local memory store.',
+            command: `vgxness resume --project ${initialProject.value} --run-id ${input.runId}`,
+            safety: baseSafety,
+        });
+    }
+    const inspected = input.runs.getRunOperatorResumePlan(input.runId);
+    if (!inspected.ok) {
+        return blockedResume({
+            project: initialProject,
+            runId: input.runId,
+            blocker: inspected.error.message,
+            why: 'VGXNESS could not find or inspect the requested run.',
+            command: `vgxness runs list --project ${initialProject.value}`,
+            safety: baseSafety,
+        });
+    }
+    return fromRunOperatorResumePlan(inspected.value, initialProject, input.databasePath !== undefined);
+}
+function buildOrientationResume(input, project) {
+    const dbHint = input.databasePath === undefined ? '' : ` --db ${input.databasePath}`;
+    const command = `vgxness runs list --project ${project.value} --status failed${dbHint}`;
+    const manualNextCommands = [
+        `vgxness runs list --project ${project.value} --status failed${dbHint}`,
+        `vgxness runs list --project ${project.value} --status blocked${dbHint}`,
+        `vgxness runs list --project ${project.value} --status needs-human${dbHint}`,
+        `vgxness resume --project ${project.value} --run-id <id>${dbHint}`,
+    ];
+    if (input.databaseError !== undefined) {
+        return {
+            version: 1,
+            kind: 'product-resume',
+            mode: 'orientation',
+            project,
+            resumable: false,
+            resume: ['Find an interrupted run, then inspect it before deciding whether to continue manually.'],
+            why: ['No --run-id was provided, so VGXNESS cannot inspect checkpoint, approval, or blocker state for a selected run yet.'],
+            blockers: [`Unable to read local memory store${input.databasePath === undefined ? '' : ` at ${input.databasePath}`}: ${input.databaseError}`],
+            command,
+            manualNextCommands,
+            safety: baseSafety,
+            candidateRuns: [],
+        };
+    }
+    const listed = input.runs?.listRecentInterruptedRuns?.({ project: project.value, limit: candidateLimit });
+    if (listed !== undefined && !listed.ok) {
+        return {
+            version: 1,
+            kind: 'product-resume',
+            mode: 'orientation',
+            project,
+            resumable: false,
+            resume: ['Find an interrupted run, then inspect it before deciding whether to continue manually.'],
+            why: ['No --run-id was provided, so VGXNESS cannot inspect checkpoint, approval, or blocker state for a selected run yet.'],
+            blockers: [listed.error.message],
+            command,
+            manualNextCommands,
+            safety: baseSafety,
+            candidateRuns: [],
+        };
+    }
+    const candidateRuns = (listed?.value ?? []).map((candidate) => ({
+        ...candidate,
+        ...(candidate.userIntent === undefined ? {} : { userIntent: shorten(candidate.userIntent, 72) }),
+        command: `vgxness resume --project ${project.value} --run-id ${candidate.runId}${dbHint}`,
+    }));
+    const why = listed === undefined
+        ? ['No --run-id was provided, so VGXNESS cannot inspect checkpoint, approval, or blocker state for a selected run yet.']
+        : ['No --run-id was provided, so VGXNESS is showing recent failed, blocked, or needs-human runs for this project.'];
+    return {
+        version: 1,
+        kind: 'product-resume',
+        mode: 'orientation',
+        project,
+        resumable: false,
+        resume: candidateRuns.length === 0
+            ? ['Find an interrupted run, then inspect it before deciding whether to continue manually.']
+            : ['Recent interrupted runs were found. Inspect one before deciding whether to continue manually.'],
+        why,
+        blockers: [],
+        command,
+        manualNextCommands,
+        safety: [listed === undefined ? 'Did not open the local memory store because no project-specific run lookup was requested.' : 'Opened the local memory store read-only to list recent interrupted runs.', ...baseSafety],
+        candidateRuns,
+    };
+}
+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 fromRunOperatorResumePlan(inspect, fallbackProject, includeDbHint) {
+    const project = { value: inspect.run.project || fallbackProject.value, source: 'run' };
+    const blockerLines = inspect.blockers.map((blocker) => (blocker.relatedId === undefined ? blocker.message : `${blocker.message} (${blocker.relatedId})`));
+    const latestCheckpoint = inspect.latestCheckpoint === null ? 'none' : `${inspect.latestCheckpoint.label} (${inspect.latestCheckpoint.id})`;
+    const dbHint = includeDbHint ? ' --db <path>' : '';
+    return {
+        version: 1,
+        kind: 'product-resume',
+        mode: 'inspect',
+        project,
+        runId: inspect.run.id,
+        resumable: inspect.resumePlan.resumable,
+        resume: [inspect.resumePlan.recommendedAction],
+        why: [
+            `Run: ${inspect.run.id}`,
+            `Status: ${inspect.run.status}`,
+            `Workflow: ${inspect.run.workflow} / ${inspect.run.phase}`,
+            `Latest checkpoint: ${latestCheckpoint}`,
+            inspect.debug.summary,
+        ],
+        blockers: blockerLines,
+        command: `vgxness resume --project ${project.value} --run-id ${inspect.run.id}${dbHint}`,
+        manualNextCommands: inspect.manualNextCommands,
+        safety: baseSafety,
+        candidateRuns: [],
+        inspect,
+    };
+}
+function blockedResume(input) {
+    return {
+        version: 1,
+        kind: 'product-resume',
+        mode: 'inspect',
+        project: input.project,
+        runId: input.runId,
+        resumable: false,
+        resume: ['Resolve the blocker, then inspect the run again before deciding whether to continue manually.'],
+        why: [`Run: ${input.runId}`, input.why],
+        blockers: [input.blocker],
+        command: input.command,
+        manualNextCommands: [input.command],
+        safety: input.safety,
+        candidateRuns: [],
+    };
+}
+function shorten(value, maxLength) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3)}...`;
+}

package/dist/runs/repositories/runs.js

@@ -70,13 +70,24 @@ export class RunRepository {
                 where.push('status=@status');
                 parameters.status = filters.status;
             }
+            if (filters.statuses !== undefined && filters.statuses.length > 0) {
+                const statusPlaceholders = filters.statuses.map((_, index) => `@status${index}`);
+                where.push(`status IN (${statusPlaceholders.join(', ')})`);
+                for (const [index, status] of filters.statuses.entries())
+                    parameters[`status${index}`] = status;
+            }
+            const limitClause = filters.limit === undefined ? '' : 'LIMIT @limit';
+            const queryParameters = { ...parameters };
+            if (filters.limit !== undefined)
+                queryParameters.limit = filters.limit;
             const rows = this.db.connection
                 .prepare(`
         SELECT * FROM runs
         ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
         ORDER BY created_at DESC
+        ${limitClause}
       `)
-                .all(parameters);
+                .all(queryParameters);
             return ok(rows.map(mapRun));
         }
         catch (cause) {