vgxness 1.14.1 → 1.16.0

package/dist/agents/agent-selector-resolver.js

@@ -0,0 +1,23 @@
+export const agentSelectorNameFallbackCode = 'AGENT_SELECTOR_NAME_FALLBACK';
+export function resolveAgentSelector(input, lookup) {
+    const byId = lookup.getById(input.selector);
+    if (byId.ok)
+        return ok({ agent: byId.value });
+    const byName = lookup.getByName(input.project, input.scope, input.selector);
+    if (byName.ok) {
+        return ok({
+            agent: byName.value,
+            warning: `${agentSelectorNameFallbackCode}: selector "${input.selector}" matched scoped agent name; using canonical agent id "${byName.value.id}" name "${byName.value.name}".`,
+        });
+    }
+    return {
+        ok: false,
+        error: {
+            code: 'not_found',
+            message: `Agent selector not found: "${input.selector}". Looked up registry id first, then scoped agent name for project "${input.project}" and scope "${input.scope}". Accepted forms: canonical agent id or agent name within the requested project/scope.`,
+        },
+    };
+}
+function ok(value) {
+    return { ok: true, value };
+}

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 = 11;
+export const canonicalPromptContractVersion = 12;
 export const canonicalSddSubagentNames = [
     'vgxness-sdd-explore',
     'vgxness-sdd-propose',
@@ -146,50 +146,52 @@ export function createCanonicalOpenCodeSddSubagentPrompt(name) {
  * This feeds the OpenCode default config and Claude generated agent files; it is
  * intentionally separate from registry/seed instructions below.
  */
-export const canonicalOpenCodeManagerPrompt = `# VGXNESS Manager - compact SDD orchestrator
+export const canonicalOpenCodeManagerPrompt = `# VGXNESS Manager
 
-Bind only to the primary \`vgxness-manager\` agent. Executor agents use their own prompts.
+Bind to \`vgxness-manager\` only. Executors use their own prompts.
 
 ## Role
-Coordinate SDD; keep chat thin, use VGXNESS MCP as durable state, delegate to smallest exact hidden SDD subagent, synthesize evidence. Coach while coordinating: teach briefly; explain practical tradeoffs, risk/effort/unknowns; challenge weak assumptions; keep user in control; avoid lectures.
+Coordinate SDD; keep chat thin, use VGXNESS MCP state, delegate to exact SDD subagent. Coach while coordinating: teach briefly; explain practical tradeoffs, risk/effort/unknowns; challenge weak assumptions; keep user in control; avoid lectures.
 
 ## Non-negotiable governance
-- 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\` 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.
+- VGXNESS uses SQLite artifacts/control-plane; OpenCode as primary provider; artifacts are not openspec files. Do not write to \`openspec/\`.
+- SDD artifact acceptance is human-only. Artifact presence is not acceptance. Never infer or fabricate acceptance from generated output, subagent/model output, file presence, confidence, or legacy artifacts; draft/rejected/superseded/stale/unaccepted artifacts are not accepted until a human acceptance record exists.
+- Before phase advancement, call \`vgxness_sdd_status\`/\`vgxness_sdd_next\` plus \`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 when available. Stop on approval/block; never 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; require 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; excludes 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 mutate provider/global OpenCode config. 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.
 - Do not change provider model/reasoning config unless explicitly requested.
 
 ## Flexible governance routing
-Use the lightest safe path: Tier 0-2 direct; Tier 3 preflight; Tier 4 formal SDD for governance, permissions, acceptance, architecture/security, or cross-surface behavior. Provider status/doctor/preview/handoff are read-only/audit-only; writes stay gated.
+Use lightest safe path: T0-2 direct, T3 preflight, T4 formal SDD for governance, permissions, acceptance, architecture/security, or cross-surface behavior. Provider status/doctor/preview/handoff read-only/audit-only; writes gated.
 
 ## Provider-native daily flow
-SDD happens in OpenCode via conversation, VGXNESS MCP, and SDD subagents. No terminal SDD phase commands for normal flow. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
+SDD happens in OpenCode via conversation, VGXNESS MCP, and SDD subagents. No terminal SDD phase commands. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
 
 ## 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.
-- 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 phase with \`vgxness_agent_resolve\`. Preview mode does not execute a provider or write provider config for \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, or \`vgxness_skill_payload\`. Use \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` requires explicit human authorization.
-- Runs/recovery: use \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\` for run work; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, and close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect before advice; never pass runId as approvalId. Follow safe \`recommendedActions[]\`.
-- Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report \`providerEvidence.evidenceLevel\`/\`hostToolPresenceVerified\` limits.
+- 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 session id and actor \`manager\`; if no id, do not invent one and summarize.
+- Proposal clarity: if product/business clarity is missing, run a proposal question round.
+- SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; list/read with \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`; prefer \`payloadMode: "compact"\` so primary context stays clean; use verbose only when required, preferably inside the delegated phase subagent. Save with \`vgxness_sdd_save_artifact\` after the right flow. Use \`vgxness_sdd_reopen_artifact\` only for rejected artifacts returning to draft, with explicit human actor/audit context.
+- Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, run exactly \`spec -> design -> tasks\` without extra human confirmation via exact subagents; save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Not 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/after; generated spec/design drafts can feed design/tasks but remain unaccepted.
+- Acceptance/readiness: check SDD status/readiness for the exact project/change/phase; confirm explicit human acceptance; call \`vgxness_sdd_accept_artifact\` directly with audit context (\`acceptedBy.type: "human"\`, non-empty \`acceptedBy.id\`, runId, agentId); 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, audit warnings.
+- Memory: \`vgxness_memory_search\`/\`vgxness_memory_get\` for prior work/unclear context; \`vgxness_memory_save\` for durable discoveries, decisions, bug fixes, config, patterns, or preferences; \`vgxness_memory_update\` only to correct/evolve a known id. Do not duplicate full SDD artifacts as memory.
+- Agents/skills: Skill registry index-first; resolve skills by registry, exact path, and task context; read exact paths; do not invent summaries. Resolve phase with \`vgxness_agent_resolve\`. Preview mode does not execute a provider or write provider config for \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, or \`vgxness_skill_payload\`. \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` needs explicit human authorization.
+- Runs/recovery: \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\`; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect; never pass runId as approvalId. Follow safe \`recommendedActions[]\`.
+- Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report \`providerEvidence.evidenceLevel\` and \`hostToolPresenceVerified\` limits.
 
 ## 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; 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.
+- Simple answer: inline; no run by default.
+- Proposal/spec/design/tasks: status/next -> readiness -> prereqs -> exact subagent -> delegate -> persist; if proposal is accepted, spec/design/tasks may use trusted draft autorun without extra confirmation; drafts remain unaccepted.
+- Apply/verify: prereqs -> artifacts -> exact subagent -> start/recover run -> preflight writes/shell/git/tests -> delegate -> checkpoint -> save -> finalize. Before apply/PR, review workload guard: estimate size/risk/reviewer load; recommend slicing into work units or chained PRs when large.
+- Config/provider/prompt change: inspect manager/profile/payload first; persistence needs 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. 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.
+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 phase mapping.
 
 ## Output
-Be concise: delegated work, results, files/decisions, evidence/tests, risks, next step.`;
+Be concise.`;
 /**
  * Registry/seed instructions for the manager agent definition.
  * These feed the canonical manifest, checked-in seed, boot upgrade, registry

package/dist/cli/cli-help.js

@@ -12,6 +12,7 @@ Areas:
   init [--project <name>] [--provider opencode|claude|none] [--scope user|global|personal] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents] [--json]
   setup plan [--project <name>] [--provider opencode|claude|none] [--scope user|global|personal] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents] [--json]
   setup apply --yes [--project <name>] [--provider opencode|claude|none] [--scope user|global|personal] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents]
+  setup reinstall [--yes] [--project <name>] [--scope user|global|personal] [--db global|project-local|custom|<path>] [--db-path <path>] [--mode mcp-only|mcp-plus-agents] [--json]
   setup backup list --provider opencode [--scope project|user|global] [--target <path>] [--json]
   setup rollback --backup <path> [--preview|--yes] [--json]
   setup status [--project <name>] [--scope project|personal] [--db <path>] [--json]
@@ -23,7 +24,7 @@ Areas:
   Next answers "what should I do now?" with a shorter next-action view.
   Resume answers "how do I continue interrupted work?" with run inspection guidance.
   Without --change or --run-id they stay orientation-only and do not open local memory; with --change or --run-id they read SQLite read-only. Pass --json for automation.
-  Setup plan/init default to human-readable read-only output; pass --json for automation. VGX-managed provider configuration is user-global only for OpenCode and Claude; setup apply writes provider config only with --yes and uses the global user DB plus mcp-plus-agents by default.
+  Setup plan/init default to human-readable read-only output; pass --json for automation. VGX-managed provider configuration is user-global only for OpenCode and Claude; setup apply writes provider config only with --yes and uses the global user DB plus mcp-plus-agents by default. setup reinstall is the explicit safe overwrite path: it replaces only VGXNESS-managed OpenCode entries, preserves unrelated config, and still requires --yes to write.
   Setup status defaults to human-readable read-only output; pass --json for automation. It never writes provider config or executes providers.
   Doctor defaults to human-readable output; pass --json for automation.
   Verification plans are read-only recommendations only; they never execute commands, write provider config, persist results, mutate SDD artifacts, or infer acceptance.
@@ -40,8 +41,9 @@ Areas:
   Seed loading writes only to the local registry; it does not install or write .opencode/, .claude/, or provider config.
 
   opencode preview --provider opencode (--agent <name> | --agent-id <id>) --project <name> --change <id> --phase <phase> [--scope project|personal]
+  OpenCode CLI preview prints the legacy injection preview JSON for inspection; MCP opencode_handoff_preview is the read-only conversation handoff preview and can be paired with opencode_manager_payload for verbose manager payload details.
 
-  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.
+  Interactive Home TUI opens from \`vgxness\` in a real terminal; non-TTY use prints safe guidance. 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.
@@ -81,6 +83,8 @@ Areas:
   skills detach (--id <id> | --project <name> --name <name>) --target-type agent|subagent|workflow-phase|provider-adapter|intent-signal --target-key <key>
   skills record-usage (--id <id> | --project <name> --name <name>) --outcome selected|injected|helped|failed|neutral [--run-id <id>]
   skills resolve [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--intent-signals a,b] [--provider <name>] [--run <id>] [--record-usage selected|injected]
+  skills index --project <name> --scope project|personal
+  skills export --project <name> --scope project|personal
   skills status --project <name> [--scope project|personal] [--provider opencode] [--mode agent|subagent] [--agent <name-or-id>]
   skills payload [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--intent-signals a,b] [--provider <name>]
   skills propose (--id <id> | --project <name> --name <name>) --proposed-version <version> --source-kind path|url|inline --rationale <text>
@@ -91,14 +95,15 @@ Areas:
   skills list-evaluation-results [--scenario <id>] [--skill-id <id>] [--proposal <id>] [--version-id <id>] [--evaluator <actor>] [--status passed|failed|needs-review|not-applicable]
   skills get-proposal --proposal <id>
   skills submit-proposal|approve-proposal|reject-proposal|cancel-proposal|apply-proposal --proposal <id> --actor <name> [--reason <text>]
+  Skills export returns a read-only registry manifest for inspection/automation only; it is not backup, restore, import, or provider/native skill installation.
 
   subagents register --parent-agent-id <id> --project <name> --name <name> --description <text> --instructions <text>
   subagents register --file <subagent.json>
   subagents list --parent-agent-id <id>
   subagents get --id <id> | --project <name> --name <name> [--scope project|personal]
 
-  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.
+  No args opens the read-only Home TUI in an interactive terminal; non-TTY prints safe guidance and exits 0 without writing provider config.
+  Setup can run as an interactive TUI or as CLI commands: use setup plan/status for read-only guidance, setup apply --yes for first install, and setup reinstall --yes only after reviewing the VGXNESS-managed overwrite warning.
   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.
 
@@ -139,6 +144,7 @@ Areas:
   runs finish --run-id <id> --status completed|failed|blocked|cancelled --outcome <outcome> [--reason <text>]
   runs permission-check --run-id <id> --category <category> --operation <name> [--path <path>] [--agent-id <id>] [--destructive] [--external] [--privileged] [--ambiguous]
   runs preflight --run-id <id> --category <category> --operation <name> [--workspace <path>] [--path <path>] [--provider-tool <name>] [--agent-id <id>] [--destructive] [--external] [--privileged] [--ambiguous]
+  runs preflight output includes workspaceStrategy recommendation JSON and does not create branches, worktrees, or PRs.
   runs approvals --run <run-id>
   runs approve|reject|cancel-approval --approval <id> --actor <name> [--reason <text>]
   runs retry-check --approval <id> [--policy <json>]

package/dist/cli/commands/agent-skill-dispatcher.js

@@ -5,6 +5,8 @@ import { getProviderRenderer } from '../../agents/renderers/index.js';
 import { ManagerProfileOverlayRepository } from '../../agents/repositories/manager-profile-overlays.js';
 import { createAgentRegistryToolHandlers } from '../../harness/tools/agents.js';
 import { runBootSkillSeed } from '../../skills/boot-seed.js';
+import { SkillExportService } from '../../skills/skill-export-service.js';
+import { SkillIndexService } from '../../skills/skill-index-service.js';
 import { SkillRegistryService } from '../../skills/skill-registry-service.js';
 import { SkillStatusService } from '../../skills/skill-status-service.js';
 import { csvFlag, instructionKindFlag, jsonFlag, optionalJsonFlag, optionalModeFlag, optionalScopeFlag, optionalSkillEvaluationResultStatusFlag, optionalSkillImprovementProposalStatusFlag, optionalSkillResolutionUsageFlag, optionalSkillTargetTypeFlag, optionalSkillVersionStatusFlag, optionalStringFlag, requiredFlag, scopeFlag, skillEvaluationResultStatusFlag, skillSourceFromFlags, skillTargetTypeFlag, skillUsageOutcomeFlag, } from '../cli-flags.js';
@@ -88,6 +90,17 @@ function skillStatusInput(flags) {
         },
     };
 }
+function skillIndexInput(flags) {
+    const project = requiredFlag(flags, 'project');
+    const scope = requiredFlag(flags, 'scope');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== 'project' && scope.value !== 'personal')
+        return validationFailure('--scope must be project or personal');
+    return { ok: true, value: { project: project.value, scope: scope.value } };
+}
 function skillPayloadInput(flags) {
     if (flags['record-usage'] !== undefined)
         return validationFailure('skills payload is read-only; use skills resolve with --record-usage for explicit usage writes');
@@ -504,6 +517,18 @@ export function runSkillCommand(command, parsed, database, environment) {
         const input = resolveSkillsInput(parsed.flags);
         return input.ok ? jsonResult(registry.resolveSkills(input.value)) : resultFailure(input);
     }
+    if (command === 'index') {
+        const input = skillIndexInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        return jsonResult(new SkillIndexService(registry).getIndex(input.value));
+    }
+    if (command === 'export') {
+        const input = skillIndexInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        return jsonResult(new SkillExportService(new SkillIndexService(registry)).export(input.value));
+    }
     if (command === 'status') {
         const input = skillStatusInput(parsed.flags);
         if (!input.ok)
@@ -672,4 +697,4 @@ export function runSkillCommand(command, parsed, database, environment) {
     return usageFailure(`Unknown skills command: ${command}`);
 }
 // Re-export helpers for external use
-export { expectAgentMode, managerProfileInput, managerProfileOverlayInput, proposalActorInput, registerPayload, resolveAgentForRender, resolveAgentsInput, resolveSkill, resolveSkillsInput, resolveSubagentsForRender, scenarioNameFlag, skillPayloadInput, skillStatusInput, validateFileInputIsComplete, };
+export { expectAgentMode, managerProfileInput, managerProfileOverlayInput, proposalActorInput, registerPayload, resolveAgentForRender, resolveAgentsInput, resolveSkill, resolveSkillsInput, resolveSubagentsForRender, scenarioNameFlag, skillPayloadInput, skillIndexInput, skillStatusInput, validateFileInputIsComplete, };

package/dist/cli/commands/index.js

@@ -4,6 +4,6 @@ export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand
 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, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';
+export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runHomeTuiCommand, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupReinstallApplyCommand, runSetupReinstallCommand, 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

@@ -2,8 +2,8 @@ import { okText } from '../cli-help.js';
 function defaultNoArgsGuidance() {
     return ([
         '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`.',
+        'In a real terminal, `vgxness` opens the read-only Home TUI. In non-TTY contexts, use explicit CLI commands.',
+        'Next: use `vgxness setup plan`, `vgxness init --plan`, `vgxness status`, `vgxness next`, or `vgxness --help`.',
     ].join('\n') + '\n');
 }
 export async function runDefaultInteractiveEntrypoint(environment) {

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

@@ -14,6 +14,9 @@ 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 { runHomeTuiController } from '../home-tui-controller.js';
+import { runSetupTuiController } from '../setup-tui-controller.js';
+import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
 function renderSetupRollbackApply(result, parsed) {
     if (parsed.flags.json === true)
         return jsonResult(result);
@@ -34,6 +37,8 @@ export function runSetupLifecycleCommand(parsed, environment) {
         return runSetupPlanCommand(parsed, environment);
     if (area === 'setup' && command === 'apply')
         return usageFailure('setup apply is available through the async CLI entrypoint; run vgxness setup apply --yes from the installed CLI.');
+    if (area === 'setup' && command === 'reinstall')
+        return runSetupReinstallCommand(parsed, environment);
     if (area === 'setup' && command === 'backup')
         return runSetupBackupCommand(parsed, environment);
     if (area === 'setup' && command === 'rollback')
@@ -70,6 +75,16 @@ export function runSetupPlanCommand(parsed, environment) {
         return jsonResult(plan);
     return okText(`${renderSetupPlan(plan.value)}\n`);
 }
+export function runSetupReinstallCommand(parsed, environment) {
+    const reinstallParsed = withReinstallFlags(parsed);
+    const input = setupPlanInputFromFlags(reinstallParsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const plan = createSetupPlan(input.value);
+    if (!plan.ok || parsed.flags.json === true)
+        return jsonResult(plan);
+    return okText(`${renderSetupReinstallPreview(plan.value)}\n`);
+}
 export function runSetupRollbackCommand(parsed, environment) {
     const backupPath = optionalStringFlag(parsed.flags, 'backup');
     if (backupPath === undefined)
@@ -126,6 +141,15 @@ export async function runSetupApplyCommand(parsed, environment) {
     const applied = await applySetupPlanInput(input.value, environment);
     return applied.ok ? jsonResult({ ok: true, value: applied.value }) : resultFailure(applied);
 }
+export async function runSetupReinstallApplyCommand(parsed, environment) {
+    if (parsed.flags.yes !== true)
+        return usageFailure('setup reinstall rewrites VGXNESS-managed provider entries and requires explicit confirmation with --yes. Unrelated OpenCode config is preserved. No provider config was written.');
+    const input = setupPlanInputFromFlags(withReinstallFlags(parsed), environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const applied = await applySetupPlanInput(input.value, environment);
+    return applied.ok ? jsonResult({ ok: true, value: applied.value }) : resultFailure(applied);
+}
 export async function applySetupPlanInput(input, environment) {
     const plan = createSetupPlan(input);
     if (!plan.ok)
@@ -208,6 +232,22 @@ export function setupPlanInputFromFlags(parsed, environment) {
         },
     };
 }
+function withReinstallFlags(parsed) {
+    return { ...parsed, flags: { ...parsed.flags, 'overwrite-vgxness': true, reinstall: true } };
+}
+function renderSetupReinstallPreview(plan) {
+    return [
+        'VGXNESS Setup Reinstall Preview',
+        '',
+        'Warning: reinstall replaces only VGXNESS-managed OpenCode entries: mcp.vgxness and known VGXNESS agents/instructions.',
+        'Unrelated OpenCode config is preserved. This is not a full opencode.json reset.',
+        'A managed backup is planned before existing user-global OpenCode config is changed.',
+        '',
+        renderSetupPlan(plan).trimEnd(),
+        '',
+        'Apply after review: vgxness setup reinstall --yes',
+    ].join('\n');
+}
 function defaultWizardInput(environment) {
     return {
         project: environment.cwd
@@ -350,14 +390,37 @@ export function resolveInitDispatchMode(parsed, _environment) {
     return 'setup-plan';
 }
 export async function runInitCommand(parsed, environment) {
+    if (shouldRunSetupTui(parsed, environment)) {
+        const input = setupPlanInputFromFlags(parsed, environment);
+        if (!input.ok)
+            return resultFailure(input);
+        const plan = createSetupPlan(input.value);
+        if (!plan.ok)
+            return resultFailure(plan);
+        return runSetupTuiController({ environment, plan: plan.value });
+    }
     return runInitCommandWithoutSetupTui(parsed, environment);
 }
+export async function runHomeTuiCommand(parsed, environment) {
+    const input = setupPlanInputFromFlags(parsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const plan = createSetupPlan(input.value);
+    if (!plan.ok)
+        return resultFailure(plan);
+    return runHomeTuiController({ environment, plan: plan.value });
+}
 export async function runInitCommandWithoutSetupTui(parsed, environment) {
     const mode = resolveInitDispatchMode(parsed, environment);
     if (mode === 'setup-plan')
         return runSetupPlanCommand(parsed, environment);
     return runSetupApplyCommand({ ...parsed, flags: { ...parsed.flags, yes: true } }, environment);
 }
+function shouldRunSetupTui(parsed, environment) {
+    if (parsed.flags.plan === true || parsed.flags.json === true || parsed.flags.yes === true)
+        return false;
+    return canRunInteractiveTui(environment.stdin, environment.stdout);
+}
 export function createSetupLifecycleService(input) {
     return new SetupLifecycleService({
         store: () => (input.opened.ok ? { ok: true, value: { path: input.databasePath } } : input.opened),

package/dist/cli/dispatcher.js

@@ -5,7 +5,8 @@ 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, 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, runHomeTuiCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runProductNextCommand, runProductResumeCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupReinstallApplyCommand, runSetupRollbackCommand, runProductStatusCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
+import { canRunInteractiveTui } from './tui/terminal-capabilities.js';
 const _promptBuffers = new WeakMap();
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
@@ -55,7 +56,8 @@ export function dispatchCli(argv, environment) {
     const opened = openCliDatabase(databasePath);
     if (!opened.ok)
         return resultFailure(opened);
-    runBootAgentSeedUpgrade(opened.value, environment.env);
+    if (!skipsBootAgentSeedUpgrade(area, command))
+        runBootAgentSeedUpgrade(opened.value, environment.env);
     try {
         if (isWorkflowId(area) && command === 'run')
             return runWorkflowRunCommand(area, parsed, opened.value);
@@ -89,14 +91,20 @@ export function dispatchCli(argv, environment) {
         opened.value.close();
     }
 }
+function skipsBootAgentSeedUpgrade(area, command) {
+    return area === 'skills' && (command === 'index' || command === 'export');
+}
 function isGlobalVersionRequest(argv) {
     return argv.length === 1 && (argv[0] === '--version' || argv[0] === '-v');
 }
 export async function dispatchCliAsync(argv, environment) {
     const parsed = parseArgs(argv);
     const [area, command] = parsed.positionals;
-    if (argv.length === 0)
+    if (argv.length === 0) {
+        if (canRunInteractiveTui(environment.stdin, environment.stdout))
+            return runHomeTuiCommand({ positionals: [], flags: {} }, environment);
         return runDefaultInteractiveEntrypoint(environment);
+    }
     if (area === 'mcp') {
         if (!command)
             return usageFailure('Missing command for mcp');
@@ -114,6 +122,8 @@ export async function dispatchCliAsync(argv, environment) {
         return runInitCommand(parsed, environment);
     if (area === 'setup' && command === 'apply')
         return runSetupApplyCommand(parsed, environment);
+    if (area === 'setup' && command === 'reinstall' && parsed.flags.yes === true)
+        return runSetupReinstallApplyCommand(parsed, environment);
     if (area === 'setup' && command === 'rollback')
         return runSetupRollbackCommand(parsed, environment);
     return dispatchCli(argv, environment);
@@ -173,6 +183,8 @@ function validateCommand(area, command) {
             command === 'detach' ||
             command === 'record-usage' ||
             command === 'resolve' ||
+            command === 'index' ||
+            command === 'export' ||
             command === 'status' ||
             command === 'payload' ||
             command === 'propose' ||
@@ -219,7 +231,7 @@ function validateCommand(area, command) {
         return command === 'preview' ? { ok: true } : { ok: false, message: `Unknown opencode command: ${command}` };
     }
     if (area === 'setup') {
-        return command === 'status' || command === 'plan' || command === 'apply' || command === 'backup' || command === 'rollback'
+        return command === 'status' || command === 'plan' || command === 'apply' || command === 'reinstall' || command === 'backup' || command === 'rollback'
             ? { ok: true }
             : { ok: false, message: `Unknown setup command: ${command}` };
     }