vgxness 1.9.3 → 1.9.5

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/cli-help.js

@@ -72,7 +72,7 @@ Areas:
   mcp doctor [--db <path>] [--project <name>] [--change <id>] [--timeout-ms <ms>]
   MCP setup preview is read-only; it does not install or write .opencode/, .claude/, or provider config.
   Without --db, MCP install and setup commands use the vgxness global default database; pass --db .vgx/memory.sqlite for project-local compatibility.
-  OpenCode install defaults to user/global scope and installs mcp.vgxness plus vgxness-manager and hidden vgxness-sdd-* agents; use --mcp-only for legacy MCP-only config.
+  OpenCode install defaults to user/global scope and installs mcp.vgxness plus permission.bash=allow, vgxness-manager, and hidden vgxness-sdd-* agents; use --mcp-only for legacy MCP-only config.
   Use --overwrite-vgxness (alias --reinstall) to reinstall only VGXNESS-managed OpenCode entries while preserving unrelated config; --yes is still required to write.
   It writes only after --yes. The default target is $HOME/.config/opencode/opencode.json; use --scope project to target .opencode/opencode.json explicitly.
   Project OpenCode config can override user config. Plans are read-only; applies refuse unsafe existing config and create backups before merge.

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/memory-sdd-dispatcher.js

@@ -8,6 +8,7 @@ import { createNaturalLanguagePlan } from '../../orchestrator/natural-language-p
 import { OpenCodeInjectionPreviewService } from '../../providers/opencode/injection-preview.js';
 import { RunService } from '../../runs/run-service.js';
 import { ArtifactPortabilityService } from '../../sdd/artifact-portability-service.js';
+import { buildSddCockpitSurfaceResponse } from '../../sdd/cockpit-read-model.js';
 import { normalizeSddArtifact, normalizeSddPhaseInput, sddPhases } from '../../sdd/schema.js';
 import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
 import { SkillRegistryService } from '../../skills/skill-registry-service.js';
@@ -145,9 +146,12 @@ export function runSddCommand(command, parsed, database, environment) {
     }
     if (command === 'cockpit') {
         const cockpit = service.getCockpit({ project: project.value, change: change.value });
-        if (!cockpit.ok || parsed.flags.json === true)
+        if (!cockpit.ok)
             return jsonResult(cockpit);
-        return okText(renderSddCockpit(cockpit.value));
+        const surface = buildSddCockpitSurfaceResponse(cockpit.value);
+        if (parsed.flags.json === true)
+            return jsonResult({ ok: true, value: surface });
+        return okText(renderSddCockpit(surface));
     }
     if (command === 'ready') {
         const phase = requiredFlag(parsed.flags, 'phase');

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
@@ -114,21 +120,28 @@ export function renderSddContinuationPlan(plan) {
     return `${lines.join('\n')}\n`;
 }
 export function renderSddCockpit(cockpit) {
-    const blockers = cockpit.aggregateBlockers;
+    const readModel = cockpit.readModel;
+    const blockers = readModel.blockers;
     const lines = [
         'SDD Cockpit (read-only)',
-        `Project: ${cockpit.project}`,
-        `Change: ${cockpit.change}`,
-        `Actionable phase: ${cockpit.actionablePhase ?? 'none'}`,
-        `Next: ${cockpit.next.status}${cockpit.next.nextPhase === undefined ? '' : ` / ${cockpit.next.nextPhase}`}`,
-        `Recommended action: ${cockpit.recommendedAction}`,
-        `Accepted: ${cockpit.acceptedCount}/${cockpit.phases.length}`,
-        `Legacy artifacts: ${cockpit.legacyCount}`,
-        '',
-        'Aggregate blockers:',
+        `Project: ${readModel.project}`,
+        `Change: ${readModel.change}`,
+        `Next action: ${readModel.nextAction.kind}${readModel.nextAction.phase === undefined ? '' : ` / ${readModel.nextAction.phase}`}`,
+        `Recommended action: ${readModel.nextAction.label}`,
+        `Content included: ${readModel.contentIncluded ? 'yes' : 'no'}`,
+        `Accepted: ${readModel.summary.acceptedArtifacts}/${readModel.summary.totalPhases}`,
+        `Legacy artifacts: ${readModel.summary.legacyArtifacts}`,
+        '',
+        'Phases:',
+        ...readModel.phases.map((phase) => `- ${phase.phase}: status=${phase.artifact.status}; accepted=${phase.acceptance.acceptedByHuman ? 'human' : 'no'}; content=${phase.artifact.contentAvailable ? 'metadata-only' : 'none'}; topic=${phase.topicKey}`),
+        '',
+        'Blockers:',
         ...(blockers.length === 0
             ? ['- none']
-            : blockers.map((blocker) => `- ${blocker.kind}: ${blocker.phase} at ${blocker.topicKey} - ${blocker.reason}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
+            : blockers.map((blocker) => `- ${blocker.severity}/${blocker.code}: ${blocker.phase ?? 'change'} at ${blocker.topicKey ?? '-'} - ${blocker.message}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
+        '',
+        'Guidance:',
+        ...readModel.guidance.map((item) => `- ${item}`),
         '',
         `Inspect: ${cockpit.inspectCommand}`,
         `Cockpit JSON: ${cockpit.inspectCommand}`,

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 {