vgxness 1.9.3 → 1.9.5

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

@@ -34,8 +34,9 @@ export function planOpenCodeMcpInstall(input) {
         mcpOnly: input.mcpOnly,
     });
     const overwriteVgxness = input.overwriteVgxness === true;
+    const allowBash = true;
     if (scope === 'user') {
-        return planUserOpenCodeMcpInstall(input, databasePathSource, server, agentPlan, overwriteVgxness);
+        return planUserOpenCodeMcpInstall(input, databasePathSource, server, agentPlan, overwriteVgxness, allowBash);
     }
     const existingTargets = supportedConfigTargets
         .map((relativePath) => ({
@@ -49,35 +50,35 @@ export function planOpenCodeMcpInstall(input) {
                 kind: 'manual-check',
                 message: 'Remove ambiguity by keeping exactly one OpenCode project config target before installing.',
             },
-        ], agentPlan, overwriteVgxness);
+        ], agentPlan, overwriteVgxness, allowBash);
     }
     if (existingTargets.length === 0) {
         return {
-            ...baseContract(input.databasePath, databasePathSource, scope, join(input.cwd, '.opencode', 'opencode.json'), false, 'create', agentPlan, overwriteVgxness),
+            ...baseContract(input.databasePath, databasePathSource, scope, join(input.cwd, '.opencode', 'opencode.json'), false, 'create', agentPlan, overwriteVgxness, allowBash),
             status: 'would_install',
             action: 'create',
             targetPath: join(input.cwd, '.opencode', 'opencode.json'),
             backupRequired: false,
             server,
-            preservedTopLevelKeys: agentPlan.installsAgents ? ['$schema', 'instructions', 'default_agent', 'agent', 'mcp'] : ['$schema', 'mcp'],
+            preservedTopLevelKeys: createdConfigKeys(agentPlan),
             existingSchema: null,
         };
     }
     const [target] = existingTargets;
     if (target === undefined)
-        return refusal('ambiguous_target', 'Unable to resolve OpenCode project config target.', input.databasePath, databasePathSource, scope, undefined, [], undefined, overwriteVgxness);
+        return refusal('ambiguous_target', 'Unable to resolve OpenCode project config target.', input.databasePath, databasePathSource, scope, undefined, [], undefined, overwriteVgxness, allowBash);
     if (target.relativePath.endsWith('.jsonc')) {
-        return refusal('unsupported_jsonc', `OpenCode JSONC config ${target.relativePath} is not supported yet; use JSON or remove comments first.`, input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness);
+        return refusal('unsupported_jsonc', `OpenCode JSONC config ${target.relativePath} is not supported yet; use JSON or remove comments first.`, input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
     }
     const parsed = parseConfig(target.absolutePath);
     if (!parsed.ok)
-        return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness);
+        return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
     const config = parsed.value;
     if (config.mcp !== undefined && !isRecord(config.mcp)) {
-        return refusal('invalid_mcp_shape', 'Existing top-level mcp must be a JSON object before vgxness can be merged.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness);
+        return refusal('invalid_mcp_shape', 'Existing top-level mcp must be a JSON object before vgxness can be merged.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
     }
     if (isRecord(config.mcp) && Object.hasOwn(config.mcp, 'vgxness') && !overwriteVgxness) {
-        return refusal('existing_vgxness_mcp', 'Existing OpenCode config already contains mcp.vgxness; overwrite is refused by default.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness);
+        return refusal('existing_vgxness_mcp', 'Existing OpenCode config already contains mcp.vgxness; overwrite is refused by default.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
     }
     const agentConflict = findConflictingVgxnessAgents(config, agentPlan);
     if (agentConflict.length > 0 && !overwriteVgxness) {
@@ -86,13 +87,16 @@ export function planOpenCodeMcpInstall(input) {
                 kind: 'manual-check',
                 message: `Manually reconcile conflicting VGXNESS agent entries: ${agentConflict.join(', ')}.`,
             },
-        ], agentPlan, overwriteVgxness);
+        ], agentPlan, overwriteVgxness, allowBash);
     }
     if (agentPlan.installsAgents && config.agent !== undefined && !isRecord(config.agent)) {
-        return refusal('unsupported_config_shape', 'Existing top-level agent must be a JSON object before VGXNESS agent entries can be merged or overwritten.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness);
+        return refusal('unsupported_config_shape', 'Existing top-level agent must be a JSON object before VGXNESS agent entries can be merged or overwritten.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
+    }
+    if (config.permission !== undefined && !isRecord(config.permission)) {
+        return refusal('unsupported_config_shape', 'Existing top-level permission must be a JSON object before VGXNESS can set permission.bash to allow by default.', input.databasePath, databasePathSource, scope, target.absolutePath, [], agentPlan, overwriteVgxness, allowBash);
     }
     return {
-        ...baseContract(input.databasePath, databasePathSource, scope, target.absolutePath, true, 'merge-preserve-existing', agentPlan, overwriteVgxness),
+        ...baseContract(input.databasePath, databasePathSource, scope, target.absolutePath, true, 'merge-preserve-existing', agentPlan, overwriteVgxness, allowBash),
         status: 'would_install',
         action: 'merge',
         targetPath: target.absolutePath,
@@ -102,40 +106,40 @@ export function planOpenCodeMcpInstall(input) {
         existingSchema: typeof config.$schema === 'string' ? config.$schema : opencodeConfigSchema,
     };
 }
-function planUserOpenCodeMcpInstall(input, databasePathSource, server, agentPlan, overwriteVgxness) {
+function planUserOpenCodeMcpInstall(input, databasePathSource, server, agentPlan, overwriteVgxness, allowBash) {
     const target = resolveOpenCodeMcpInstallTarget({
         cwd: input.cwd,
         scope: 'user',
         env: input.env,
     });
     if (!target.ok) {
-        return refusal('unsupported_config_shape', target.message, input.databasePath, databasePathSource, 'user', undefined, [], undefined, overwriteVgxness);
+        return refusal('unsupported_config_shape', target.message, input.databasePath, databasePathSource, 'user', undefined, [], undefined, overwriteVgxness, allowBash);
     }
     const jsoncPath = `${target.path}c`;
     if (existsSync(jsoncPath)) {
-        return refusal('unsupported_jsonc', 'OpenCode user JSONC config opencode.jsonc is not supported yet; use JSON or remove comments first.', input.databasePath, databasePathSource, 'user', jsoncPath, [], agentPlan, overwriteVgxness);
+        return refusal('unsupported_jsonc', 'OpenCode user JSONC config opencode.jsonc is not supported yet; use JSON or remove comments first.', input.databasePath, databasePathSource, 'user', jsoncPath, [], agentPlan, overwriteVgxness, allowBash);
     }
     if (!existsSync(target.path)) {
         return {
-            ...baseContract(input.databasePath, databasePathSource, 'user', target.path, false, 'create', agentPlan, overwriteVgxness),
+            ...baseContract(input.databasePath, databasePathSource, 'user', target.path, false, 'create', agentPlan, overwriteVgxness, allowBash),
             status: 'would_install',
             action: 'create',
             targetPath: target.path,
             backupRequired: false,
             server,
-            preservedTopLevelKeys: agentPlan.installsAgents ? ['$schema', 'instructions', 'default_agent', 'agent', 'mcp'] : ['$schema', 'mcp'],
+            preservedTopLevelKeys: createdConfigKeys(agentPlan),
             existingSchema: null,
         };
     }
     const parsed = parseConfig(target.path);
     if (!parsed.ok)
-        return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness);
+        return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness, allowBash);
     const config = parsed.value;
     if (config.mcp !== undefined && !isRecord(config.mcp)) {
-        return refusal('invalid_mcp_shape', 'Existing top-level mcp must be a JSON object before vgxness can be merged.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness);
+        return refusal('invalid_mcp_shape', 'Existing top-level mcp must be a JSON object before vgxness can be merged.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness, allowBash);
     }
     if (isRecord(config.mcp) && Object.hasOwn(config.mcp, 'vgxness') && !overwriteVgxness) {
-        return refusal('existing_vgxness_mcp', 'Existing OpenCode config already contains mcp.vgxness; overwrite is refused by default.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness);
+        return refusal('existing_vgxness_mcp', 'Existing OpenCode config already contains mcp.vgxness; overwrite is refused by default.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness, allowBash);
     }
     const agentConflict = findConflictingVgxnessAgents(config, agentPlan);
     if (agentConflict.length > 0 && !overwriteVgxness) {
@@ -144,13 +148,16 @@ function planUserOpenCodeMcpInstall(input, databasePathSource, server, agentPlan
                 kind: 'manual-check',
                 message: `Manually reconcile conflicting VGXNESS agent entries: ${agentConflict.join(', ')}.`,
             },
-        ], agentPlan, overwriteVgxness);
+        ], agentPlan, overwriteVgxness, allowBash);
     }
     if (agentPlan.installsAgents && config.agent !== undefined && !isRecord(config.agent)) {
-        return refusal('unsupported_config_shape', 'Existing top-level agent must be a JSON object before VGXNESS agent entries can be merged or overwritten.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness);
+        return refusal('unsupported_config_shape', 'Existing top-level agent must be a JSON object before VGXNESS agent entries can be merged or overwritten.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness, allowBash);
+    }
+    if (config.permission !== undefined && !isRecord(config.permission)) {
+        return refusal('unsupported_config_shape', 'Existing top-level permission must be a JSON object before VGXNESS can set permission.bash to allow by default.', input.databasePath, databasePathSource, 'user', target.path, [], agentPlan, overwriteVgxness, allowBash);
     }
     return {
-        ...baseContract(input.databasePath, databasePathSource, 'user', target.path, true, 'merge-preserve-existing', agentPlan, overwriteVgxness),
+        ...baseContract(input.databasePath, databasePathSource, 'user', target.path, true, 'merge-preserve-existing', agentPlan, overwriteVgxness, allowBash),
         status: 'would_install',
         action: 'merge',
         targetPath: target.path,
@@ -195,10 +202,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) {
@@ -213,7 +220,7 @@ function deepEqual(left, right) {
     const rightKeys = Object.keys(right).sort();
     return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && deepEqual(left[key], right[key]));
 }
-function baseContract(databasePath, source, scope, targetPath, backupRequired, mergePolicy, agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false) {
+function baseContract(databasePath, source, scope, targetPath, backupRequired, mergePolicy, agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false, allowBash = true) {
     return {
         version: 1,
         kind: 'mcp-client-install-opencode',
@@ -228,17 +235,18 @@ function baseContract(databasePath, source, scope, targetPath, backupRequired, m
             mergePolicy,
         },
         scope,
-        warnings: warningsForScope(scope, overwriteVgxness, agentPlan),
+        warnings: warningsForScope(scope, overwriteVgxness, agentPlan, allowBash),
         verificationHints: verificationHints(databasePath, source),
         manualTest: manualTestForScope(scope, databasePath, source),
         installsAgents: agentPlan.installsAgents,
         agentNames: agentPlan.agentNames,
         overwriteVgxness,
+        allowBash,
         ...(agentPlan.defaultAgent !== undefined ? { defaultAgent: agentPlan.defaultAgent } : {}),
     };
 }
-function refusal(reason, message, databasePath, source, scope, targetPath, extraVerificationHints = [], agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false) {
-    const contract = baseContract(databasePath, source, scope, targetPath, false, 'refuse-no-clobber', agentPlan, overwriteVgxness);
+function refusal(reason, message, databasePath, source, scope, targetPath, extraVerificationHints = [], agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false, allowBash = true) {
+    const contract = baseContract(databasePath, source, scope, targetPath, false, 'refuse-no-clobber', agentPlan, overwriteVgxness, allowBash);
     return {
         ...contract,
         verificationHints: [...extraVerificationHints, ...contract.verificationHints],
@@ -248,20 +256,26 @@ function refusal(reason, message, databasePath, source, scope, targetPath, extra
         ...(targetPath !== undefined ? { targetPath } : {}),
     };
 }
-function warningsForScope(scope, overwriteVgxness, agentPlan) {
+function warningsForScope(scope, overwriteVgxness, agentPlan, allowBash) {
     const overwriteWarnings = overwriteVgxness
         ? [
             `Reinstall/overwrite is enabled: existing VGXNESS-managed OpenCode entries will be replaced (${agentPlan.installsAgents ? 'mcp.vgxness, default_agent, instructions AGENTS.md, and known VGXNESS agents' : 'mcp.vgxness only'}); unrelated OpenCode config is preserved.`,
         ]
         : [];
+    const bashWarnings = allowBash ? ['OpenCode permission.bash is set to allow by default; terminal commands may run without prompting.'] : [];
     if (scope === 'project')
-        return ['Restart OpenCode after installation so it reloads the project MCP config.', ...overwriteWarnings];
+        return ['Restart OpenCode after installation so it reloads the project MCP config.', ...overwriteWarnings, ...bashWarnings];
     return [
         'Restart OpenCode after installation so it reloads the user MCP config.',
         'OpenCode project config may override user config for a workspace; check project-level config if vgxness is not visible.',
         ...overwriteWarnings,
+        ...bashWarnings,
     ];
 }
+function createdConfigKeys(agentPlan) {
+    const keys = agentPlan.installsAgents ? ['$schema', 'instructions', 'default_agent', 'agent', 'mcp'] : ['$schema', 'mcp'];
+    return [...keys, 'permission'];
+}
 function manualTestForScope(scope, databasePath, source) {
     if (scope === 'project') {
         return {

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

@@ -28,7 +28,7 @@ export async function installOpenCodeMcpClient(input) {
         ...(input.overwriteVgxness !== undefined ? { overwriteVgxness: input.overwriteVgxness } : {}),
     });
     if (!input.confirmed) {
-        return refusal('confirmation_required', confirmationRequiredMessage(plan.scope), input.databasePath, databasePathSource, server, confirmationRequiredSafety(plan), 'targetPath' in plan ? plan.targetPath : undefined, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
+        return refusal('confirmation_required', confirmationRequiredMessage(plan.scope), input.databasePath, databasePathSource, server, confirmationRequiredSafety(plan), 'targetPath' in plan ? plan.targetPath : undefined, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness, plan.allowBash);
     }
     if (plan.status === 'refused')
         return refusalFromPlan(plan, input.databasePath, databasePathSource, server);
@@ -36,41 +36,46 @@ export async function installOpenCodeMcpClient(input) {
         if (existsSync(plan.targetPath)) {
             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);
+                return refusal(reparsed.reason, reparsed.message, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness, plan.allowBash);
+            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);
+                return agentConflictRefusal(conflictingAgents, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.allowBash);
+            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, plan.allowBash);
         }
-        writeConfig(plan.targetPath, mergeVgxnessOpenCodeConfig({ $schema: opencodeConfigSchema }, plan.server, plan.installsAgents));
-        return validateInstalledResult(plan.targetPath, undefined, server, input.databasePath, databasePathSource, applySafety(plan), plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness);
+        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, plan.allowBash);
     }
     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);
+        return refusal(parsed.reason, parsed.message, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness, plan.allowBash);
+    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);
+        return agentConflictRefusal(conflictingAgents, input.databasePath, databasePathSource, server, applySafety(plan), plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.allowBash);
     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);
+        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, plan.allowBash);
     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);
+    return validateInstalledResult(plan.targetPath, backup.value, server, input.databasePath, databasePathSource, applySafety(plan), plan.verificationHints, plan.warnings, plan.manualTest, agentPlan, plan.overwriteVgxness, plan.allowBash);
 }
-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 };
     }
+    merged.permission = { ...(isRecord(config.permission) ? config.permission : {}), bash: 'allow' };
     return merged;
 }
 function mergeOpenCodeInstructions(existing) {
@@ -102,21 +107,25 @@ function createBackup(path, scope) {
         description: 'Backup existing OpenCode config before merging VGXNESS MCP configuration.',
     });
 }
-function validateInstalledResult(targetPath, backup, server, databasePath, source, safety, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness = false) {
+function validateInstalledResult(targetPath, backup, server, databasePath, source, safety, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness = false, allowBash = true) {
     const parsed = parseConfig(targetPath);
     if (!parsed.ok)
-        return refusal('post_write_validation_failed', 'OpenCode config could not be re-read after write.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan);
+        return refusal('post_write_validation_failed', 'OpenCode config could not be re-read after write.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness, allowBash);
     const mcp = parsed.value.mcp;
     const installed = isRecord(mcp) ? mcp.vgxness : undefined;
     if (!isOpenCodeLocalMcpServerConfig(installed)) {
-        return refusal('post_write_validation_failed', 'OpenCode config was written but mcp.vgxness did not validate.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan);
+        return refusal('post_write_validation_failed', 'OpenCode config was written but mcp.vgxness did not validate.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness, allowBash);
     }
     if (agentPlan.installsAgents) {
         const agent = parsed.value.agent;
         if (!isRecord(agent) || parsed.value.default_agent !== agentPlan.defaultAgent || agentPlan.agentNames.some((name) => !isRecord(agent[name]))) {
-            return refusal('post_write_validation_failed', 'OpenCode config was written but VGXNESS agent entries did not validate.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan);
+            return refusal('post_write_validation_failed', 'OpenCode config was written but VGXNESS agent entries did not validate.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness, allowBash);
         }
     }
+    const permission = parsed.value.permission;
+    if (!isRecord(permission) || permission.bash !== 'allow') {
+        return refusal('post_write_validation_failed', 'OpenCode config was written but permission.bash did not validate as allow.', databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness, allowBash);
+    }
     return {
         version: 1,
         kind: 'mcp-client-install-opencode',
@@ -131,6 +140,7 @@ function validateInstalledResult(targetPath, backup, server, databasePath, sourc
         installsAgents: agentPlan.installsAgents,
         agentNames: agentPlan.agentNames,
         overwriteVgxness,
+        allowBash,
         ...(agentPlan.defaultAgent !== undefined ? { defaultAgent: agentPlan.defaultAgent } : {}),
     };
 }
@@ -155,7 +165,7 @@ function isOpenCodeLocalMcpServerConfig(value) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function refusal(reason, message, databasePath, source, server, safety, targetPath, verificationHints = defaultVerificationHints(databasePath, source), warningMessages = warnings(), manualTestGuidance = manualTest(databasePath, source), agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false) {
+function refusal(reason, message, databasePath, source, server, safety, targetPath, verificationHints = defaultVerificationHints(databasePath, source), warningMessages = warnings(), manualTestGuidance = manualTest(databasePath, source), agentPlan = createOpenCodeDefaultAgentInstallPlan({ mcpOnly: true }), overwriteVgxness = false, allowBash = true) {
     return {
         version: 1,
         kind: 'mcp-client-install-opencode',
@@ -171,14 +181,15 @@ function refusal(reason, message, databasePath, source, server, safety, targetPa
         installsAgents: agentPlan.installsAgents,
         agentNames: agentPlan.agentNames,
         overwriteVgxness,
+        allowBash,
         ...(agentPlan.defaultAgent !== undefined ? { defaultAgent: agentPlan.defaultAgent } : {}),
     };
 }
 function refusalFromPlan(plan, databasePath, source, server) {
-    return refusal(plan.reason, plan.message, databasePath, source, server, plan.safety, plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, plan, plan.overwriteVgxness);
+    return refusal(plan.reason, plan.message, databasePath, source, server, plan.safety, plan.targetPath, plan.verificationHints, plan.warnings, plan.manualTest, plan, plan.overwriteVgxness, plan.allowBash);
 }
-function agentConflictRefusal(conflictingAgents, databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan) {
-    return refusal('existing_vgxness_agent', `Existing OpenCode config contains custom VGXNESS agent entries that would be overwritten: ${conflictingAgents.join(', ')}. Remove, rename, or manually reconcile them before installing.`, databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan);
+function agentConflictRefusal(conflictingAgents, databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, allowBash = true) {
+    return refusal('existing_vgxness_agent', `Existing OpenCode config contains custom VGXNESS agent entries that would be overwritten: ${conflictingAgents.join(', ')}. Remove, rename, or manually reconcile them before installing.`, databasePath, source, server, safety, targetPath, verificationHints, warningMessages, manualTestGuidance, agentPlan, false, allowBash);
 }
 function applySafety(plan) {
     return {
@@ -202,7 +213,7 @@ function confirmationRequiredMessage(scope) {
     return `\`mcp install opencode\` requires explicit --yes before any ${scope} config write.`;
 }
 function warnings() {
-    return ['Restart OpenCode after installation so it reloads the project MCP config.'];
+    return ['Restart OpenCode after installation so it reloads the project MCP config.', 'OpenCode permission.bash is set to allow by default; terminal commands may run without prompting.'];
 }
 function manualTest(databasePath, source) {
     return {

package/dist/mcp/control-plane.js

@@ -9,6 +9,7 @@ import { prepareMemoryDatabasePath, resolveMemoryDatabasePath } from '../memory/
 import { OpenCodeManagerPayloadService } from '../providers/opencode/manager-payload.js';
 import { RunService } from '../runs/run-service.js';
 import { sddContinuationPlanFrom } from '../sdd/sdd-continuation-plan.js';
+import { buildSddCockpitSurfaceResponse } from '../sdd/cockpit-read-model.js';
 import { SddWorkflowService } from '../sdd/sdd-workflow-service.js';
 import { SkillRegistryService } from '../skills/skill-registry-service.js';
 import { VerificationPlanService } from '../verification/index.js';
@@ -43,7 +44,7 @@ export function callVgxTool(call, services) {
         case 'vgxness_sdd_next':
             return toEnvelope(validated.tool, services.sdd.getNext(validated.input));
         case 'vgxness_sdd_cockpit':
-            return toEnvelope(validated.tool, services.sdd.getCockpit(validated.input));
+            return toEnvelope(validated.tool, mapMemoryResult(services.sdd.getCockpit(validated.input), buildSddCockpitSurfaceResponse));
         case 'vgxness_sdd_continue':
             return sddContinueEnvelope(validated.input, services);
         case 'vgxness_governance_report':
@@ -405,6 +406,9 @@ function runResumeCandidatesEnvelope(input, services) {
 function toEnvelope(tool, result) {
     return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
 }
+function mapMemoryResult(result, project) {
+    return result.ok ? { ok: true, value: project(result.value) } : result;
+}
 function resolveControlPlaneDatabasePath(options) {
     if (options.databasePath !== undefined)
         return { ok: true, value: options.databasePath };

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

package/dist/mcp/stdio-server.js

@@ -66,7 +66,7 @@ function descriptionForTool(publicToolName) {
     if (publicToolName === 'context_cockpit')
         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.';
+        return 'Read-only SDD cockpit summary with raw compatibility fields plus additive readModel; metadata-only artifact summaries, no artifact bodies, and explicit human acceptance semantics.';
     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);

package/dist/sdd/cockpit-read-model.js

@@ -0,0 +1,192 @@
+import { sddPhases, sddPrerequisites } from './schema.js';
+export class SddCockpitReadModelService {
+    workflow;
+    constructor(workflow) {
+        this.workflow = workflow;
+    }
+    getReadModel(input) {
+        const cockpit = this.workflow.getCockpit(input);
+        if (!cockpit.ok)
+            return cockpit;
+        return { ok: true, value: buildSddCockpitReadModel(cockpit.value) };
+    }
+    getSurfaceResponse(input) {
+        const cockpit = this.workflow.getCockpit(input);
+        if (!cockpit.ok)
+            return cockpit;
+        return { ok: true, value: buildSddCockpitSurfaceResponse(cockpit.value) };
+    }
+}
+export function buildSddCockpitSurfaceResponse(cockpit) {
+    return { ...cockpit, readModel: buildSddCockpitReadModel(cockpit) };
+}
+export function buildSddCockpitReadModel(cockpit) {
+    const phases = cockpit.phases.map((phase) => toPhaseReadModel(phase));
+    const blockers = toReadBlockers(cockpit);
+    const nextAction = chooseNextAction(cockpit, phases);
+    return {
+        project: cockpit.project,
+        change: cockpit.change,
+        phases,
+        nextAction,
+        blockers,
+        guidance: guidanceFor(cockpit, nextAction, blockers),
+        summary: summarize(phases),
+        contentIncluded: false,
+    };
+}
+function toPhaseReadModel(phase) {
+    const status = artifactReadStatus(phase);
+    const contentAvailable = phase.present && phase.artifact !== undefined;
+    const reasons = phase.blockers.map((blocker) => blocker.action ?? blocker.reason);
+    const canAccept = phase.present && !phase.accepted && status === 'draft';
+    const canReview = contentAvailable && status === 'draft';
+    return {
+        phase: phase.phase,
+        label: phaseLabel(phase.phase),
+        topicKey: phase.topicKey,
+        artifact: {
+            exists: phase.present,
+            status,
+            contentAvailable,
+            topicKey: phase.topicKey,
+            ...(phase.artifact?.artifactId === undefined ? {} : { artifactId: phase.artifact.artifactId }),
+            ...(phase.artifact?.createdAt === undefined ? {} : { createdAt: phase.artifact.createdAt }),
+            ...(phase.artifact?.updatedAt === undefined ? {} : { updatedAt: phase.artifact.updatedAt }),
+        },
+        acceptance: {
+            accepted: phase.accepted,
+            acceptedByHuman: phase.artifact?.acceptance?.actor.type === 'human',
+            ...(phase.artifact?.acceptance === undefined ? {} : { acceptance: phase.artifact.acceptance }),
+            requiredForNextPhase: isRequiredForLaterPhase(phase.phase),
+        },
+        actionability: {
+            canGenerate: !phase.present && phase.readiness.ready,
+            canReview,
+            canAccept,
+            canReopen: phase.present && status === 'rejected',
+            blocked: !phase.readiness.ready || phase.blockers.length > 0,
+            reasons,
+        },
+        guidance: guidanceForPhase(phase, status, canAccept),
+    };
+}
+function artifactReadStatus(phase) {
+    if (!phase.present)
+        return 'missing';
+    if (phase.legacy)
+        return 'legacy';
+    const state = phase.state;
+    if (state === 'draft' || state === 'accepted' || state === 'rejected' || state === 'superseded' || state === 'missing')
+        return state;
+    return 'unknown';
+}
+function chooseNextAction(cockpit, phases) {
+    const reviewable = phases.find((phase) => phase.actionability.canReview);
+    if (reviewable !== undefined) {
+        return {
+            kind: 'review-artifact',
+            phase: reviewable.phase,
+            label: `Review ${reviewable.phase} artifact and accept it only after explicit human approval.`,
+            requiresConfirmation: false,
+        };
+    }
+    const generatable = phases.find((phase) => phase.actionability.canGenerate);
+    if (generatable !== undefined) {
+        return {
+            kind: 'generate-artifact',
+            phase: generatable.phase,
+            label: `Generate or create the ${generatable.phase} SDD artifact.`,
+            requiresConfirmation: false,
+        };
+    }
+    if (cockpit.next.status === 'complete') {
+        return { kind: 'none', label: 'All SDD phases are human-accepted.', requiresConfirmation: false };
+    }
+    if (cockpit.next.nextPhase !== undefined) {
+        const nextPhase = phases.find((phase) => phase.phase === cockpit.next.nextPhase);
+        return {
+            kind: 'continue-workflow',
+            phase: cockpit.next.nextPhase,
+            label: safeRecommendedAction(cockpit.recommendedAction, nextPhase),
+            requiresConfirmation: false,
+        };
+    }
+    return { kind: 'none', label: cockpit.recommendedAction, requiresConfirmation: false };
+}
+function safeRecommendedAction(recommendedAction, phase) {
+    if (phase === undefined)
+        return recommendedAction;
+    if (!/accept/i.test(recommendedAction))
+        return recommendedAction;
+    if (phase.artifact.status === 'draft')
+        return recommendedAction;
+    if (phase.artifact.status === 'rejected')
+        return `Reopen the ${phase.phase} artifact before further review.`;
+    if (phase.artifact.status === 'superseded')
+        return `Generate or inspect the current canonical ${phase.phase} artifact; superseded metadata is not actionable.`;
+    if (phase.artifact.status === 'legacy')
+        return `Inspect legacy ${phase.phase} metadata before using it in the current SDD flow.`;
+    return recommendedAction;
+}
+function toReadBlockers(cockpit) {
+    return cockpit.aggregateBlockers.map((blocker) => ({
+        phase: blocker.phase,
+        topicKey: blocker.topicKey,
+        code: blocker.kind,
+        message: blocker.reason,
+        severity: blocker.kind === 'missing-topic-key' ? 'info' : 'blocking',
+        ...(blocker.action === undefined ? {} : { action: blocker.action }),
+        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+    }));
+}
+function summarize(phases) {
+    return {
+        totalPhases: phases.length,
+        presentArtifacts: phases.filter((phase) => phase.artifact.exists).length,
+        acceptedArtifacts: phases.filter((phase) => phase.acceptance.accepted).length,
+        missingArtifacts: phases.filter((phase) => phase.artifact.status === 'missing').length,
+        draftArtifacts: phases.filter((phase) => phase.artifact.status === 'draft').length,
+        rejectedArtifacts: phases.filter((phase) => phase.artifact.status === 'rejected').length,
+        supersededArtifacts: phases.filter((phase) => phase.artifact.status === 'superseded').length,
+        legacyArtifacts: phases.filter((phase) => phase.artifact.status === 'legacy').length,
+        isComplete: phases.length === sddPhases.length && phases.every((phase) => phase.acceptance.accepted),
+    };
+}
+function guidanceFor(cockpit, nextAction, blockers) {
+    const phaseStatusByName = new Map(cockpit.phases.map((phase) => [phase.phase, artifactReadStatus(phase)]));
+    const guidance = [nextAction.label];
+    if (cockpit.phases.some((phase) => artifactReadStatus(phase) === 'draft' && !phase.accepted)) {
+        guidance.push('Artifact presence alone does not count as acceptance; explicit human acceptance is required for drafts.');
+    }
+    if (cockpit.next.blockerGuidance !== undefined) {
+        guidance.push(...cockpit.next.blockerGuidance
+            .filter((blocker) => phaseStatusByName.get(blocker.phase) === 'draft' || !/accept/i.test(blocker.action))
+            .map((blocker) => blocker.action));
+    }
+    return [...new Set(guidance)];
+}
+function guidanceForPhase(phase, status, canAccept) {
+    if (status === 'missing')
+        return [`Create the ${phase.phase} artifact when prerequisites are ready.`];
+    if (canAccept)
+        return [`Review ${phase.topicKey}; accept only after explicit human approval.`];
+    if (status === 'accepted')
+        return ['Accepted artifact metadata is available; full content is omitted from this read model.'];
+    if (status === 'rejected')
+        return ['Rejected artifact metadata is available; reopen it before further review.'];
+    if (status === 'superseded')
+        return ['Superseded artifact metadata is available; generate or inspect the current canonical artifact instead.'];
+    if (status === 'legacy')
+        return ['Legacy artifact metadata requires inspection before it can be used for current SDD flow.'];
+    return phase.blockers.map((blocker) => blocker.action ?? blocker.reason);
+}
+function phaseLabel(phase) {
+    return phase
+        .split('-')
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+}
+function isRequiredForLaterPhase(phase) {
+    return sddPhases.some((candidate) => sddPrerequisites[candidate].includes(phase));
+}

package/dist/sdd/cockpit-types.js

@@ -0,0 +1 @@
+export {};