vgxness 1.9.2 → 1.9.4

package/dist/cli/tui/main-menu/main-menu-read-model.js

@@ -11,10 +11,10 @@ const statCards = [
     { label: 'actions', value: '5', badge: '', description: 'safe routes' },
     { label: 'provider', value: '1', badge: '', description: 'OpenCode' },
     { label: 'writes', value: '0', badge: '', description: 'dashboard render' },
-    { label: 'SDD', value: 'guided', badge: '', description: 'MCP flow' },
+    { label: 'SDD', value: 'OpenCode', badge: '', description: 'daily surface' },
 ];
 const statusSnapshotLines = [
-    'OpenCode supported; dashboard does not call providers.',
+    'OpenCode + VGXNESS MCP is the daily SDD surface; dashboard does not call providers.',
     'Advanced checks stay explicit: setup status, mcp doctor opencode.',
 ];
 const optionCopy = {
@@ -34,17 +34,17 @@ const optionCopy = {
     },
     sdd: {
         label: 'SDD workflow',
-        description: 'artifacts, phases, next step',
+        description: 'diagnostics, recovery, fallback',
         badges: [tuiBadges.previewOnly],
         detailTitle: 'SDD workflow',
-        detailLines: ['Use OpenCode conversation plus VGXNESS MCP for daily progression.'],
+        detailLines: ['Use OpenCode conversation plus VGXNESS MCP and hidden SDD subagents for daily progression; this TUI stays read-only for setup, diagnostics, recovery, and fallback commands.'],
     },
     'advanced-cli': {
         label: 'Advanced CLI',
-        description: 'manual commands, no automation',
+        description: 'fallback scripts, no automation',
         badges: [tuiBadges.manual],
         detailTitle: 'Advanced CLI',
-        detailLines: ['Prints explicit command references; no provider config is written.'],
+        detailLines: ['Prints explicit diagnostic, recovery, fallback, and scripting command references; no provider config is written.'],
     },
     exit: {
         label: 'Quit',
@@ -62,13 +62,13 @@ export function buildMainMenuViewModel(state) {
         subtitle: dashboardHero.subtitle,
         hero: dashboardHero,
         statCards,
-        contextLines: ['Pick a route. Dashboard render stays passive/read-only.'],
+        contextLines: ['Pick a route. Dashboard render stays passive/read-only; daily SDD continues in OpenCode.'],
         options,
         detail: { title: focused.detailTitle, lines: focused.detailLines, badges: focused.badges },
         statusSnapshot: { title: 'Signal', lines: statusSnapshotLines, badges: [tuiBadges.readOnly] },
         safetyLines: ['read-only • no provider writes • explicit confirmation'],
         helpLines: state.helpVisible
-            ? ['Keys: ↑/↓ or j/k move, Enter open, ?/h help, q/Esc quit.', 'Guidance entries print commands only; setup writes still require confirmation.']
+            ? ['Keys: ↑/↓ or j/k move, Enter open, ?/h help, q/Esc quit.', 'Guidance entries print fallback/diagnostic commands only; setup writes still require confirmation.']
             : [],
         footer: state.viewport.mode === 'narrow' ? 'no provider writes • explicit confirmation' : 'j/k • enter • q • no provider writes • explicit confirmation',
     };

package/dist/cli/tui/setup/setup-tui-services.js

@@ -1,4 +1,7 @@
+import { computeEffectiveManagerInstructions } from '../../../agents/manager-profile-overlay-service.js';
 import { installOpenCodeMcpClient } from '../../../mcp/client-install-opencode.js';
+import { openMemoryDatabase } from '../../../memory/sqlite/database.js';
+import { prepareMemoryDatabasePath } from '../../../memory/storage-paths.js';
 import { vgxnessSetupDefaults } from '../../../setup/setup-defaults.js';
 import { createSetupPlan } from '../../../setup/setup-plan.js';
 export function setupPlanInputFromTui(input) {
@@ -37,16 +40,30 @@ export async function applySetupTuiPlan(planInput, runtime) {
         };
     if (plan.value.status !== 'ready')
         return { ok: false, error: { code: 'validation_failed', message: `Setup plan is ${plan.value.status}; resolve blockers before applying.` } };
-    const installed = await installOpenCodeMcpClient({
-        cwd: runtime.cwd,
-        databasePath: plan.value.db.path,
-        databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
-        scope: planInput.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
-        env: runtime.env,
-        confirmed: true,
-        mcpOnly: planInput.installMode === 'mcp-only',
-        ...(planInput.overwriteVgxness === undefined ? {} : { overwriteVgxness: planInput.overwriteVgxness }),
-    });
+    const prepared = prepareMemoryDatabasePath(plan.value.db.path);
+    if (!prepared.ok)
+        return prepared;
+    const opened = openMemoryDatabase({ path: plan.value.db.path });
+    if (!opened.ok)
+        return opened;
+    let installed;
+    try {
+        const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value, planInput.project);
+        installed = await installOpenCodeMcpClient({
+            cwd: runtime.cwd,
+            databasePath: plan.value.db.path,
+            databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
+            scope: planInput.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
+            env: runtime.env,
+            confirmed: true,
+            mcpOnly: planInput.installMode === 'mcp-only',
+            ...(planInput.overwriteVgxness === undefined ? {} : { overwriteVgxness: planInput.overwriteVgxness }),
+            ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+        });
+    }
+    finally {
+        opened.value.close();
+    }
     if (installed.status !== 'installed')
         return { ok: false, error: { code: 'validation_failed', message: `${installed.reason}: ${installed.message}` } };
     return {

package/dist/code/cli/code-command.js

@@ -1,3 +1,4 @@
+import { normalizeSddPhaseInput } from '../../sdd/schema.js';
 import { resolveCodeConfig } from '../config/defaults.js';
 import { CodeProviderRegistry } from '../providers/provider-registry.js';
 import { exitCodeForCodeStatus, renderHumanCodeSummary } from '../reporting/summary.js';
@@ -31,11 +32,12 @@ export async function runCodeCommand(input) {
         };
     const intent = input.command === 'sdd' ? `Run SDD ${input.args[1] ?? ''} for ${input.args[0] ?? ''}`.trim() : input.args.join(' ').trim();
     const changeId = input.command === 'sdd' ? input.args[0] : undefined;
-    const phase = input.command === 'sdd' ? input.args[1] : undefined;
-    if (input.command === 'sdd' && (changeId === undefined || phase === undefined))
+    const phaseInput = input.command === 'sdd' ? input.args[1] : undefined;
+    const phase = phaseInput === undefined ? undefined : normalizeSddPhaseInput(phaseInput);
+    if (input.command === 'sdd' && (changeId === undefined || phaseInput === undefined))
         return { exitCode: 1, stdout: '', stderr: 'Missing sdd change and phase\n' };
-    if (input.command === 'sdd' && phase !== undefined && !isSddCodePhase(phase))
-        return { exitCode: 1, stdout: '', stderr: `Unknown SDD phase: ${phase}\n` };
+    if (input.command === 'sdd' && phaseInput !== undefined && phase === undefined)
+        return { exitCode: 1, stdout: '', stderr: `Unknown SDD phase: ${phaseInput}\n` };
     if (!intent)
         return {
             exitCode: 1,
@@ -77,6 +79,7 @@ export async function runCodeCommand(input) {
         cwd: input.cwd,
         ...(changeId === undefined ? {} : { changeId }),
         ...(phase !== undefined && isSddCodePhase(phase) ? { phase } : {}),
+        ...(input.sddRuntimeMode === undefined ? {} : { sddRuntimeMode: input.sddRuntimeMode }),
         ...(input.persistArtifact === undefined ? {} : { persistArtifact: input.persistArtifact }),
         ...(input.sddGateway === undefined ? {} : { sddGateway: input.sddGateway }),
         ...(input.memoryGateway === undefined ? {} : { memoryGateway: input.memoryGateway }),

package/dist/code/reporting/summary.js

@@ -21,7 +21,10 @@ export function renderHumanCodeSummary(summary) {
         ...(summary.sdd === undefined
             ? []
             : [
-                `SDD: ${summary.sdd.changeId}/${summary.sdd.phase} saved=${summary.sdd.artifactSaved ? 'yes' : 'no'}`,
+                `SDD: ${summary.sdd.changeId}/${summary.sdd.phase} mode=${summary.sdd.sddRuntimeMode ?? 'strict'} saved=${summary.sdd.artifactSaved ? 'yes' : 'no'}`,
+                ...(summary.sdd.sddRuntimeMode === 'draft-run'
+                    ? ['SDD draft-run note: draft prerequisites are used for planning only; human acceptance is still required; apply-progress remains gated.']
+                    : []),
                 `Next SDD step: ${summary.sdd.nextRecommendation}`,
             ]),
         `Risks: ${summary.risks.length === 0 ? 'none reported' : summary.risks.join('; ')}`,

package/dist/code/runtime/code-runtime.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { normalizeSddPhaseInput } from '../../sdd/schema.js';
 import { resolveCodeConfig } from '../config/defaults.js';
 import { buildCodePrompt } from '../prompts/prompt-builder.js';
 import { CodeProviderError } from '../providers/provider-adapter.js';
@@ -30,7 +31,13 @@ export class CodeRuntime {
             if (input.changeId === undefined || input.phase === undefined || !isSddCodePhase(input.phase))
                 throw new Error('SDD mode requires a valid changeId and phase');
             const gateway = input.sddGateway ?? new InMemorySddGateway();
-            sddContext = await loadSddContext({ gateway, project, changeId: input.changeId, phase: input.phase });
+            sddContext = await loadSddContext({
+                gateway,
+                project,
+                changeId: input.changeId,
+                phase: input.phase,
+                ...(input.sddRuntimeMode === undefined ? {} : { runtimeMode: input.sddRuntimeMode }),
+            });
         }
         const availableDefinitions = input.mode === 'sdd' && input.phase !== undefined
             ? sddToolDefinitions({ phase: input.phase, persist: input.persistArtifact === true })
@@ -117,6 +124,7 @@ export class CodeRuntime {
                 ...(diagnostics === undefined ? {} : { diagnostics: diagnostics }),
             },
             ...(sddContext === undefined ? {} : { changeId: sddContext.changeId, sddPhase: sddContext.phase }),
+            ...(sddContext === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
         });
         if (sddContext !== undefined) {
             await this.checkpoint(run.id, session, 'sdd-context-loaded', {
@@ -480,7 +488,15 @@ export class CodeRuntime {
             memory,
             ...(sddContext === undefined
                 ? {}
-                : { sdd: { changeId: sddContext.changeId, phase: sddContext.phase, artifactSaved, nextRecommendation: sddContext.next.recommendedAction } }),
+                : {
+                    sdd: {
+                        changeId: sddContext.changeId,
+                        phase: sddContext.phase,
+                        ...(sddContext.runtimeMode === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
+                        artifactSaved,
+                        nextRecommendation: sddContext.next.recommendedAction,
+                    },
+                }),
         };
         const summary = config.transcriptMode === 'off' ? baseSummary : { ...baseSummary, transcript: buildTranscript(config.transcriptMode, session.checkpoints, toolResults) };
         if (sddContext !== undefined)
@@ -533,7 +549,13 @@ export class CodeRuntime {
             verification: { status: 'not-run', reason: 'SDD phase blocked before provider execution.' },
             filesChanged: [],
             risks: [answer],
-            sdd: { changeId: sddContext.changeId, phase: sddContext.phase, artifactSaved: false, nextRecommendation: sddContext.next.recommendedAction },
+            sdd: {
+                changeId: sddContext.changeId,
+                phase: sddContext.phase,
+                ...(sddContext.runtimeMode === undefined ? {} : { sddRuntimeMode: sddContext.runtimeMode }),
+                artifactSaved: false,
+                nextRecommendation: sddContext.next.recommendedAction,
+            },
         };
         await this.runGateway.finalize(runId, { status: 'blocked', outcome: 'blocked', outcomeReason: answer });
         return summary;
@@ -641,7 +663,8 @@ export class CodeRuntime {
                     changedFiles: [],
                 };
             if (call.name === 'sdd_read_artifact') {
-                const phase = typeof call.input.phase === 'string' && isSddCodePhase(call.input.phase) ? call.input.phase : context.phase;
+                const requestedPhase = typeof call.input.phase === 'string' ? normalizeSddPhaseInput(call.input.phase) : undefined;
+                const phase = requestedPhase !== undefined && isSddCodePhase(requestedPhase) ? requestedPhase : context.phase;
                 const artifact = await gateway.getArtifact({ project, change: context.changeId, phase });
                 return {
                     result: { toolCallId: call.id, toolName: call.name, ok: true, output: { phase, artifact }, metadata: { capability, truncated: false } },

package/dist/code/runtime/sdd-context.js

@@ -10,6 +10,7 @@ export function shellEnabledForSddPhase(phase) {
     return phase === 'apply-progress' || phase === 'verify';
 }
 export async function loadSddContext(input) {
+    const runtimeMode = input.runtimeMode ?? 'strict';
     const [status, next] = await Promise.all([
         input.gateway.getStatus({ project: input.project, change: input.changeId }),
         input.gateway.getNextPhase({ project: input.project, change: input.changeId }),
@@ -22,7 +23,7 @@ export async function loadSddContext(input) {
         if (artifact !== null)
             artifacts.push(toContextArtifact(input.project, input.changeId, phase, phase === input.phase ? 'active' : 'accepted', artifact.content, phaseStatus));
     }
-    return { changeId: input.changeId, phase: input.phase, status, next, artifacts };
+    return { changeId: input.changeId, phase: input.phase, runtimeMode, status, next, artifacts };
 }
 function toContextArtifact(project, change, phase, role, content, phaseStatus) {
     const bytes = Buffer.byteLength(content, 'utf8');
@@ -98,6 +99,8 @@ export function validateSddReadiness(context) {
                 recommendedAction: `Accept or restore prerequisites before running ${context.phase}.`,
             },
         };
+    if (isDraftRun(context) && isPlanningPhase(context.phase))
+        return { ok: true };
     if (present)
         return { ok: true };
     if (context.status.nextReadyPhase === context.phase)
@@ -123,10 +126,23 @@ export function activeBlockedPrerequisites(context) {
             return [{ phase, topicKey, reason: 'missing' }];
         if (status.accepted === true && status.legacy !== true)
             return [];
-        const reason = status.legacy === true ? 'legacy' : status.state === 'rejected' || status.state === 'superseded' ? status.state : 'draft';
+        if (status.legacy === true)
+            return [{ phase, topicKey, reason: 'legacy', ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }) }];
+        if (draftPrerequisiteAllowed(context, status.state ?? 'draft'))
+            return [];
+        const reason = status.state === 'rejected' || status.state === 'superseded' ? status.state : 'draft';
         return [{ phase, topicKey, reason, ...(status.artifactId === undefined ? {} : { artifactId: status.artifactId }) }];
     });
 }
+function draftPrerequisiteAllowed(context, state) {
+    return isDraftRun(context) && isPlanningPhase(context.phase) && state === 'draft';
+}
+function isDraftRun(context) {
+    return context.runtimeMode === 'draft-run';
+}
+function isPlanningPhase(phase) {
+    return phase === 'explore' || phase === 'proposal' || phase === 'spec' || phase === 'design' || phase === 'tasks';
+}
 function acceptedArtifactPhases(active) {
     return prerequisitePhases(active);
 }

package/dist/governance/governance-report-builder.js

@@ -1,5 +1,5 @@
 import { getSddPhasePermissionMatrixForPhase, permissionCategories, sddPhasePermissionMatrixVersion } from '../permissions/policy-evaluator.js';
-import { isSddPhase, normalizeSddArtifact } from '../sdd/schema.js';
+import { isSddPhase, normalizeSddArtifact, normalizeSddPhaseInput } from '../sdd/schema.js';
 import { fingerprintManagerProfileOverlay } from './overlay-fingerprint.js';
 export class GovernanceReportBuilder {
     services;
@@ -27,11 +27,13 @@ export class GovernanceReportBuilder {
             warnings.push('run-service-unavailable');
         }
         const workflow = input.workflow ?? run?.workflow;
-        const phase = input.phase ?? run?.phase;
+        const rawPhase = input.phase ?? run?.phase;
+        const phase = canonicalReportPhase(workflow, rawPhase);
         const agent = buildAgentRef(input, run);
         const change = input.change;
         const payloadMode = input.payloadMode ?? 'compact';
         const resolvedRunId = input.runId ?? run?.id;
+        const permissionsPhase = phase === undefined ? undefined : (normalizeSddPhaseInput(phase) ?? phase);
         const report = {
             version: 1,
             kind: 'governance-report',
@@ -44,7 +46,7 @@ export class GovernanceReportBuilder {
             ...(agent === undefined ? {} : { agent }),
             sdd: {},
             permissions: {
-                ...buildPermissionsMode(phase),
+                ...buildPermissionsMode(permissionsPhase),
             },
             openCode: {
                 mode: 'audit-only',
@@ -72,7 +74,8 @@ export class GovernanceReportBuilder {
     tryBuildOptimizedSddSnapshot(report, project, change, phase, payloadMode, warnings) {
         if (this.services.sdd.getGovernanceSnapshot === undefined)
             return false;
-        if (phase !== undefined && !isSddPhase(phase)) {
+        const canonicalPhase = phase === undefined ? undefined : normalizeSddPhaseInput(phase);
+        if (phase !== undefined && canonicalPhase === undefined) {
             warnings.push('sdd-readiness-skipped-non-sdd-phase');
             return false;
         }
@@ -80,7 +83,7 @@ export class GovernanceReportBuilder {
             project,
             change,
             payloadMode,
-            ...(phase === undefined ? {} : { phase }),
+            ...(canonicalPhase === undefined ? {} : { phase: canonicalPhase }),
         });
         if (!snapshot.ok) {
             warnings.push(`sdd-snapshot-unavailable:${snapshot.error.code}`);
@@ -125,8 +128,9 @@ export class GovernanceReportBuilder {
         else {
             warnings.push(`sdd-artifacts-unavailable:${listed.error.code}`);
         }
-        if (phase !== undefined && isSddPhase(phase)) {
-            const readiness = this.services.sdd.getReady({ project, change, phase });
+        const canonicalPhase = phase === undefined ? undefined : normalizeSddPhaseInput(phase);
+        if (canonicalPhase !== undefined) {
+            const readiness = this.services.sdd.getReady({ project, change, phase: canonicalPhase });
             if (readiness.ok) {
                 report.sdd.readiness = readiness.value;
                 for (const blocker of readiness.value.blockedPrerequisites ?? [])
@@ -280,6 +284,13 @@ function buildAgentRef(input, run) {
 function dedupe(values) {
     return [...new Set(values)];
 }
+function canonicalReportPhase(workflow, phase) {
+    if (phase === undefined)
+        return undefined;
+    if (workflow !== undefined && workflow.trim().toLowerCase() !== 'sdd')
+        return phase;
+    return normalizeSddPhaseInput(phase) ?? phase;
+}
 function validationFailure(message) {
     return { ok: false, error: { code: 'validation_failed', message } };
 }

package/dist/mcp/claude-code-agent-config.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join, parse, resolve } from 'node:path';
 import { projectCanonicalAgentManifestToClaudeCode } from '../agents/canonical-agent-projection.js';
 import { assertInsideWorkspace } from './claude-code-config.js';
 export const claudeCodeGeneratedMarker = 'VGXNESS-GENERATED';
@@ -29,10 +29,16 @@ export function resolveClaudeAgentTarget(input) {
     return { workspaceRoot: input.workspaceRoot, scope, directoryPath: join(home, '.claude', 'agents'), ...(input.env === undefined ? {} : { env: input.env }) };
 }
 export function safeHomeDirectory(env = process.env) {
-    const candidate = env.HOME?.trim() || homedir();
-    if (!candidate || candidate === '/' || candidate.includes('\0') || candidate.includes('~'))
+    const homeDrive = env.HOMEDRIVE?.trim();
+    const homePath = env.HOMEPATH?.trim();
+    const homeDrivePath = homeDrive && homePath ? `${homeDrive}${homePath}` : '';
+    const candidate = env.HOME?.trim() || env.USERPROFILE?.trim() || homeDrivePath || homedir();
+    if (!candidate || candidate.startsWith('~') || candidate.includes('\0'))
         throw new Error('Unable to resolve a safe home directory for Claude user agents.');
-    return resolve(candidate);
+    const expanded = resolve(candidate);
+    if (parse(expanded).root === expanded)
+        throw new Error('Unable to resolve a safe home directory for Claude user agents.');
+    return expanded;
 }
 export function isVgxnessOwnedClaudeAgentMarkdown(contents) {
     return contents.includes(claudeCodeGeneratedMarker) && contents.includes('provider=claude') && contents.includes('artifact=claude-code-subagent');

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

@@ -195,10 +195,10 @@ function parseConfig(path) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-export function findConflictingVgxnessAgents(config, agentPlan) {
+export function findConflictingVgxnessAgents(config, agentPlan, input = {}) {
     if (!agentPlan.installsAgents || !isRecord(config.agent))
         return [];
-    const defaults = createOpenCodeDefaultAgentConfig().agents;
+    const defaults = createOpenCodeDefaultAgentConfig(input).agents;
     return agentPlan.agentNames.filter((name) => Object.hasOwn(config.agent, name) && !deepEqual(config.agent[name], defaults[name]));
 }
 function deepEqual(left, right) {

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

@@ -37,36 +37,40 @@ export async function installOpenCodeMcpClient(input) {
             const reparsed = parseConfig(plan.targetPath);
             if (!reparsed.ok)
                 return refusal(reparsed.reason, reparsed.message, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
-            const conflictingAgents = findConflictingVgxnessAgents(reparsed.value, agentPlan);
+            const conflictingAgents = findConflictingVgxnessAgents(reparsed.value, agentPlan, {
+                effectiveManagerInstructions: input.effectiveManagerInstructions,
+            });
             if (conflictingAgents.length > 0 && input.overwriteVgxness !== true)
                 return agentConflictRefusal(conflictingAgents, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan);
             return refusal('unsupported_config_shape', 'OpenCode config appeared after planning; rerun setup apply so it can be merged safely without overwriting user config.', input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
         }
-        writeConfig(plan.targetPath, mergeVgxnessOpenCodeConfig({ $schema: opencodeConfigSchema }, plan.server, plan.installsAgents));
+        writeConfig(plan.targetPath, mergeVgxnessOpenCodeConfig({ $schema: opencodeConfigSchema }, plan.server, plan.installsAgents, input.effectiveManagerInstructions));
         return validateInstalledResult(plan.targetPath, undefined, server, input.databasePath, databasePathSource, applySafety(plan), plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
     }
     const parsed = parseConfig(plan.targetPath);
     if (!parsed.ok)
         return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
-    const conflictingAgents = findConflictingVgxnessAgents(parsed.value, agentPlan);
+    const conflictingAgents = findConflictingVgxnessAgents(parsed.value, agentPlan, {
+        effectiveManagerInstructions: input.effectiveManagerInstructions,
+    });
     if (conflictingAgents.length > 0 && input.overwriteVgxness !== true)
         return agentConflictRefusal(conflictingAgents, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan);
     const backup = createBackup(plan.targetPath, plan.scope);
     if (!backup.ok)
         return refusal('post_write_validation_failed', backup.error.message, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
     const config = parsed.value;
-    const mergedConfig = mergeVgxnessOpenCodeConfig({ ...config, $schema: plan.existingSchema ?? opencodeConfigSchema }, plan.server, plan.installsAgents);
+    const mergedConfig = mergeVgxnessOpenCodeConfig({ ...config, $schema: plan.existingSchema ?? opencodeConfigSchema }, plan.server, plan.installsAgents, input.effectiveManagerInstructions);
     writeConfig(plan.targetPath, mergedConfig);
     return validateInstalledResult(plan.targetPath, backup.value, server, input.databasePath, databasePathSource, applySafety(plan), plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
 }
-function mergeVgxnessOpenCodeConfig(config, server, installsAgents) {
+function mergeVgxnessOpenCodeConfig(config, server, installsAgents, effectiveManagerInstructions) {
     const merged = {
         ...config,
         $schema: typeof config.$schema === 'string' ? config.$schema : opencodeConfigSchema,
         mcp: { ...(isRecord(config.mcp) ? config.mcp : {}), vgxness: server },
     };
     if (installsAgents) {
-        const defaults = createOpenCodeDefaultAgentConfig();
+        const defaults = createOpenCodeDefaultAgentConfig({ effectiveManagerInstructions });
         merged.instructions = mergeOpenCodeInstructions(config.instructions);
         merged.default_agent = defaults.defaultAgent;
         merged.agent = { ...(isRecord(config.agent) ? config.agent : {}), ...defaults.agents };

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';
@@ -43,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),
@@ -96,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':
@@ -238,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)
@@ -346,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/opencode-default-agent-config.js

@@ -1,5 +1,5 @@
-import { projectCanonicalAgentManifestToOpenCode, } from '../agents/canonical-agent-projection.js';
-import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddTaskPermissions, } from '../agents/canonical-agent-manifest.js';
+import { projectCanonicalAgentManifestToOpenCode, withEffectiveOpenCodeManagerInstructions, } from '../agents/canonical-agent-projection.js';
+import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddMcpToolPermissions, createCanonicalOpenCodeSddTaskPermissions, } from '../agents/canonical-agent-manifest.js';
 export const vgxnessOpenCodeDefaultAgent = canonicalDefaultAgentName;
 export const vgxnessOpenCodePromptContractVersion = canonicalPromptContractVersion;
 export const vgxnessOpenCodeInstructionsPath = 'AGENTS.md';
@@ -7,11 +7,14 @@ export const vgxnessOpenCodeSddSubagents = canonicalSddSubagentNames;
 export function createOpenCodeSddTaskPermissions() {
     return createCanonicalOpenCodeSddTaskPermissions();
 }
+export function createOpenCodeSddMcpToolPermissions() {
+    return createCanonicalOpenCodeSddMcpToolPermissions();
+}
 export function createOpenCodeDefaultAgentInstallPlan(input = {}) {
     if (input.mcpOnly === true)
         return { installsAgents: false, agentNames: [] };
     return { installsAgents: true, agentNames: [vgxnessOpenCodeDefaultAgent, ...vgxnessOpenCodeSddSubagents], defaultAgent: vgxnessOpenCodeDefaultAgent };
 }
-export function createOpenCodeDefaultAgentConfig() {
-    return projectCanonicalAgentManifestToOpenCode();
+export function createOpenCodeDefaultAgentConfig(input = {}) {
+    return withEffectiveOpenCodeManagerInstructions(projectCanonicalAgentManifestToOpenCode(), input.effectiveManagerInstructions);
 }