vgxness 1.10.1 → 1.11.0

package/README.md

@@ -1,6 +1,6 @@
 # VGXNESS
 
-VGXNESS is an installable CLI, MCP control plane, and native code runtime for guided AI-agent workflows, SDD artifacts, local memory, and OpenCode integration.
+VGXNESS is an installable CLI and MCP control plane for guided AI-agent workflows, SDD artifacts, local memory, and OpenCode integration.
 
 ## Release status and license
 
@@ -8,7 +8,7 @@ This package is proprietary software. The npm package ships inspectable JavaScri
 
 OpenCode is the primary supported provider. Claude setup support is secondary. VGX-managed OpenCode and Claude provider configuration is user-global only; provider config writes require explicit CLI confirmation.
 
-VGXNESS v1.9.1 has a canonical project health audit with validated evidence: 38 MCP tools, 106 test files, and the official Bun validation path passing, including package evidence with `releaseReadiness: pass`. Current unreleased builds expose 41 MCP tools after adding read-only SDD/run recovery parity. See [Project health audit v1.9.1](./docs/project-health-audit-v1.9.1.md) for the versioned matrix and safety taxonomy.
+VGXNESS v1.10.x has a current project health audit describing the implemented CLI/MCP/SDD control plane, OpenCode health, known docs drift, interrupted runs, and the remaining execution/recovery gaps. See [Project health audit v1.10.x](./docs/project-health-audit-v1.10.x.md) for the current system snapshot; [v1.9.1](./docs/project-health-audit-v1.9.1.md) remains historical validation evidence for that release.
 
 ## Requirements
 
@@ -132,13 +132,13 @@ vgx --help # compatibility alias
 
 ## First setup with OpenCode
 
-Run the guided setup wizard in a TTY:
+Preview the setup plan:
 
 ```bash
 vgxness init
 ```
 
-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:
+`vgxness init` is read-only by default, including in TTYs; apply still requires explicit `--yes`. For a copyable bootstrap and diagnostic path after installing the package globally:
 
 ```bash
 vgxness setup plan
@@ -147,7 +147,6 @@ 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 config (`$HOME/.config/opencode/opencode.json`), and `mcp-plus-agents` mode. VGX-managed OpenCode and Claude provider configuration is user-global only; runtime VGXNESS state remains project-aware through `--project`, `--change`, workspace, and database context. Existing project-local provider files such as `.opencode/`, `opencode.json`, `.mcp.json`, `.claude/`, and `CLAUDE.md` remain untouched by VGXNESS setup. They may still affect OpenCode or Claude behavior externally, but VGXNESS treats them as external/manual diagnostics and will not repair, write, back up, or delete them. The generated MCP command for the global DB default is:
@@ -164,20 +163,11 @@ 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 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.
+The daily SDD happy path is OpenCode conversation with the installed VGXNESS MCP server and hidden SDD subagents. Use CLI commands for bootstrap, setup, diagnostics, recovery, fallback, and scripting: `status`, `next`, and `sdd continue` inspect state and print read-only continuation guidance; `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.
 
-## Code runtime (`vgxness code`)
+## Code runtime status
 
-Beyond setup and SDD control, VGXNESS ships a native code runtime for bounded agentic work in the local workspace:
-
-```bash
-vgxness code inspect "<question>"      # read-only investigation
-vgxness code plan "<task>"             # read-only implementation plan
-vgxness code craft-preview "<task>"    # show the diff you would make
-vgxness code craft "<task>"            # approval-gated, bounded edit-capable work
-```
-
-Edits, shell, network, git mutations, SDD persistence, and memory saves route through explicit permission decisions. External workspace edits are denied, destructive commands require approval, and secret-like values are redacted from prompts, transcripts, and reports. See [Code runtime](./docs/code-runtime.md) and [Safety model](./docs/safety.md) for the full contract.
+The experimental `vgxness code` runtime and principal OpenTUI code surface have been removed temporarily because they were copied OpenCode-like runtime work. Continue SDD work in OpenCode through VGXNESS MCP, and use the safe CLI commands above for diagnostics and recovery.
 
 ## Safety model
 
@@ -191,9 +181,9 @@ Edits, shell, network, git mutations, SDD persistence, and memory saves route th
 - OpenCode is the primary supported provider; other providers are preview/manual extension points.
 - VGXNESS exposes 41 typed MCP tools across SDD, memory, sessions, agents, skills, runs, providers, and verification. See [MCP tools](./docs/mcp.md).
 
-## Main menu entrypoint
+## Principal entrypoint
 
-Run `vgxness` with no arguments in an interactive terminal to open the OpenTUI main menu. `vgx` remains a compatibility alias. In non-TTY shells, no-args prints static safe setup guidance and exits 0 without inferring project state.
+Run `vgxness` with no arguments to print static safe guidance and exit 0 without opening local memory, importing OpenTUI, or writing provider config. `vgx` remains a compatibility alias.
 
 For scripts, use explicit read-only commands with an explicit project:
 
@@ -266,9 +256,9 @@ Remove any user-global OpenCode/Claude config entries and local/global VGXNESS d
 ## More docs
 
 - [CLI reference](./docs/cli.md)
+- [Project health audit v1.10.x](./docs/project-health-audit-v1.10.x.md)
 - [Project health audit v1.9.1](./docs/project-health-audit-v1.9.1.md)
 - [Architecture](./docs/architecture.md)
-- [Code runtime](./docs/code-runtime.md)
 - [MCP tools](./docs/mcp.md)
 - [Safety model](./docs/safety.md)
 - [Storage](./docs/storage.md)

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

@@ -183,7 +183,7 @@ Daily SDD happens inside OpenCode through conversation, VGXNESS MCP, and hidden
 - 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.
+- 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. The removed experimental \`vgxness code\` runtime is not an SDD fallback.
 
 ## Delegation thresholds
 Default to delegation for SDD phase-shaped work, repository exploration beyond one narrow lookup, implementation, verification, incident recovery, or multi-step analysis. Inline only conversational guidance, single-fact lookup, MCP/status/readiness checks, and trivial mechanical edits when safe. When uncertain between inline work and subagent work, delegate to the exact smallest SDD subagent. Never delegate to unknown agents; use exact SDD phase mapping.
@@ -203,7 +203,7 @@ const registryManagerInstructionsV10 = [
     '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.',
+    '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. The removed experimental vgxness code runtime is not an SDD fallback.',
     'OpenCode native/provider tools are governance-v1 audit-only/non-hard-blocking; report warnings, never say they are hard-blocked by config.',
 ].join(' ');
 const subagentData = {

package/dist/behavior/behavior-contract-manifest.js

@@ -12,13 +12,12 @@ export const criticalBehaviorContractInvariantIds = [
     'context.manager-compact-default',
     'context.progressive-disclosure',
     'flow.provider-native-no-terminal-sdd-daily',
-    'scope.exclude-vgxcode-runtime',
     'worktree.preserve-unrelated-user-work',
 ];
 export const behaviorContractManifest = {
     name: canonicalBehaviorContractName,
     contractVersion: canonicalBehaviorContractVersion,
-    excludedTargets: ['vgxcode', 'src/code/runtime/*', 'src/code/prompts/*'],
+    excludedTargets: [],
     invariants: [
         { id: 'sdd.acceptance.human-only', category: 'sdd', severity: 'critical', summary: 'SDD acceptance is recorded only from explicit human acceptance.' },
         { id: 'sdd.draft-is-not-accepted', category: 'sdd', severity: 'critical', summary: 'Draft, rejected, superseded, legacy, or unaccepted artifacts are not accepted prerequisites.' },
@@ -31,7 +30,6 @@ export const behaviorContractManifest = {
         { id: 'context.manager-compact-default', category: 'context', severity: 'critical', summary: 'Manager-facing context defaults to compact payloads.' },
         { id: 'context.progressive-disclosure', category: 'context', severity: 'critical', summary: 'Expanded and verbose context are requested only when needed.' },
         { id: 'flow.provider-native-no-terminal-sdd-daily', category: 'flow', severity: 'critical', summary: 'Daily SDD progression happens provider-natively through conversation and MCP, not mandatory terminal phase commands.' },
-        { id: 'scope.exclude-vgxcode-runtime', category: 'scope', severity: 'critical', summary: 'This behavior contract excludes vgxcode and src/code runtime/prompt implementation targets.' },
         { id: 'worktree.preserve-unrelated-user-work', category: 'worktree', severity: 'critical', summary: 'Unrelated user work and dirty files are preserved.' },
     ],
 };

package/dist/behavior/behavior-contract-validation.js

@@ -22,10 +22,6 @@ export function validateBehaviorContractManifest(manifest = behaviorContractMani
         else if (invariant.severity !== 'critical')
             errors.push(`critical invariant ${id} must have severity critical`);
     }
-    for (const target of ['vgxcode', 'src/code/runtime/*', 'src/code/prompts/*']) {
-        if (!manifest.excludedTargets.includes(target))
-            errors.push(`missing excluded target: ${target}`);
-    }
     return { ok: errors.length === 0, errors };
 }
 export function validateBehaviorContractProjection(metadata, manifest = behaviorContractManifest) {

package/dist/cli/cli-help.js

@@ -41,12 +41,7 @@ Areas:
 
   opencode preview --provider opencode (--agent <name> | --agent-id <id>) --project <name> --change <id> --phase <phase> [--scope project|personal]
 
-  code inspect "<question>" [--json|--events-jsonl] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--transcript off|summary|full] [--memory off|ask|auto]
-  code plan "<task>" [--json|--events-jsonl] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--transcript off|summary|full] [--memory off|ask|auto]
-  code craft-preview "<task>" [--events-jsonl] [--provider fake|openai-compatible] [--model <id>] [--stream]
-  code craft "<task>" [--json|--events-jsonl --approval-channel stdio] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--approval-policy ask|allow|deny] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
-  code sdd <change> <phase> [--json] [--save-artifact] [--draft-run] [--provider fake|openai-compatible] [--model <id>] [--stream] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
-  VGXNESS Code inspect and plan are native read-only repository flows. Craft is bounded edit-capable work with approval-gated edits and shell verification; craft JSONL approvals require explicit --approval-channel stdio. SDD mode follows phase-specific artifact boundaries and saves only with --save-artifact. --draft-run lets planning phases use draft prerequisites only; human acceptance is still required and apply-progress remains gated.
+  The experimental vgxness code runtime and principal OpenTUI code surface were removed and are temporarily unavailable. Daily SDD progression should happen inside OpenCode through conversation, VGXNESS MCP, and hidden SDD subagents; use status/next/sdd continue for read-only CLI guidance.
 
   orchestrator preview --project <name> --intent <text> [--change <id>] [--db <path>]
   Orchestrator preview classifies natural-language requests only; it never executes providers, edits files, records runs, or writes provider config.
@@ -102,9 +97,8 @@ Areas:
   subagents list --parent-agent-id <id>
   subagents get --id <id> | --project <name> --name <name> [--scope project|personal]
 
-  No args in an interactive TTY opens the OpenTUI main menu.
-  No args without a TTY prints static safe setup guidance and exits 0 without opening project state.
-  Setup TUI may launch without --project; Installation remains available and project-scoped checks are deferred while project screens render project-required recovery states.
+  No args prints static safe guidance and exits 0 without opening project state, importing OpenTUI, or writing provider config.
+  Setup is CLI-only: use setup plan/status for read-only guidance and setup apply --yes only after review.
   Provider setup support: OpenCode first-class supported default guided install; Claude first-class supported guarded user-global install; project/local provider files are diagnostics only; Antigravity placeholder; Custom/future extension point.
   Provider config writes/install/apply are external-only and require explicit confirmation.
 

package/dist/cli/commands/index.js

@@ -1,9 +1,9 @@
 export { runAgentCommand, runSkillCommand, runSubagentCommand } from './agent-skill-dispatcher.js';
-export { runCodeCliCommand, runDefaultInteractiveEntrypoint } from './interactive-entrypoint-dispatcher.js';
+export { runDefaultInteractiveEntrypoint } from './interactive-entrypoint-dispatcher.js';
 export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand, runMcpInstallCommand, runMcpSetupCommand } from './mcp-dispatcher.js';
 export { runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runSddCommand } from './memory-sdd-dispatcher.js';
 export { runApprovalsCommand, runPermissionsCommand, runRunsCommand } from './run-permission-dispatcher.js';
 export { runProductNextCommand, runProductResumeCommand, runProductStatusCommand } from './status-dispatcher.js';
-export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSetupTuiCommand, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';
+export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';
 export { runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand } from './workflow-dispatcher.js';
 export { runVerificationPlanCommand, runVerificationReportCommand } from './verification-dispatcher.js';

package/dist/cli/commands/interactive-entrypoint-dispatcher.js

@@ -1,158 +1,14 @@
-import { runCodeCommand } from '../../code/cli/code-command.js';
-import { InMemoryRunGateway } from '../../code/runtime/gateways.js';
-import { MemoryServiceCodeGateway } from '../../code/runtime/memory-service-gateway.js';
-import { RunsCodeRunGateway } from '../../code/runtime/runs-code-run-gateway.js';
-import { SddWorkflowGateway } from '../../code/runtime/sdd-workflow-gateway.js';
-import { MemoryService } from '../../memory/memory-service.js';
-import { RunService } from '../../runs/run-service.js';
-import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
-import { codeApprovalPolicyFlag, codeMemoryPolicyFlag, codeTranscriptModeFlag, codeVerificationModeFlag, databasePathFor, optionalNumberFlag, optionalStringFlag, } from '../cli-flags.js';
-import { okText, usageFailure, validationFailure } from '../cli-help.js';
-import { openCliDatabase, resultFailure } from '../cli-helpers.js';
-import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
-import { runSetupTuiCommand } from './setup-dispatcher.js';
-function defaultNoTtyGuidance() {
+import { okText } from '../cli-help.js';
+function defaultNoArgsGuidance() {
     return ([
-        'VGXNESS Dashboard requires a TTY; no provider config was written.',
-        'Next: rerun `vgxness` in an interactive terminal, run `vgxness init --plan`, or run `vgxness setup plan` for read-only installation guidance.',
+        'VGXNESS no-args entrypoint is safe and deterministic; no local DB was opened and no provider config was written.',
+        'The experimental principal code/OpenTUI surface was removed and is temporarily unavailable.',
+        'Next: use `vgxness status`, `vgxness next`, `vgxness init --plan`, `vgxness setup plan`, or `vgxness --help`.',
     ].join('\n') + '\n');
 }
-function guidanceForMainMenuResult(result) {
-    if (result.type === 'show-doctor-guidance')
-        return ['Doctor / recovery guidance:', '- Read-only status: `vgxness setup status`', '- Provider doctor: `vgxness mcp doctor opencode`', '- No provider config was written.'].join('\n') + '\n';
-    if (result.type === 'show-sdd-guidance')
-        return ['SDD / workflow guidance:', '- Use VGXNESS MCP tools from OpenCode for normal SDD progression.', '- Manual status: `vgxness sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
-    if (result.type === 'show-advanced-cli')
-        return ['Advanced CLI guidance:', '- Installation preview: `vgxness init --plan` or `vgxness setup plan`', '- Setup status: `vgxness setup status --project <name>`', '- SDD status: `vgxness sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
-    if (result.type === 'exit')
-        return 'Exited dashboard; no provider config was written.\n';
-    return undefined;
-}
-async function renderDefaultMainMenu(environment, onResult) {
-    const { renderOpenTuiMainMenu } = await import('../tui/opentui/main-menu/renderer.js');
-    await renderOpenTuiMainMenu({
-        stdin: environment.stdin,
-        stdout: environment.stdout,
-        onResult,
-    });
-}
-export async function runDefaultInteractiveEntrypointWithMainMenu(environment, input = {}) {
-    if (!canRunInteractiveTui(environment.stdin, environment.stdout))
-        return okText(defaultNoTtyGuidance());
-    let selected;
-    await (input.renderMainMenu ?? ((onResult) => renderDefaultMainMenu(environment, onResult)))((result) => {
-        selected = result;
-    });
-    const result = selected ?? { type: 'exit' };
-    if (result.type === 'open-setup')
-        return (input.setupTui ?? runSetupTuiCommand)(environment);
-    return okText(guidanceForMainMenuResult(result) ?? 'No provider config was written.\n');
-}
-function codeApprovalChannelFlag(flags) {
-    const value = optionalStringFlag(flags, 'approval-channel');
-    if (value === undefined)
-        return { ok: true, value: undefined };
-    return value === 'stdio' ? { ok: true, value } : validationFailure('--approval-channel must be stdio');
-}
 export async function runDefaultInteractiveEntrypoint(environment) {
-    return runDefaultInteractiveEntrypointWithMainMenu(environment);
-}
-export async function runCodeCliCommand(parsed, environment) {
-    const [, command] = parsed.positionals;
-    if (command !== 'inspect' && command !== 'plan' && command !== 'craft' && command !== 'craft-preview' && command !== 'sdd')
-        return usageFailure(`Unknown code command: ${command ?? ''}`.trim());
-    const eventsJsonl = parsed.flags['events-jsonl'] === true;
-    const approvalChannel = codeApprovalChannelFlag(parsed.flags);
-    if (!approvalChannel.ok)
-        return resultFailure(approvalChannel);
-    if (approvalChannel.value === 'stdio' && (command !== 'craft' || !eventsJsonl))
-        return usageFailure('--approval-channel stdio is supported only for code craft --events-jsonl');
-    if (eventsJsonl && command !== 'inspect' && command !== 'plan' && command !== 'craft-preview' && approvalChannel.value !== 'stdio')
-        return usageFailure('code craft --events-jsonl requires --approval-channel stdio; JSONL without approvals is currently supported only for read-only inspect, plan, and craft-preview');
-    const draftRunFlag = parsed.flags['draft-run'];
-    if (draftRunFlag !== undefined && command !== 'sdd')
-        return usageFailure('--draft-run is supported only for code sdd');
-    if (draftRunFlag !== undefined && draftRunFlag !== true)
-        return usageFailure('--draft-run does not accept a value; use --draft-run for code sdd draft mode');
-    const sddRuntimeMode = draftRunFlag === true ? 'draft-run' : undefined;
-    const maxSourceBytes = optionalNumberFlag(parsed.flags, 'max-source-bytes');
-    if (!maxSourceBytes.ok)
-        return resultFailure(maxSourceBytes);
-    const output = parsed.flags.json === true || optionalStringFlag(parsed.flags, 'output') === 'json' ? 'json' : 'human';
-    const approvalPolicy = codeApprovalPolicyFlag(parsed.flags);
-    if (!approvalPolicy.ok)
-        return resultFailure(approvalPolicy);
-    const verificationMode = codeVerificationModeFlag(parsed.flags);
-    if (!verificationMode.ok)
-        return resultFailure(verificationMode);
-    const transcriptMode = codeTranscriptModeFlag(parsed.flags);
-    if (!transcriptMode.ok)
-        return resultFailure(transcriptMode);
-    const memoryPolicy = codeMemoryPolicyFlag(parsed.flags);
-    if (!memoryPolicy.ok)
-        return resultFailure(memoryPolicy);
-    const provider = optionalStringFlag(parsed.flags, 'provider');
-    const model = optionalStringFlag(parsed.flags, 'model');
-    if (eventsJsonl) {
-        if (approvalChannel.value === 'stdio' && (environment.stdin === undefined || environment.stdout === undefined))
-            return resultFailure(validationFailure('--approval-channel stdio requires CLI stdin and stdout streams'));
-        return await runCodeCommand({
-            command,
-            args: parsed.positionals.slice(2),
-            cwd: environment.cwd,
-            output,
-            runGateway: new InMemoryRunGateway(),
-            project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
-            ...(provider === undefined ? {} : { provider }),
-            ...(model === undefined ? {} : { model }),
-            stream: parsed.flags.stream === true,
-            env: environment.env,
-            eventsJsonl,
-            memoryPolicy: 'off',
-            ...(approvalChannel.value === undefined ? {} : { approvalChannel: approvalChannel.value }),
-            ...(approvalChannel.value === 'stdio' ? { approvalDecisionInput: environment.stdin, eventOutput: environment.stdout } : {}),
-            ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}),
-            ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
-            ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),
-            ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }),
-            ...(sddRuntimeMode === undefined ? {} : { sddRuntimeMode }),
-        });
-    }
-    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
-    if (!selectedDatabasePath.ok)
-        return resultFailure(selectedDatabasePath);
-    const opened = openCliDatabase(selectedDatabasePath.value);
-    if (!opened.ok)
-        return resultFailure(opened);
-    try {
-        const runs = new RunService(opened.value);
-        const memory = new MemoryService(opened.value);
-        return await runCodeCommand({
-            command,
-            args: parsed.positionals.slice(2),
-            cwd: environment.cwd,
-            output,
-            runGateway: new RunsCodeRunGateway(runs),
-            sddGateway: new SddWorkflowGateway(new SddWorkflowService(memory)),
-            memoryGateway: new MemoryServiceCodeGateway(memory),
-            project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
-            ...(provider === undefined ? {} : { provider }),
-            ...(model === undefined ? {} : { model }),
-            stream: parsed.flags.stream === true,
-            env: environment.env,
-            eventsJsonl,
-            persistArtifact: parsed.flags['save-artifact'] === true || parsed.flags.persist === true,
-            ...(sddRuntimeMode === undefined ? {} : { sddRuntimeMode }),
-            ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}),
-            ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
-            ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),
-            ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }),
-            ...(memoryPolicy.value === undefined ? {} : { memoryPolicy: memoryPolicy.value }),
-        });
-    }
-    finally {
-        opened.value.close();
-    }
+    void environment;
+    return okText(defaultNoArgsGuidance());
 }
-// Re-export helpers
-export { defaultNoTtyGuidance, };
+// Re-export helper for focused CLI tests.
+export { defaultNoArgsGuidance };

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

@@ -9,13 +9,11 @@ import { applyRollbackConfigBackup, listProviderConfigBackups, previewRollbackCo
 import { vgxnessSetupDefaults } from '../../setup/setup-defaults.js';
 import { SetupLifecycleService } from '../../setup/setup-lifecycle-service.js';
 import { createSetupPlan } from '../../setup/setup-plan.js';
-import { databasePathFor, databasePathSelectionFor, opencodeInstallScopeFlag, optionalStringFlag, providerUserGlobalOnlyMigrationMessage, scopeFlag, setupDatabaseFlags, setupInstallModeFlag, setupProviderFlag, } from '../cli-flags.js';
+import { databasePathFor, opencodeInstallScopeFlag, optionalStringFlag, providerUserGlobalOnlyMigrationMessage, scopeFlag, setupDatabaseFlags, setupInstallModeFlag, setupProviderFlag, } from '../cli-flags.js';
 import { okText, usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
 import { renderSetupPlan } from '../setup-plan-renderer.js';
 import { renderSetupStatus } from '../setup-status-renderer.js';
-import { createDefaultSetupTuiServices } from '../tui/setup/setup-tui-services.js';
-import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
 function renderSetupRollbackApply(result, parsed) {
     if (parsed.flags.json === true)
         return jsonResult(result);
@@ -344,63 +342,21 @@ export function promptLineExport(environment, prompt) {
 export function renderSetupPlanForHumansExport(plan) {
     return renderSetupPlanForHumans(plan);
 }
-export function resolveInitDispatchMode(parsed, environment) {
+export function resolveInitDispatchMode(parsed, _environment) {
     if (parsed.flags.plan === true || parsed.flags.json === true)
         return 'setup-plan';
     if (parsed.flags.yes === true)
         return 'setup-apply';
-    return environment.stdin?.isTTY === true && environment.stdout?.isTTY === true ? 'setup-tui' : 'setup-plan';
+    return 'setup-plan';
 }
 export async function runInitCommand(parsed, environment) {
-    return runInitCommandWithSetupTui(parsed, environment, runSetupTuiCommand);
+    return runInitCommandWithoutSetupTui(parsed, environment);
 }
-export async function runInitCommandWithSetupTui(parsed, environment, setupTui) {
+export async function runInitCommandWithoutSetupTui(parsed, environment) {
     const mode = resolveInitDispatchMode(parsed, environment);
     if (mode === 'setup-plan')
         return runSetupPlanCommand(parsed, environment);
-    if (mode === 'setup-apply')
-        return runSetupApplyCommand({ ...parsed, flags: { ...parsed.flags, yes: true } }, environment);
-    const project = optionalStringFlag(parsed.flags, 'project');
-    return setupTui(environment, project === undefined ? undefined : { project });
-}
-export async function runSetupTuiCommand(environment, input) {
-    if (!canRunInteractiveTui(environment.stdin, environment.stdout))
-        return okText('Setup TUI requires an interactive TTY. [read-only] No provider config was written. Run `vgxness init --plan` or `vgxness setup plan` for read-only preview output; apply later with `vgxness setup apply --yes` only after review.\n');
-    const selectedDatabasePath = databasePathSelectionFor({}, environment);
-    if (!selectedDatabasePath.ok)
-        return resultFailure(selectedDatabasePath);
-    const opened = input?.lifecycle === undefined ? openCliDatabase(selectedDatabasePath.value.path) : undefined;
-    if (opened !== undefined && !opened.ok)
-        return resultFailure(opened);
-    const lifecycle = input?.lifecycle ??
-        createSetupLifecycleService({ opened: opened ?? validationFailure('Store is unavailable.'), databasePath: selectedDatabasePath.value.path, environment });
-    const project = input?.project ?? environment.cwd.replace(/[/]+$/, '').split(/[/]/).pop() ?? 'vgxness';
-    const runtime = {
-        project,
-        workspaceRoot: environment.cwd,
-        env: environment.env,
-        selections: {
-            databaseMode: vgxnessSetupDefaults.defaultDatabaseMode,
-            provider: vgxnessSetupDefaults.defaultProvider,
-            scope: vgxnessSetupDefaults.defaultOpenCodeScope,
-            installMode: vgxnessSetupDefaults.defaultInstallMode,
-            overwriteVgxness: false,
-        },
-    };
-    try {
-        const { renderOpenTuiSetup } = await import('../tui/opentui/setup/index.js');
-        await renderOpenTuiSetup({
-            services: createDefaultSetupTuiServices({ lifecycle, cwd: environment.cwd, env: environment.env }),
-            runtime,
-            stdin: environment.stdin,
-            stdout: environment.stdout,
-        });
-        return { exitCode: 0, stdout: '', stderr: '' };
-    }
-    finally {
-        if (opened?.ok)
-            opened.value.close();
-    }
+    return runSetupApplyCommand({ ...parsed, flags: { ...parsed.flags, yes: true } }, environment);
 }
 export function createSetupLifecycleService(input) {
     return new SetupLifecycleService({

package/dist/cli/dispatcher.js

@@ -5,7 +5,7 @@ import { databasePathFor, parseArgs, requiredFlag } from './cli-flags.js';
 import { okText, usageFailure, visibleHelpText } from './cli-help.js';
 import { openCliDatabase, resultFailure } from './cli-helpers.js';
 import { runBootAgentSeedUpgrade } from '../agents/boot-upgrade.js';
-import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runProductNextCommand, runProductResumeCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runProductStatusCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
+import { runAgentCommand, runApprovalsCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runProductNextCommand, runProductResumeCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runProductStatusCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
 const _promptBuffers = new WeakMap();
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
@@ -110,8 +110,6 @@ export async function dispatchCliAsync(argv, environment) {
     }
     if (area === 'doctor')
         return runDoctorAliasCommand(parsed, environment);
-    if (area === 'code')
-        return runCodeCliCommand(parsed, environment);
     if (area === 'init')
         return runInitCommand(parsed, environment);
     if (area === 'setup' && command === 'apply')
@@ -228,10 +226,5 @@ function validateCommand(area, command) {
     if (area === 'verification') {
         return command === 'plan' || command === 'report' ? { ok: true } : { ok: false, message: `Unknown verification command: ${command}` };
     }
-    if (area === 'code') {
-        return command === 'inspect' || command === 'plan' || command === 'craft' || command === 'sdd'
-            ? { ok: true }
-            : { ok: false, message: `Unknown code command: ${command}` };
-    }
     return { ok: false, message: `Unknown command area: ${area}` };
 }

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

@@ -44,7 +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 commandHeading = next.blocked ? 'Recovery/diagnostic command' : 'Continuation guidance command';
     const lines = [
         'Next',
         ...next.next.map((line) => `- ${line}`),
@@ -64,7 +64,7 @@ export function renderProductNext(next) {
 }
 function productCommandHeading(status) {
     if (status.sddNextStatus === 'runnable')
-        return 'Manual fallback command';
+        return 'Continuation guidance command';
     return 'Recovery/diagnostic command';
 }
 function relatedRunContextLines(relatedRunContext, includeTrailingBlank) {

package/dist/cli/sdd-renderer.js

@@ -5,13 +5,13 @@ export function renderSddStatus(input) {
     const blockers = input.status.phases.filter((phase) => phase.present && phase.accepted !== true);
     const complete = input.status.phases.length > 0 && input.status.phases.every((phase) => phase.present && phase.accepted === true);
     const statusLabel = complete ? 'complete' : input.status.nextReadyPhase === undefined ? 'blocked' : 'ready';
-    const directPhaseCommand = input.status.nextReadyPhase === undefined ? undefined : `vgxness code sdd ${input.status.change} ${input.status.nextReadyPhase} --save-artifact`;
+    const directPhaseCommand = input.status.nextReadyPhase === undefined ? undefined : `vgxness sdd continue --project ${input.project} --change ${input.status.change}`;
     const recommendedAction = complete
         ? 'No next SDD phase remains for this change.'
         : input.status.nextReadyPhase === undefined
             ? 'Review blockers or accept present draft artifacts before continuing.'
             : `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 commandLabel = directPhaseCommand === undefined ? 'Diagnostic command' : 'Continuation guidance command';
     const lines = [
         'SDD Status',
         `Project: ${input.project}`,
@@ -39,9 +39,9 @@ export function renderSddNext(input) {
     const guidance = input.decision.blockerGuidance ?? [];
     const phase = input.decision.nextPhase ?? 'none';
     const commandGuidance = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
-        ? `vgxness code sdd ${input.decision.change} ${input.decision.nextPhase} --save-artifact`
+        ? `vgxness sdd continue --project ${input.project} --change ${input.decision.change}`
         : `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 commandLabel = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined ? 'Continuation guidance 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;
@@ -76,7 +76,7 @@ export function renderSddNext(input) {
     return `${lines.join('\n')}\n`;
 }
 export function renderSddContinuationPlan(plan) {
-    const suggestedCommandLabel = plan.status === 'runnable' ? 'Manual fallback command' : 'Diagnostic command';
+    const suggestedCommandLabel = plan.status === 'runnable' ? 'Continuation guidance command' : 'Diagnostic command';
     const lines = [
         'SDD Continue (read-only)',
         `Project: ${plan.project}`,

package/dist/mcp/client-install-claude-code.js

@@ -129,7 +129,7 @@ function writeProjectMemory(plan) {
 async function applyUserInstall(input, plan, server, writtenPaths, backups) {
     const existingTargets = plan.targets.filter((target) => target.kind !== 'cli-mcp-registration' && (target.action === 'merge' || target.action === 'update-vgxness' || target.action === 'append-managed-block' || target.action === 'update-managed-block'));
     for (const target of existingTargets) {
-        const backup = createBackup(target.path, target.kind === 'user-memory' ? 'user-memory' : 'config', 'user');
+        const backup = createBackup(target.path, target.kind === 'user-memory' ? 'user-memory' : 'config', 'user', input.env?.HOME);
         if (!backup.ok)
             return refusal('backup_failed', backup.error.message, plan, server, writtenPaths, backups);
         backups.push(toBackupSummary(backup.value));
@@ -173,7 +173,7 @@ function writeUserMemory(env, plan) {
     const after = inspectClaudeUserMemory(env);
     return after.status === 'managed-current' ? { ok: true, value: target.path } : { ok: false, error: { code: 'validation_failed', message: 'Claude user memory did not validate as managed-current after write.' } };
 }
-function createBackup(path, kind, scope = 'project') {
+function createBackup(path, kind, scope = 'project', allowedManagedHome) {
     return createManagedProviderConfigBackup({
         targetPath: path,
         provider: 'claude',
@@ -181,6 +181,7 @@ function createBackup(path, kind, scope = 'project') {
         createdByOperation: 'mcp-client-install-claude-code',
         reason: kind === 'project-memory' ? 'pre-project-memory-update-safety' : kind === 'user-memory' ? 'pre-user-memory-update-safety' : 'pre-merge-safety',
         description: kind === 'project-memory' ? 'Backup existing Claude Code project memory before appending or updating the VGXNESS managed block.' : kind === 'user-memory' ? 'Backup existing Claude Code user memory before appending or updating the VGXNESS managed block.' : 'Backup existing Claude Code config before merging VGXNESS MCP or agent configuration.',
+        ...(allowedManagedHome !== undefined ? { allowedManagedHome } : {}),
     });
 }
 function refusal(reason, message, plan, server, writtenPaths, backups, cliResult) {

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

@@ -55,7 +55,7 @@ export async function installOpenCodeMcpClient(input) {
     });
     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, plan.bashPermissionPolicy);
-    const backup = createBackup(plan.targetPath, plan.scope);
+    const backup = createBackup(plan.targetPath, plan.scope, input.env?.HOME);
     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, plan.bashPermissionPolicy);
     const config = parsed.value;
@@ -97,7 +97,7 @@ function writeConfig(path, config) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
 }
-function createBackup(path, scope) {
+function createBackup(path, scope, allowedManagedHome) {
     return createManagedProviderConfigBackup({
         targetPath: path,
         provider: 'opencode',
@@ -105,6 +105,7 @@ function createBackup(path, scope) {
         createdByOperation: 'mcp-client-install-opencode',
         reason: 'pre-merge-safety',
         description: 'Backup existing OpenCode config before merging VGXNESS MCP configuration.',
+        ...(allowedManagedHome !== undefined ? { allowedManagedHome } : {}),
     });
 }
 function validateInstalledResult(targetPath, backup, server, databasePath, source, safety, verificationHints, warningMessages, manualTestGuidance, agentPlan, overwriteVgxness = false, bashPermissionPolicy = bashPermissionPolicyFor(agentPlan)) {

package/dist/runs/execution-planning.js

@@ -79,11 +79,11 @@ function conditionRequirements(operation, decision, realpathHardeningRequired, s
     return conditions;
 }
 function planLimitations(operation, decision, strategy, sandbox) {
-    const limitations = ['planning-only: no command, provider tool, worktree, sandbox, directory, or filesystem mutation is performed'];
+    const limitations = ['planning-only: this preflight records an execution plan only; no command, provider tool, worktree, sandbox, directory, or filesystem mutation was performed'];
     if (strategy === 'worktree')
-        limitations.push('worktree is a planned isolation target only; creation is future executor work');
+        limitations.push('worktree is only the planned isolation target; no worktree was created and mutations still require a separate executor or manual worktree');
     if (strategy === 'process-sandbox')
-        limitations.push('process-sandbox is a planned isolation target only; launch/enforcement is future executor work');
+        limitations.push('process-sandbox is only the planned isolation target; no sandbox was launched and execution still requires a separate executor');
     if (decision.decision === 'deny')
         limitations.push(`permission policy denies execution: ${decision.reason}`);
     if (sandbox?.decision === 'rejected')