vgxness 1.9.3 → 1.9.4

package/README.md

@@ -138,7 +138,7 @@ Run the guided setup wizard in a TTY:
 vgxness init
 ```
 
-In non-TTY shells, `vgxness init` prints the same read-only setup plan instead of prompting. For a copyable happy path after installing the package globally:
+In non-TTY shells, `vgxness init` prints the same read-only setup plan instead of prompting. For a copyable bootstrap and diagnostic path after installing the package globally:
 
 ```bash
 vgxness setup plan
@@ -147,6 +147,7 @@ vgxness doctor
 vgxness status --project <project> --change <change>
 vgxness next --project <project> --change <change>
 vgxness sdd continue --project <project> --change <change>
+vgxness code sdd <change> <phase> --project <project> --save-artifact
 ```
 
 Stable defaults are: package `vgxness`, provider `opencode`, global user data DB, user/global OpenCode scope (`$HOME/.config/opencode/opencode.json`), and `mcp-plus-agents` mode. Use `--scope project` only when you intentionally want `<workspace>/.opencode/opencode.json`. The generated MCP command for the global DB default is:
@@ -163,7 +164,7 @@ vgxness setup apply --yes
 
 `vgxness setup plan` and `vgxness setup status` are human-readable and do not write provider config by default; local VGXNESS store initialization may occur when a command needs the selected SQLite store. `vgxness doctor`, `vgxness status`, `vgxness next`, `vgxness sdd status`, `vgxness sdd next`, `vgxness sdd continue`, and `vgxness sdd accept-artifact` are also human-readable by default. Pass `--json` when you need parseable automation output. `vgxness setup apply --yes` is the explicit provider-config write path.
 
-The SDD happy path is `status` -> `next` -> `sdd continue` -> `code sdd` or `resume` -> `accept-artifact` or `reopen-artifact`. `sdd continue`, top-level `status`/`next`, and `resume` are advisory/read-only surfaces; related interrupted run hints and resume candidates help the operator choose the next command but do not execute providers or retry runs. Draft-run suggestions are planning-only: human acceptance is still required, and `apply-progress` remains gated.
+The daily SDD happy path is OpenCode conversation with the installed VGXNESS MCP server and hidden SDD subagents. Use CLI/TUI commands for bootstrap, setup, diagnostics, recovery, fallback, and scripting: `status`, `next`, and `sdd continue` inspect state and print manual fallback guidance; `code sdd` remains available for an explicit manual fallback run; `resume` helps inspect interrupted work. After a draft is ready, `sdd accept-artifact` records explicit human acceptance, and `sdd reopen-artifact` returns rejected artifacts to draft. Draft-run suggestions are planning-only: human acceptance is still required, and `apply-progress` remains gated.
 
 ## Code runtime (`vgxness code`)
 
@@ -182,7 +183,7 @@ Edits, shell, network, git mutations, SDD persistence, and memory saves route th
 
 - Preview, status, and plan commands do not write provider config; local VGXNESS store initialization may occur where the command needs SQLite-backed state.
 - Provider config writes require explicit `--yes` confirmation.
-- Setup/status TUI surfaces are preview-oriented; run copied commands explicitly when you choose to act.
+- Setup/status TUI surfaces are read-only setup, diagnostics, recovery, and fallback surfaces; daily SDD progression stays in OpenCode with VGXNESS MCP.
 - SDD artifacts are SQLite-backed through VGXNESS services. Do not create or write `openspec/`.
 - `vgxness sdd accept-artifact` records explicit human-only acceptance; saving a draft never implies acceptance.
 - `vgxness sdd reopen-artifact` is the explicit path from a rejected artifact back to draft before revision.

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

@@ -2,7 +2,7 @@ import { canonicalBehaviorContractVersion } from '../behavior/behavior-contract-
 export const canonicalDefaultAgentName = 'vgxness-manager';
 export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
 export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 9;
+export const canonicalPromptContractVersion = 10;
 export const canonicalSddSubagentNames = [
     'vgxness-sdd-explore',
     'vgxness-sdd-propose',
@@ -78,13 +78,25 @@ function managerDefinition() {
         builtIn: true,
         name: canonicalDefaultAgentName,
         description: 'Coordinates VGXNESS MCP state and SDD sub-agents while routing Tier 0-2 lightweight work, Tier 3 preflight validation, and Tier 4 formal SDD.',
-        instructions: { kind: 'inline', value: registryManagerInstructionsV9 },
+        instructions: { kind: 'inline', value: registryManagerInstructionsV10 },
         capabilities: ['sdd-orchestration', 'agent-routing', 'mcp-coordination', 'project-local-automation'],
         permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' },
         memory: { scopes: ['project'] },
         workflows: ['explore', 'quickfix', 'plan', 'build', 'debug', 'sdd', 'agent-seeding', 'opencode-install'],
         skills: ['vgxness-sdd-manager'],
-        adapters: { opencode: { model: canonicalOpenCodeDefaultModel, config: { options: { reasoningEffort: canonicalOpenCodeManagerReasoningEffort, vgxnessPromptContractVersion: canonicalPromptContractVersion, vgxnessBehaviorContractVersion: canonicalBehaviorContractVersion }, permission: { task: createCanonicalOpenCodeSddTaskPermissions() } } } },
+        adapters: {
+            opencode: {
+                model: canonicalOpenCodeDefaultModel,
+                config: {
+                    options: {
+                        reasoningEffort: canonicalOpenCodeManagerReasoningEffort,
+                        vgxnessPromptContractVersion: canonicalPromptContractVersion,
+                        vgxnessBehaviorContractVersion: canonicalBehaviorContractVersion,
+                    },
+                    permission: { task: createCanonicalOpenCodeSddTaskPermissions(), ...createCanonicalOpenCodeSddMcpToolPermissions() },
+                },
+            },
+        },
         providerSupport: commonSupport(),
     };
 }
@@ -110,6 +122,19 @@ function subagentDefinition(name) {
 export function createCanonicalOpenCodeSddTaskPermissions() {
     return Object.fromEntries([['*', 'deny'], ...canonicalSddSubagentNames.map((name) => [name, 'allow'])]);
 }
+export function createCanonicalOpenCodeSddMcpToolPermissions() {
+    return {
+        vgxness_sdd_status: 'allow',
+        vgxness_sdd_next: 'allow',
+        vgxness_sdd_ready: 'allow',
+        vgxness_sdd_get_readiness: 'allow',
+        vgxness_sdd_get_artifact: 'allow',
+        vgxness_sdd_list_artifacts: 'allow',
+        vgxness_sdd_cockpit: 'allow',
+        vgxness_agent_resolve: 'allow',
+        vgxness_sdd_save_artifact: 'allow',
+    };
+}
 export function createCanonicalOpenCodeSddSubagentPrompt(name) {
     const phase = name.replace('vgxness-sdd-', '');
     const common = `You are the VGXNESS SDD ${phase} executor, not the orchestrator. Do this phase's work yourself. Do NOT delegate, do NOT call task/delegate, and do NOT launch sub-agents. Use provided SDD artifacts, VGXNESS MCP state, and local repository evidence as needed. Retrieve full artifact content through MCP when the phase requires it; do not expect the manager to paste verbose artifacts into your prompt. Do not depend on external local skill files; this inline contract is sufficient. Preserve unrelated user work, keep output concise, and report evidence.`;
@@ -132,7 +157,7 @@ Coordinate SDD; keep chat thin, use VGXNESS MCP as durable state, delegate to th
 - SDD artifact acceptance is human-only. Never infer or fabricate acceptance from generated output, subagent/model output, file presence, confidence, or legacy artifacts. Treat draft/rejected/superseded/stale/unaccepted artifacts as not accepted until a human acceptance record exists.
 - Before phase advancement, call readiness/status tools: \`vgxness_sdd_status\`/\`vgxness_sdd_next\` and \`vgxness_sdd_ready\` or \`vgxness_sdd_get_readiness\`.
 - Before risky VGX-managed side effects (edit, shell/tests, git, network, provider-tool, secrets, external-directory, destructive, privileged, ambiguous), call \`vgxness_run_preflight\` with runId/workflow/phase/agent context when available. If approval/block is required, stop; do not invent approval.
-- Direct human acceptance of an exact SDD artifact via \`vgxness_sdd_accept_artifact\` is not a generic SDD write for manager routing: do not call \`vgxness_run_preflight\` solely for that acceptance when the user explicitly accepted the exact project/change/phase artifact, \`acceptedBy.type\` is \`"human"\`, \`acceptedBy.id\` is non-empty, and status/readiness confirms the artifact is eligible. This shortcut applies only to \`vgxness_sdd_accept_artifact\`, not \`vgxness_sdd_save_artifact\`, edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
+- Direct human acceptance of an exact SDD artifact via \`vgxness_sdd_accept_artifact\` is not a generic SDD write for manager routing: do not call \`vgxness_run_preflight\` solely for that acceptance when the user explicitly accepted the exact project/change/phase artifact, \`acceptedBy.type\` is \`"human"\`, \`acceptedBy.id\` is non-empty, and status/readiness confirms the artifact is eligible. This shortcut applies only to \`vgxness_sdd_accept_artifact\` and the trusted draft autorun chain described below; it does not apply to edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
 - OpenCode native/provider tools are governance-v1 audit-only/non-hard-blocking. Report warnings; do not say native OpenCode tools are hard-blocked by config.
 - Do not mutate provider/global OpenCode config. Do not write to \`openspec/\`. Do not publish packages unless explicitly requested. Never revert/overwrite unrelated user work. Preserve \`permission.task\` deny-by-default with only exact known SDD subagents allowed.
 - Do not change provider model/reasoning config unless explicitly requested.
@@ -146,6 +171,7 @@ Daily SDD happens inside OpenCode through conversation, VGXNESS MCP, and hidden
 ## MCP playbook
 - For starting, resuming, or recovering context: prefer \`vgxness_context_cockpit\`; treat \`vgxness_session_restore\` as one signal, not truth. For ending, pausing, handing off, or compacting: \`vgxness_session_close\` with current session id and actor \`manager\`; if no id, do not invent one and summarize.
 - SDD artifacts: guide state with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; list/read with \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`; prefer \`payloadMode: "compact"\` so the primary context stays clean; use verbose only when required, preferably inside the delegated phase subagent. Save with \`vgxness_sdd_save_artifact\` only after the appropriate flow. Use \`vgxness_sdd_reopen_artifact\` only for rejected artifacts returning to draft, with explicit human actor/audit context. SDD artifacts are not generic memory.
+- Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, you may run exactly \`spec -> design -> tasks\` without extra human confirmation via exact hidden subagents and save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Do not use for explore/proposal/apply-progress/verify/archive, rejected/superseded artifacts, accepted overwrites, or risky side effects (provider config, edits, shell/tests, git, secrets, external/destructive/privileged/ambiguous). Re-check status/readiness before and after; generated spec/design drafts may feed downstream design/tasks but remain unaccepted.
 - Acceptance/readiness: check SDD status/readiness for the exact project/change/phase, confirm explicit human acceptance of that exact artifact, call \`vgxness_sdd_accept_artifact\` directly with audit context (\`acceptedBy.type: "human"\`, non-empty \`acceptedBy.id\`, runId, agentId), then re-check status/readiness before reporting state. Do not add \`vgxness_run_preflight\` solely for that exact direct acceptance call. Ambiguous replies count only when tied to an immediate exact acceptance prompt. Use \`vgxness_governance_report\` for readiness, artifact states, preflight posture, and audit warnings.
 - Memory: call \`vgxness_memory_search\`/\`vgxness_memory_get\` for prior work or unclear context; call \`vgxness_memory_save\` for durable discoveries, decisions, bug fixes, config, patterns, or preferences; use \`vgxness_memory_update\` only to correct/evolve a known id. Do not duplicate full SDD artifacts as memory.
 - Agents/profile/payloads: resolve exact phase with \`vgxness_agent_resolve\`. \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, and \`vgxness_skill_payload\` are preview context only; agent_activate does not execute a provider or write provider config. Use \`vgxness_manager_profile_get\` before behavior changes; \`vgxness_manager_profile_set\` requires explicit human authorization.
@@ -154,7 +180,7 @@ Daily SDD happens inside OpenCode through conversation, VGXNESS MCP, and hidden
 
 ## Minimum flows
 - Simple answer: inline; memory only for prior context; no run by default.
-- Proposal/spec/design/tasks: status/next -> readiness -> prerequisites -> exact subagent -> delegate -> persist by governance.
+- Proposal/spec/design/tasks: status/next -> readiness -> prerequisites -> exact subagent -> delegate -> persist by governance; if proposal is accepted, spec/design/tasks may run as the trusted draft autorun chain without extra confirmation, but drafts remain unaccepted.
 - Apply/verify: require prerequisites -> artifacts -> exact subagent -> start/recover run -> preflight writes/shell/git/tests -> delegate -> checkpoint -> save -> finalize.
 - Config/provider/prompt change: inspect manager/profile or payload first; persistent changes need explicit human authorization.
 - Recovery: MCP first. Continue: use \`vgxness_sdd_continue\`; read-only/advisory: no provider execution, run creation, artifact mutation, provider config/openspec writes, or acceptance/apply-progress bypass. CLI \`vgxness sdd continue\` is human fallback only. \`vgxness resume --project\` is for candidate runs; \`vgxness code sdd ... --draft-run\` is a planning-only path, never for apply-progress.
@@ -170,10 +196,10 @@ Be concise: delegated work, results, files/decisions, evidence/tests, risks, nex
  * render baselines, and manager profile overlay baselines; they are
  * intentionally distinct from the provider runtime prompt above.
  */
-const registryManagerInstructionsV9 = [
+const registryManagerInstructionsV10 = [
     'You are the VGXNESS SDD coordinator, not a monolithic executor. Coach briefly while coordinating: explain useful tradeoffs, be realistic about risks and unknowns, respectfully challenge weak assumptions with better options, keep the user comfortable and in control, and stay concise.',
     'Use VGXNESS MCP as the durable control plane: restore session context with vgxness_session_restore before inferring start/resume state from chat, and close/pause/compact with vgxness_session_close using actor manager plus an actionable summary when a current session id exists.',
-    'Check SDD status/next/ready/cockpit, read prerequisites with sdd_get_artifact or sdd_list_artifacts, use public sdd_continue/internal vgxness_sdd_continue first for advisory read-only continuation plans, use sdd_reopen_artifact only for rejected artifacts returning to draft with explicit human actor/audit context, save accepted phase output with sdd_save_artifact, search/get/save/update memory only for reusable knowledge, resolve exact SDD subagents before substantial phase work, use runs/checkpoints/preflight/finalize for significant implementation or verification, use run_resume_candidates for unknown runId, inspect interrupted runs by runId with run_resume_inspect, then call run_resume_gate with approvalId from pendingApprovals/inspect; never pass runId as approvalId; use vgxness_provider_status for configured/phase/next questions plus vgxness_provider_doctor for read-only OpenCode MCP/manager health.',
+    'Check SDD status/next/ready/cockpit, read prerequisites with sdd_get_artifact or sdd_list_artifacts, use public sdd_continue/internal vgxness_sdd_continue first for advisory read-only continuation plans, use sdd_reopen_artifact only for rejected artifacts returning to draft with explicit human actor/audit context, save phase output with sdd_save_artifact only by governance; when proposal is accepted, spec/design/tasks may run sequentially as draft-only autorun without extra confirmation, while acceptance remains human-only. Search/get/save/update memory only for reusable knowledge, resolve exact SDD subagents before substantial phase work, use runs/checkpoints/preflight/finalize for significant implementation or verification, use run_resume_candidates for unknown runId, inspect interrupted runs by runId with run_resume_inspect, then call run_resume_gate with approvalId from pendingApprovals/inspect; never pass runId as approvalId; use vgxness_provider_status for configured/phase/next questions plus vgxness_provider_doctor for read-only OpenCode MCP/manager health.',
     'Prefer payloadMode=compact for manager-facing status/context reads, SDD artifact reads/lists, and activation handoffs so the primary context stays clean; request payloadMode=verbose only when full artifact contents, provider payloads, or skill context are actually needed, preferably inside delegated phase subagents.',
     'MCP sdd_continue must not execute providers, create runs, mutate artifacts, write provider config/openspec, bypass human acceptance, or treat draft-run as apply-progress.',
     'CLI is an escape hatch for bootstrap, doctor, rollback, recovery, MCP unavailable/setup missing, or explicit user request; do not tell users to run terminal SDD phase commands for normal daily flow. CLI vgxness sdd continue is a human/manual fallback only; vgxness resume --project is for candidate runs, and vgxness code sdd ... --draft-run is planning-only.',
@@ -183,8 +209,8 @@ const subagentData = {
     'vgxness-sdd-explore': { seedDescription: 'Investigates codebase context and identifies options before proposals.', seedInstructions: 'You are the explore phase executor, not the orchestrator. Do not delegate. Explore repository evidence for the requested SDD change. Do not implement code changes. Return concise findings, risks, and recommended next artifacts.', capabilities: ['sdd-exploration', 'codebase-research', 'discovery'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:explore'], skills: ['vgxness-sdd-explore'], phaseContract: 'Investigate codebase context, constraints, options, and risks. Do not implement code changes. Return findings and recommended next artifacts.' },
     'vgxness-sdd-propose': { seedDescription: 'Creates focused change proposals from exploration findings.', seedInstructions: 'You are the proposal phase executor, not the orchestrator. Do not delegate. Create a focused SDD proposal from exploration evidence. Do not implement code changes. Identify scope, tradeoffs, non-goals, and acceptance direction.', capabilities: ['sdd-proposal', 'proposal-planning', 'scope-definition'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:proposal'], skills: ['vgxness-sdd-proposal'], phaseContract: 'Create or refine a focused SDD proposal from exploration evidence. Do not implement code changes. Include scope, tradeoffs, non-goals, and acceptance direction.' },
     'vgxness-sdd-spec': { seedDescription: 'Writes detailed requirements and acceptance criteria for SDD changes.', seedInstructions: 'You are the spec phase executor, not the orchestrator. Do not delegate. Write a detailed SDD specification with requirements, acceptance criteria, edge cases, and out-of-scope items. Do not implement code changes.', capabilities: ['sdd-specification', 'requirements', 'acceptance-criteria'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:spec'], skills: ['vgxness-sdd-spec'], phaseContract: 'Write requirements, acceptance criteria, edge cases, and out-of-scope items. Do not implement code changes.' },
-    'vgxness-sdd-design': { seedDescription: 'Creates technical design from approved specs and proposals.', seedInstructions: 'You are the design phase executor, not the orchestrator. Do not delegate. Create a technical design grounded in the repository. Identify affected modules, data shapes, risks, rollout, and verification strategy. Do not implement code changes.', capabilities: ['sdd-design', 'technical-design', 'architecture-planning'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:design'], skills: ['vgxness-sdd-design'], phaseContract: 'Create technical design grounded in the repository: affected modules, data shapes, safety, rollout, and verification. Do not implement code changes.' },
-    'vgxness-sdd-tasks': { seedDescription: 'Breaks specs and designs into implementation tasks.', seedInstructions: 'You are the tasks phase executor, not the orchestrator. Do not delegate. Break the SDD spec/design into small, ordered, testable implementation tasks. Do not implement code changes.', capabilities: ['sdd-tasks', 'task-breakdown', 'implementation-planning'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:tasks'], skills: ['vgxness-sdd-tasks'], phaseContract: 'Break approved spec/design into small ordered testable implementation tasks. Do not implement code changes.' },
+    'vgxness-sdd-design': { seedDescription: 'Creates technical design from accepted proposals and accepted or trusted draft specs.', seedInstructions: 'You are the design phase executor, not the orchestrator. Do not delegate. Create a technical design grounded in the repository. Identify affected modules, data shapes, risks, rollout, and verification strategy. Do not implement code changes.', capabilities: ['sdd-design', 'technical-design', 'architecture-planning'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:design'], skills: ['vgxness-sdd-design'], phaseContract: 'Create technical design grounded in the repository: affected modules, data shapes, safety, rollout, and verification. You may use an accepted spec or a trusted draft spec produced in the manager autorun chain. Do not implement code changes.' },
+    'vgxness-sdd-tasks': { seedDescription: 'Breaks accepted or trusted draft specs and designs into implementation tasks.', seedInstructions: 'You are the tasks phase executor, not the orchestrator. Do not delegate. Break the SDD spec/design into small, ordered, testable implementation tasks. Do not implement code changes.', capabilities: ['sdd-tasks', 'task-breakdown', 'implementation-planning'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:tasks'], skills: ['vgxness-sdd-tasks'], phaseContract: 'Break accepted or trusted draft spec/design into small ordered testable implementation tasks. Do not implement code changes.' },
     'vgxness-sdd-apply': { seedDescription: 'Implements code changes from SDD task definitions.', seedInstructions: 'You are the apply phase executor, not the orchestrator. Implement only the assigned SDD tasks directly. Do not delegate. Keep changes small, preserve unrelated user work, run focused checks when authorized, and report changed files plus verification evidence.', capabilities: ['sdd-apply', 'implementation', 'code-change'], permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:apply-progress'], skills: ['vgxness-sdd-apply'], phaseContract: 'Implement only assigned SDD tasks. Preserve unrelated dirty files and user work. Use focused tests when authorized. Report changed files, tests/evidence, and residual risks.' },
     'vgxness-sdd-verify': { seedDescription: 'Validates implementation against specs, tasks, and evidence.', seedInstructions: 'You are the verify phase executor, not the orchestrator. Do not delegate. Verify the implementation against SDD artifacts. Prefer focused local tests, inspect evidence, and report residual risk. Do not implement unrelated changes.', capabilities: ['sdd-verify', 'verification', 'test-review', 'risk-review'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:verify'], skills: ['vgxness-sdd-verify'], phaseContract: 'Validate implementation against SDD artifacts and task acceptance criteria. Prefer focused local tests and evidence review. Do not implement unrelated changes.' },
     'vgxness-sdd-archive': { seedDescription: 'Archives completed SDD change artifacts and outcomes.', seedInstructions: 'You are the archive phase executor, not the orchestrator. Do not delegate. Archive completed SDD artifacts and summarize final outcome, verification, and follow-ups. Confirm before writes beyond the requested archive artifact.', capabilities: ['sdd-archive', 'artifact-archive', 'release-notes'], permissions: { read: 'allow', edit: 'ask', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:archive'], skills: ['vgxness-sdd-archive'], phaseContract: 'Archive completed SDD outcome with summary, verification evidence, follow-ups, and residual risks. Confirm before any repository writes beyond the requested archive artifact.' },

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

@@ -44,6 +44,21 @@ export function projectCanonicalAgentManifestToOpenCode(manifest = canonicalAgen
     }
     return { defaultAgent: canonicalDefaultAgentName, agents };
 }
+export function withEffectiveOpenCodeManagerInstructions(projection, instructions) {
+    const trimmed = instructions?.trim() ?? '';
+    if (trimmed === '')
+        return projection;
+    const manager = projection.agents[projection.defaultAgent];
+    if (manager === undefined)
+        return projection;
+    return {
+        defaultAgent: projection.defaultAgent,
+        agents: {
+            ...projection.agents,
+            [projection.defaultAgent]: { ...manager, prompt: trimmed },
+        },
+    };
+}
 export function projectCanonicalAgentManifestToClaudeCode(manifest = canonicalAgentManifest) {
     assertValidCanonicalManifest(manifest);
     const manager = manifest.agents.find((agent) => agent.name === manifest.defaultAgentName && agent.mode === 'agent');

package/dist/cli/commands/mcp-dispatcher.js

@@ -75,25 +75,56 @@ export function runMcpInstallCommand(parsed, environment) {
                 }),
             });
         }
-        const result = await installOpenCodeMcpClient({
-            cwd: environment.cwd,
-            databasePath: databasePath.value.path,
-            databasePathSource: databasePath.value.source,
-            scope: scope.value,
-            env: environment.env,
-            confirmed: parsed.flags.yes === true,
-            mcpOnly,
-            overwriteVgxness,
-        });
-        return result.status === 'installed'
-            ? jsonResult({ ok: true, value: result })
-            : resultFailure({
-                ok: false,
-                error: {
-                    code: 'validation_failed',
-                    message: `${result.reason}: ${result.message} Manual doctor command: ${result.manualTest.doctorCommand.join(' ')}`,
-                },
+        if (parsed.flags.yes !== true) {
+            const result = await installOpenCodeMcpClient({
+                cwd: environment.cwd,
+                databasePath: databasePath.value.path,
+                databasePathSource: databasePath.value.source,
+                scope: scope.value,
+                env: environment.env,
+                confirmed: false,
+                mcpOnly,
+                overwriteVgxness,
             });
+            return result.status === 'installed'
+                ? jsonResult({ ok: true, value: result })
+                : resultFailure({
+                    ok: false,
+                    error: {
+                        code: 'validation_failed',
+                        message: `${result.reason}: ${result.message} Manual doctor command: ${result.manualTest.doctorCommand.join(' ')}`,
+                    },
+                });
+        }
+        const opened = openCliDatabase(databasePath.value.path);
+        if (!opened.ok)
+            return resultFailure(opened);
+        try {
+            const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value);
+            const result = await installOpenCodeMcpClient({
+                cwd: environment.cwd,
+                databasePath: databasePath.value.path,
+                databasePathSource: databasePath.value.source,
+                scope: scope.value,
+                env: environment.env,
+                confirmed: true,
+                mcpOnly,
+                overwriteVgxness,
+                ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+            });
+            return result.status === 'installed'
+                ? jsonResult({ ok: true, value: result })
+                : resultFailure({
+                    ok: false,
+                    error: {
+                        code: 'validation_failed',
+                        message: `${result.reason}: ${result.message} Manual doctor command: ${result.manualTest.doctorCommand.join(' ')}`,
+                    },
+                });
+        }
+        finally {
+            opened.value.close();
+        }
     })();
 }
 function claudeInstallScopeFlag(flags) {

package/dist/cli/commands/setup-dispatcher.js

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 import { AgentRegistryService } from '../../agents/agent-registry-service.js';
+import { computeEffectiveManagerInstructions } from '../../agents/manager-profile-overlay-service.js';
 import { resolveAgentProfileModel } from '../../agents/profile-model-routing.js';
 import { installOpenCodeMcpClient } from '../../mcp/client-install-opencode.js';
 import { createMcpClientSetupPreview } from '../../mcp/client-setup-preview.js';
@@ -144,16 +145,27 @@ export async function applySetupPlanInput(input, environment) {
                 plan: plan.value,
             },
         };
-    const result = await installOpenCodeMcpClient({
-        cwd: environment.cwd,
-        databasePath: plan.value.db.path,
-        databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
-        scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
-        env: environment.env,
-        confirmed: true,
-        mcpOnly: input.installMode === 'mcp-only',
-        ...(input.overwriteVgxness === undefined ? {} : { overwriteVgxness: input.overwriteVgxness }),
-    });
+    const opened = openCliDatabase(plan.value.db.path);
+    if (!opened.ok)
+        return opened;
+    let result;
+    try {
+        const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value, input.project);
+        result = await installOpenCodeMcpClient({
+            cwd: environment.cwd,
+            databasePath: plan.value.db.path,
+            databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
+            scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
+            env: environment.env,
+            confirmed: true,
+            mcpOnly: input.installMode === 'mcp-only',
+            ...(input.overwriteVgxness === undefined ? {} : { overwriteVgxness: input.overwriteVgxness }),
+            ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+        });
+    }
+    finally {
+        opened.value.close();
+    }
     return result.status === 'installed'
         ? {
             ok: true,

package/dist/cli/product-status-renderer.js

@@ -1,4 +1,5 @@
 export function renderProductStatus(status) {
+    const commandHeading = productCommandHeading(status);
     const lines = [
         'Status',
         ...status.status.map((line) => `- ${line}`),
@@ -9,7 +10,7 @@ export function renderProductStatus(status) {
         'Next',
         ...status.next.map((line) => `- ${line}`),
         '',
-        'Command',
+        commandHeading,
         `- ${status.command}`,
         '',
         ...(status.relatedRunContext === undefined ? [] : relatedRunContextLines(status.relatedRunContext, true)),
@@ -43,6 +44,7 @@ function buildBlockedNextCommand(status) {
     return `vgxness next --project ${status.project.value} --change ${change}${dbHint}`;
 }
 export function renderProductNext(next) {
+    const commandHeading = next.blocked ? 'Recovery/diagnostic command' : 'Manual fallback command';
     const lines = [
         'Next',
         ...next.next.map((line) => `- ${line}`),
@@ -51,7 +53,7 @@ export function renderProductNext(next) {
         ...next.why.map((line) => `- ${line}`),
         ...(next.blockers.length === 0 ? [] : ['', 'Blockers', ...next.blockers.map((line) => `- ${line}`)]),
         '',
-        'Command',
+        commandHeading,
         `- ${next.command}`,
         '',
         ...(next.relatedRunContext === undefined ? [] : relatedRunContextLines(next.relatedRunContext, true)),
@@ -60,6 +62,11 @@ export function renderProductNext(next) {
     ];
     return `${lines.join('\n')}\n`;
 }
+function productCommandHeading(status) {
+    if (status.sddNextStatus === 'runnable')
+        return 'Manual fallback command';
+    return 'Recovery/diagnostic command';
+}
 function relatedRunContextLines(relatedRunContext, includeTrailingBlank) {
     return [
         'Related interrupted run:',

package/dist/cli/sdd-renderer.js

@@ -10,7 +10,8 @@ export function renderSddStatus(input) {
         ? 'No next SDD phase remains for this change.'
         : input.status.nextReadyPhase === undefined
             ? 'Review blockers or accept present draft artifacts before continuing.'
-            : `Run or draft the ${input.status.nextReadyPhase} phase with ${directPhaseCommand}.`;
+            : `Continue the ${input.status.nextReadyPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`;
+    const commandLabel = directPhaseCommand === undefined ? 'Diagnostic command' : 'Manual fallback command';
     const lines = [
         'SDD Status',
         `Project: ${input.project}`,
@@ -28,7 +29,7 @@ export function renderSddStatus(input) {
         ...(missing.length === 0 ? ['- none'] : missing.map((topicKey) => `- ${topicKey}`)),
         '',
         `Recommended action: ${recommendedAction}`,
-        `Command: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
+        `${commandLabel}: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
         `JSON: vgxness sdd status --project ${input.project} --change ${input.status.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
@@ -40,6 +41,10 @@ export function renderSddNext(input) {
     const commandGuidance = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
         ? `vgxness code sdd ${input.decision.change} ${input.decision.nextPhase} --save-artifact`
         : `vgxness sdd status --project ${input.project} --change ${input.decision.change}`;
+    const commandLabel = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined ? 'Manual fallback command' : 'Diagnostic command';
+    const primaryAction = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
+        ? `Continue the ${input.decision.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`
+        : input.decision.recommendedAction;
     const lines = [
         'SDD Next',
         `Project: ${input.project}`,
@@ -64,13 +69,14 @@ export function renderSddNext(input) {
         'Next actions:',
         ...(guidance.length === 0 ? ['- none'] : guidance.map((item) => `- ${item.phase}: ${item.action}`)),
         '',
-        `Recommended action: ${input.decision.recommendedAction}`,
-        `Command: ${commandGuidance}`,
+        `Recommended action: ${primaryAction}`,
+        `${commandLabel}: ${commandGuidance}`,
         `JSON: vgxness sdd next --project ${input.project} --change ${input.decision.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
 export function renderSddContinuationPlan(plan) {
+    const suggestedCommandLabel = plan.status === 'runnable' ? 'Manual fallback command' : 'Diagnostic command';
     const lines = [
         'SDD Continue (read-only)',
         `Project: ${plan.project}`,
@@ -81,17 +87,17 @@ export function renderSddContinuationPlan(plan) {
         `Reason: ${plan.reason}`,
         '',
         'Recommended plan:',
-        `- ${plan.recommendedAction}`,
-        `- Suggested command: ${plan.suggestedCommand}`,
-        `- Inspect command: ${plan.inspectCommand}`,
+        `- ${plan.status === 'runnable' && plan.nextPhase !== undefined ? `Continue the ${plan.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.` : plan.recommendedAction}`,
+        `- ${suggestedCommandLabel}: ${plan.suggestedCommand}`,
+        `- Diagnostic command: ${plan.inspectCommand}`,
         '',
         'Blocker-specific next actions:',
         ...(plan.blockerActions.length === 0
             ? ['- none']
             : plan.blockerActions.map((item) => {
-                const draftRun = item.draftRunCommand === undefined ? '' : `; draftRunCommand=${item.draftRunCommand}`;
+                const draftRun = item.draftRunCommand === undefined ? '' : `; manualFallbackCommand=${item.draftRunCommand}`;
                 const warning = item.warning === undefined ? '' : `; warning=${item.warning}`;
-                return `- ${item.phase}: ${item.action}; command=${item.command}${draftRun}${warning}`;
+                return `- ${item.phase}: ${item.action}; recoveryCommand=${item.command}${draftRun}${warning}`;
             })),
         '',
         ...(plan.relatedRunContext === undefined

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/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/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/status/product-status.js

@@ -82,7 +82,11 @@ function fromSddCockpit(cockpit, project, baseSafety, relatedRunContext) {
         blockers: cockpit.aggregateBlockers.length === 0
             ? ['none']
             : cockpit.aggregateBlockers.map((blocker) => `${blocker.phase}: ${blocker.reason} at ${blocker.topicKey}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`),
-        next: [cockpit.recommendedAction],
+        next: [
+            cockpit.next.status === 'runnable' && cockpit.next.nextPhase !== undefined
+                ? `Continue the ${cockpit.next.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`
+                : cockpit.recommendedAction,
+        ],
         command,
         sddNextStatus: cockpit.next.status,
         ...(relatedRunContext === undefined ? {} : { relatedRunContext }),

package/docs/cli.md

@@ -49,7 +49,7 @@ Release defaults used by the guided setup are:
 - Install mode: MCP plus manager/SDD agents (`mcp-plus-agents`).
 - Public CLI language: English.
 
-Recommended user flow after `npm install -g vgxness`:
+Recommended bootstrap and diagnostic flow after `npm install -g vgxness`:
 
 ```bash
 vgxness --help
@@ -59,30 +59,33 @@ vgxness setup plan           # human-readable, read-only plan
 vgxness setup status         # human-readable, read-only setup status
 vgxness setup apply --yes    # writes OpenCode config only after explicit consent
 vgxness doctor               # human-readable readiness checks
-vgxness status --project <project> --change <change>
-vgxness next --project <project> --change <change>
+vgxness status --project <project> --change <change>   # diagnostic cockpit
+vgxness next --project <project> --change <change>     # diagnostic/recovery next step
+vgxness sdd continue --project <project> --change <change> # read-only manual continuation plan
 vgxness resume --project <project> --run-id <id>
 vgxness setup rollback --backup <path>
 ```
 
+Daily SDD phase progression is OpenCode-first: talk to OpenCode with the VGXNESS MCP server installed, and let the hidden SDD subagents use MCP tools for phase work. The CLI and TUI remain supported for bootstrap/setup, diagnostics, recovery, manual fallback, and scripting; they are not the primary daily surface.
+
 `setup plan`, `setup status`, and non-TTY `init` planning do not write provider config. Local VGXNESS store initialization may occur when the selected SQLite store is needed. They are human-readable by default; pass `--json` when you need parseable automation output. With the default global database, the OpenCode MCP command is `vgxness mcp start`; for custom/project-local DBs it includes `--db <path>`. The default OpenCode target is `$HOME/.config/opencode/opencode.json`; pass `--scope project` to opt into `<workspace>/.opencode/opencode.json`. `setup apply --yes` is the explicit OpenCode provider-config write path. `setup rollback --backup <path>` validates a VGXNESS/OpenCode backup such as `opencode.json.backup-<timestamp>`, creates a pre-rollback backup of the current target when present, restores the selected backup byte-for-byte, and recommends `vgxness doctor`.
 
 `vgxness init` prompts in English when stdin/stdout are TTYs: project name, DB location, provider, OpenCode scope, install mode, then shows the plan and asks `Apply this setup? Type "yes" to continue:`. Any answer other than `yes` exits successfully without writes. In CI/non-TTY without `--yes`, `init` returns the read-only plan and never waits for input. `vgxness doctor`, `vgxness sdd status`, `vgxness sdd next`, `vgxness sdd get-artifact`, and `vgxness sdd list-artifacts` are also human-readable by default; use `--json` for scripts.
 
 ## Daily workflow front doors
 
-Use these top-level commands before dropping into lower-level SDD or run inspection commands:
+Use OpenCode conversation + VGXNESS MCP + hidden SDD subagents for normal daily SDD work. Use these top-level commands when you need diagnostics, recovery, manual fallback, or scriptable state inspection:
 
 | Question | Command | Purpose |
 |---|---|---|
-| Where am I? | `vgxness status --project <project> --change <change>` | Shows the SDD cockpit state, blockers, next recommendation, and safety notes. |
-| What should I do now? | `vgxness next --project <project> --change <change>` | Narrows the cockpit to the next action and why it is safe or blocked. |
-| How do I continue a change? | `vgxness sdd continue --project <project> --change <change>` | Builds a read-only continuation plan for the selected SDD change. |
+| Where am I? | `vgxness status --project <project> --change <change>` | Diagnostic cockpit state, blockers, next recommendation, and safety notes. |
+| What should I do now? | `vgxness next --project <project> --change <change>` | Recovery/diagnostic next action and why it is safe or blocked. |
+| How do I continue a change manually? | `vgxness sdd continue --project <project> --change <change>` | Builds a read-only continuation plan and manual fallback commands for the selected SDD change. |
 | How do I continue interrupted work? | `vgxness resume --project <project> [--run-id <id>]` | Lists or inspects interrupted runs and suggests manual continuation commands without retrying anything. |
 
 Without `--change`, `--project`, or `--run-id`, these commands stay orientation-only and do not open the local memory store. With a selected change, project, or run, top-level `status`, `next`, and `resume` inspect SQLite read-only; formal `sdd` commands are non-provider, non-run-executing planning/artifact commands that may use the normal local store path. Pass `--json` for automation.
 
-The usual SDD operator loop is: inspect `status`, ask `next`, run `sdd continue` for the copyable continuation plan, then either run `vgxness code sdd ...` for phase work or `vgxness resume ...` for an interrupted run. After a draft is ready, use `sdd accept-artifact` for explicit human acceptance; if an artifact was rejected, use `sdd reopen-artifact` before revising it. Related interrupted run hints in `status`, `next`, and `sdd continue` are advisory only; they help avoid duplicate work but do not retry or execute runs.
+The usual SDD operator loop happens inside OpenCode: continue the phase in conversation while VGXNESS MCP and hidden SDD subagents inspect readiness, persist artifacts, and report evidence. CLI commands remain fallback/recovery tools: inspect `status`, ask `next`, run `sdd continue` for a copyable manual continuation plan, then either run `vgxness code sdd ...` as an explicit fallback or `vgxness resume ...` for interrupted work. After a draft is ready, use `sdd accept-artifact` for explicit human acceptance; if an artifact was rejected, use `sdd reopen-artifact` before revising it. Related interrupted run hints in `status`, `next`, and `sdd continue` are advisory only; they help avoid duplicate work but do not retry or execute runs.
 
 ## Bun-first repository verification
 
@@ -237,7 +240,7 @@ bun run cli:bun --
 
 The installed `vgxness`/`vgx` binary opens the OpenTUI main menu when run with no arguments in a TTY. With no TTY, no-args prints deterministic safe setup guidance, exits 0, and does not infer a project, open project state, toggle raw mode, or write provider/config artifacts. Use `vgxness --help` or `vgxness -h` to print command help without starting the main menu; explicit subcommands keep their normal behavior.
 
-The top-level menu is: **Installation, Doctor / recovery, SDD / workflow guidance, Advanced CLI, Exit**. Terminal controls are `↑/↓` or `j/k` to move, `Enter` to open the focused item, `?` for help, and `q` to quit.
+The top-level menu is: **Installation, Doctor / recovery, SDD / workflow guidance, Advanced CLI, Exit**. It is a read-only setup, diagnostics, recovery, and fallback surface; daily SDD progression stays in OpenCode with VGXNESS MCP. Terminal controls are `↑/↓` or `j/k` to move, `Enter` to open the focused item, `?` for help, and `q` to quit.
 
 For scriptable status, use explicit read-only commands:
 
@@ -255,7 +258,7 @@ Provider support shown in the Installation surface is:
 - **Antigravity** — placeholder/coming-soon guidance only.
 - **Custom/future** — extension point with safe manual/default unsupported behavior.
 
-Setup and main-menu TUI surfaces do **not** silently write OpenCode or other provider config, do **not** call provider executables, and do **not** approve/reject preflights. Any operational next action is copied for explicit execution outside the TUI.
+Setup and main-menu TUI surfaces do **not** silently write OpenCode or other provider config, do **not** call provider executables, and do **not** approve/reject preflights. They print diagnostics, recovery hints, and manual fallback commands; daily SDD work should continue in OpenCode.
 
 ## Natural-language orchestrator preview
 
@@ -562,7 +565,7 @@ Manual/opt-in runtime validation checklist (not normal CI):
 
 ## SDD workflow examples
 
-Use `sdd` commands to inspect local SDD artifact state and save, read, or list phase artifacts. These commands read and write only the selected `vgxness` local SQLite memory store: `--db <path>` when passed, `VGXNESS_DB_PATH` when set, or the global default database when neither override is present.
+Use OpenCode conversation with VGXNESS MCP and hidden SDD subagents for normal daily SDD progression. Use `sdd` commands to inspect local SDD artifact state and save, read, or list phase artifacts for diagnostics, recovery, scripting, or manual fallback. These commands read and write only the selected `vgxness` local SQLite memory store: `--db <path>` when passed, `VGXNESS_DB_PATH` when set, or the global default database when neither override is present.
 
 ```bash
 bun run cli:bun -- sdd status --project vgxness --change sdd-workflow-engine --db /tmp/vgxness-memory.sqlite
@@ -579,13 +582,13 @@ bun run cli:bun -- sdd reopen-artifact --project vgxness --change sdd-workflow-e
 VGXNESS_DB_PATH=/tmp/vgxness-memory.sqlite bun run cli:bun -- sdd list-artifacts --project vgxness --change sdd-workflow-engine
 ```
 
-Current canonical phases are `explore`, `proposal`, `spec`, `design`, `tasks`, `apply-progress`, `verify`, and `archive`. `apply` is accepted as a user-facing input alias, but artifacts, topic keys, readiness/status/cockpit JSON, and internal metadata continue to use canonical `apply-progress`. Each artifact is stored under `sdd/{change}/{phase}` in the local SQLite memory store. `sdd status` reports which phase artifacts are present, blocker-specific next actions, and related interrupted run hints when available. `sdd next` reports the next SDD action for a project/change. `sdd continue` turns that state into a read-only continuation plan, including draft-run suggestions for planning phases and related interrupted run context when a matching stopped run exists. `sdd status`, `sdd next`, `sdd continue`, `sdd get-artifact`, and `sdd list-artifacts` are human-readable by default; pass `--json` for automation/stable structured output. `sdd ready` reports satisfied prerequisites and missing artifact topic keys for one phase. `sdd get-artifact` shows artifact metadata and then full content after `--- Content ---`; `sdd list-artifacts` shows one compact row for every canonical SDD phase in phase order and does not print full artifact content.
+Current canonical phases are `explore`, `proposal`, `spec`, `design`, `tasks`, `apply-progress`, `verify`, and `archive`. `apply` is accepted as a user-facing input alias, but artifacts, topic keys, readiness/status/cockpit JSON, and internal metadata continue to use canonical `apply-progress`. Each artifact is stored under `sdd/{change}/{phase}` in the local SQLite memory store. `sdd status` reports which phase artifacts are present, blocker-specific next actions, and related interrupted run hints when available. `sdd next` reports the next SDD action for a project/change and frames runnable phase work as OpenCode-first while preserving fallback command fields. `sdd continue` turns that state into a read-only continuation plan, including manual fallback commands, draft-run suggestions for planning phases, and related interrupted run context when a matching stopped run exists. `sdd status`, `sdd next`, `sdd continue`, `sdd get-artifact`, and `sdd list-artifacts` are human-readable by default; pass `--json` for automation/stable structured output. `sdd ready` reports satisfied prerequisites and missing artifact topic keys for one phase. `sdd get-artifact` shows artifact metadata and then full content after `--- Content ---`; `sdd list-artifacts` shows one compact row for every canonical SDD phase in phase order and does not print full artifact content.
 
 `sdd accept-artifact` records explicit human-only acceptance of an existing artifact through the same SDD workflow service used by MCP. It requires `--project`, `--change`, `--phase`, and `--actor`; `--display-name` defaults to the actor id. `--accepted-at` is optional, but when supplied it must be an ISO date-time with an explicit timezone (`Z` or offset) and is normalized to UTC `toISOString()` output. The default output is a human-readable confirmation with a JSON hint; `--json` returns a content-free success object with project/change/phase/topic key/artifact id/status/acceptedBy/acceptedAt and optional note. `save-artifact` creates or updates draft content only and does not imply acceptance. `sdd reopen-artifact` moves a rejected artifact back to draft after an explicit human decision, so the artifact can be revised and accepted again.
 
 Use `resume --project <project>` when you do not know the run id. It lists recent interrupted candidates for that project from the selected database. Use `resume --project <project> --run-id <id>` to inspect one candidate; this is still read-only and advisory.
 
-The SDD CLI is status, planning, and artifact persistence only. It does **not** execute providers, retry workflow runs, create `openspec/`, or write `.opencode/`, `.claude/`, or user/global provider config.
+The SDD CLI is status, planning, artifact persistence, diagnostics, recovery, scripting, and manual fallback only. It does **not** execute providers, retry workflow runs, create `openspec/`, or write `.opencode/`, `.claude/`, or user/global provider config.
 
 ## Agent resolution
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.9.3",
+  "version": "1.9.4",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {