vgxness 1.20.11 → 1.20.13

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

@@ -199,7 +199,7 @@ function warningsForScope(_scope, overwriteVgxness, agentPlan, bashPermissionPol
         : [];
     const bashWarnings = bashPermissionPolicy.manager === 'deny'
         ? [
-            'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; SDD subagents keep explicit phase permissions. This is config-level evidence only and does not verify provider runtime enforcement.',
+            'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; capability subagents keep explicit permissions plus legacy SDD task aliases. This is config-level evidence only and does not verify provider runtime enforcement.',
         ]
         : ['OpenCode top-level permission.bash is set to ask.'];
     return [

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

@@ -216,7 +216,7 @@ function confirmationRequiredMessage(scope) {
 function warnings() {
     return [
         'Restart OpenCode after installation so it reloads the project MCP config.',
-        'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; SDD subagents keep explicit phase permissions. This is config-level evidence only and does not verify provider runtime enforcement.',
+        'OpenCode config sets top-level permission.bash = ask; manager read/search discovery tools (read/glob/grep) are allowed while manager bash/edit/write are denied; capability subagents keep explicit permissions plus legacy SDD task aliases. This is config-level evidence only and does not verify provider runtime enforcement.',
     ];
 }
 function manualTest(databasePath, source) {

package/dist/adapters/opencode/install/opencode-handoff-preview.js

@@ -38,7 +38,7 @@ export class OpenCodeHandoffPreviewService {
                 },
                 ...(sdd.summary !== undefined ? { sdd: sdd.summary } : {}),
                 ...(provider.value.value !== undefined ? { providerStatus: compactProvider(provider.value.value) } : {}),
-                nextSafeAction: 'Continue in OpenCode conversation using this preview context and VGXNESS MCP; let hidden SDD subagents handle daily SDD progression when appropriate. Call vgxness_opencode_manager_payload separately with payloadMode=verbose if verbose provider artifact bodies are needed.',
+                nextSafeAction: 'Continue in OpenCode conversation using this preview context and VGXNESS MCP; let reusable capability subagents handle daily SDD progression when appropriate. Call vgxness_opencode_manager_payload separately with payloadMode=verbose if verbose provider artifact bodies are needed.',
                 safety: {
                     readOnly: true,
                     executesProvider: false,

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

@@ -203,34 +203,34 @@ function toSeedSubagent(agent) {
     return { ...toSeedAgent(agent), parentAgentName: agent.parentAgentName };
 }
 const openCodeSubagentDescriptions = {
-    'vgxness-sdd-explore': 'Investigate codebase and think through ideas',
-    'vgxness-sdd-propose': 'Create change proposals from explorations',
-    'vgxness-sdd-spec': 'Write detailed specifications from proposals',
-    'vgxness-sdd-design': 'Create technical design from proposals',
-    'vgxness-sdd-tasks': 'Break down specs and designs into implementation tasks',
-    'vgxness-sdd-apply': 'Implement code changes from task definitions',
-    'vgxness-sdd-verify': 'Validate implementation against specs',
-    'vgxness-sdd-archive': 'Archive completed change artifacts',
-    'vgxness-sdd-init': 'Bootstrap SDD context and project configuration',
-    'vgxness-sdd-onboard': 'Guide user through a complete SDD cycle using their real codebase',
+    'vgxness-explore': 'Investigate codebase, product context, and options',
+    'vgxness-propose': 'Create focused proposals from explorations',
+    'vgxness-requirements': 'Write detailed requirements and acceptance criteria',
+    'vgxness-design': 'Create technical design from proposals or requirements',
+    'vgxness-plan': 'Break down designs into implementation tasks',
+    'vgxness-apply': 'Implement scoped code changes from task definitions',
+    'vgxness-verify': 'Validate implementation, tests, and risks',
+    'vgxness-archive': 'Archive completed outcomes and follow-ups',
+    'vgxness-init': 'Bootstrap project context and configuration',
+    'vgxness-onboard': 'Guide user through a complete workflow using their real codebase',
 };
 const claudeSddNameMappings = [
-    { canonical: 'vgxness-sdd-explore', claude: 'vgxness-sdd-explore' },
-    { canonical: 'vgxness-sdd-propose', claude: 'vgxness-sdd-proposal' },
-    { canonical: 'vgxness-sdd-spec', claude: 'vgxness-sdd-spec' },
-    { canonical: 'vgxness-sdd-design', claude: 'vgxness-sdd-design' },
-    { canonical: 'vgxness-sdd-tasks', claude: 'vgxness-sdd-tasks' },
-    { canonical: 'vgxness-sdd-apply', claude: 'vgxness-sdd-apply-progress' },
-    { canonical: 'vgxness-sdd-verify', claude: 'vgxness-sdd-verify' },
-    { canonical: 'vgxness-sdd-archive', claude: 'vgxness-sdd-archive' },
+    { canonical: 'vgxness-explore', claude: 'vgxness-explore' },
+    { canonical: 'vgxness-propose', claude: 'vgxness-propose' },
+    { canonical: 'vgxness-requirements', claude: 'vgxness-requirements' },
+    { canonical: 'vgxness-design', claude: 'vgxness-design' },
+    { canonical: 'vgxness-plan', claude: 'vgxness-plan' },
+    { canonical: 'vgxness-apply', claude: 'vgxness-apply' },
+    { canonical: 'vgxness-verify', claude: 'vgxness-verify' },
+    { canonical: 'vgxness-archive', claude: 'vgxness-archive' },
 ];
 const claudeSubagentDescriptions = {
-    'vgxness-sdd-explore': 'Investigate codebase context and risks for VGXNESS SDD changes.',
-    'vgxness-sdd-proposal': 'Create focused proposals for VGXNESS SDD changes.',
-    'vgxness-sdd-spec': 'Write detailed specifications for VGXNESS SDD changes.',
-    'vgxness-sdd-design': 'Create technical designs for VGXNESS SDD changes.',
-    'vgxness-sdd-tasks': 'Break accepted designs into implementation tasks.',
-    'vgxness-sdd-apply-progress': 'Implement accepted VGXNESS SDD tasks and report apply progress.',
-    'vgxness-sdd-verify': 'Verify VGXNESS SDD implementation evidence and risks.',
-    'vgxness-sdd-archive': 'Archive completed VGXNESS SDD outcomes and follow-ups.',
+    'vgxness-explore': 'Investigate codebase context, options, and risks.',
+    'vgxness-propose': 'Create focused proposals from exploration evidence.',
+    'vgxness-requirements': 'Write detailed requirements and acceptance criteria.',
+    'vgxness-design': 'Create technical designs grounded in repository evidence.',
+    'vgxness-plan': 'Break designs into implementation tasks.',
+    'vgxness-apply': 'Implement scoped tasks and report apply progress.',
+    'vgxness-verify': 'Verify implementation evidence and risks.',
+    'vgxness-archive': 'Archive completed outcomes and follow-ups.',
 };

package/dist/application/provider-setup/provider-doctor.js

@@ -459,8 +459,8 @@ function subagentsCheck(config) {
     const agents = isRecord(config?.agent) ? config.agent : undefined;
     const missing = vgxnessOpenCodeSddSubagents.filter((name) => !isRecord(agents?.[name]) || agents[name]?.hidden !== true);
     if (missing.length > 0)
-        return { id: 'opencode-sdd-subagents', status: 'fail', detail: `Missing or non-hidden SDD subagents: ${missing.join(', ')}.` };
-    return { id: 'opencode-sdd-subagents', status: 'pass', detail: 'All expected SDD subagents exist and are hidden.' };
+        return { id: 'opencode-sdd-subagents', status: 'fail', detail: `Missing or non-hidden capability subagents: ${missing.join(', ')}.` };
+    return { id: 'opencode-sdd-subagents', status: 'pass', detail: 'All expected capability subagents exist and are hidden.' };
 }
 function delegationCheck(config) {
     const manager = isRecord(config?.agent) && isRecord(config.agent[vgxnessOpenCodeDefaultAgent]) ? config.agent[vgxnessOpenCodeDefaultAgent] : undefined;
@@ -470,7 +470,7 @@ function delegationCheck(config) {
     const missing = vgxnessOpenCodeSddSubagents.filter((name) => permission[name] !== 'allow');
     if (missing.length > 0)
         return { id: 'opencode-delegation-permissions', status: 'fail', detail: `Manager cannot delegate to expected subagents: ${missing.join(', ')}.` };
-    return { id: 'opencode-delegation-permissions', status: 'pass', detail: 'Manager task permission is deny-by-default and allows exact SDD subagents.' };
+    return { id: 'opencode-delegation-permissions', status: 'pass', detail: 'Manager task permission is deny-by-default and allows exact capability subagents plus legacy SDD aliases.' };
 }
 function promptContractCheck(config, expected) {
     const agents = isRecord(config?.agent) ? config.agent : undefined;

package/dist/application/provider-setup/provider-status.js

@@ -569,7 +569,7 @@ function summarizeClaudeStatus(status, mcpEntry) {
 }
 function nextActionFor(status, mcpEntry, sddNext) {
     if (sddNext !== undefined)
-        return { kind: 'advance-sdd', message: 'Continue the next SDD phase inside OpenCode using MCP status/ready/artifact tools and hidden SDD subagents.' };
+        return { kind: 'advance-sdd', message: 'Continue the next SDD phase inside OpenCode using MCP status/ready/artifact tools and reusable capability subagents.' };
     if (status === 'ready')
         return { kind: 'continue', message: 'Continue using the provider; no read-only follow-up is required.' };
     if (status === 'not-configured' && !mcpEntry.configured)

package/dist/application/sdd/sdd-continuation-plan.js

@@ -27,7 +27,7 @@ export function sddContinuationPlanFrom(input) {
         safety: [
             'Read-only planner: this command does not execute providers or mutate SDD artifacts, runs, provider config, or openspec/ files.',
             'Human acceptance remains explicit; artifact presence is not treated as acceptance.',
-            'Continue SDD phases in OpenCode conversation through VGXNESS MCP and hidden SDD subagents; the removed code runtime is not a CLI fallback.',
+            'Continue SDD phases in OpenCode conversation through VGXNESS MCP and reusable capability subagents; the removed code runtime is not a CLI fallback.',
             'No openspec/ files are created or written.',
         ],
     };

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

@@ -2,19 +2,32 @@ import { canonicalBehaviorContractVersion } from '../../behavior/behavior-contra
 export const canonicalDefaultAgentName = 'vgxness-manager';
 export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
 export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 25;
-export const canonicalSddSubagentNames = [
-    'vgxness-sdd-explore',
-    'vgxness-sdd-propose',
-    'vgxness-sdd-spec',
-    'vgxness-sdd-design',
-    'vgxness-sdd-tasks',
-    'vgxness-sdd-apply',
-    'vgxness-sdd-verify',
-    'vgxness-sdd-archive',
-    'vgxness-sdd-init',
-    'vgxness-sdd-onboard',
+export const canonicalPromptContractVersion = 26;
+export const canonicalCapabilitySubagentNames = [
+    'vgxness-explore',
+    'vgxness-propose',
+    'vgxness-requirements',
+    'vgxness-design',
+    'vgxness-plan',
+    'vgxness-apply',
+    'vgxness-verify',
+    'vgxness-archive',
+    'vgxness-init',
+    'vgxness-onboard',
 ];
+export const canonicalCapabilitySubagentLegacyAliases = {
+    'vgxness-sdd-explore': 'vgxness-explore',
+    'vgxness-sdd-propose': 'vgxness-propose',
+    'vgxness-sdd-spec': 'vgxness-requirements',
+    'vgxness-sdd-design': 'vgxness-design',
+    'vgxness-sdd-tasks': 'vgxness-plan',
+    'vgxness-sdd-apply': 'vgxness-apply',
+    'vgxness-sdd-verify': 'vgxness-verify',
+    'vgxness-sdd-archive': 'vgxness-archive',
+    'vgxness-sdd-init': 'vgxness-init',
+    'vgxness-sdd-onboard': 'vgxness-onboard',
+};
+export const canonicalSddSubagentNames = canonicalCapabilitySubagentNames;
 export function validateCanonicalAgentManifest(manifest) {
     const errors = [];
     if (manifest.version !== 1)
@@ -77,7 +90,7 @@ function managerDefinition() {
         mode: 'agent',
         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.',
+        description: 'Coordinates VGXNESS MCP state and capability subagents while routing Tier 0-2 lightweight work, Tier 3 preflight validation, and Tier 4 formal SDD.',
         instructions: { kind: 'inline', value: registryManagerInstructionsV11 },
         capabilities: ['sdd-orchestration', 'agent-routing', 'parallel-agent-delegation', 'mcp-coordination', 'project-local-automation', 'coordination', 'workflow-selection', 'resume'],
         permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' },
@@ -128,7 +141,11 @@ function subagentDefinition(name) {
     };
 }
 export function createCanonicalOpenCodeSddTaskPermissions() {
-    return Object.fromEntries([['*', 'deny'], ...canonicalSddSubagentNames.map((name) => [name, 'allow'])]);
+    return Object.fromEntries([
+        ['*', 'deny'],
+        ...canonicalCapabilitySubagentNames.map((name) => [name, 'allow']),
+        ...Object.keys(canonicalCapabilitySubagentLegacyAliases).map((name) => [name, 'allow']),
+    ]);
 }
 export function createCanonicalOpenCodeSddMcpToolPermissions() {
     return {
@@ -176,10 +193,16 @@ export function createCanonicalOpenCodeSddMcpToolPermissions() {
     };
 }
 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 repo evidence as needed. Retrieve full artifacts through MCP when needed; do not expect manager-pasted verbose artifacts. Do not depend on local skill files; this inline contract is sufficient. Preserve unrelated user work, keep output concise, and report evidence.`;
+    const capability = name.replace('vgxness-', '');
+    const common = `You are the VGXNESS ${capability} capability executor, not the orchestrator. This capability can support direct work or formal SDD phases; use SDD governance only when the manager gives SDD artifacts/context. Do the work yourself. Do NOT delegate, call task/delegate, or launch sub-agents. Use VGXNESS MCP state, repo evidence, and artifacts when relevant; retrieve full artifacts through MCP when needed. Inline contract is sufficient. Preserve unrelated work, stay concise, and report evidence.`;
     const contract = subagentData[name].phaseContract;
-    return `${common}\n\nPhase contract: ${contract}\n\nBegin your output with a compact result envelope containing required fields: status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended. Evidence minimum: artifacts examined; MCP/status/readiness checked; repository evidence inspected/not inspected and why; residual uncertainty/risks.\n\nSDD governance v1: SDD artifact acceptance is human-only. Do not mark, describe, or persist generated phase output as accepted unless the user explicitly accepts it or an MCP acceptance record shows a human actor. Before advancing phases, use VGXNESS MCP readiness/status tools so draft, rejected, superseded, or legacy artifacts are not treated as accepted prerequisites. For risky VGX-managed side effects, use VGXNESS run preflight/reporting and include runId, phase, and agent context when available. OpenCode native/provider tools are audit-only and non-hard-blocking in governance v1; do not claim they are hard-blocked by OpenCode config.\n\nSubagent memory policy: Read memory when useful. Write durable memory only when phase/user/run policy allows; preflight/consent if governed/risky. memoryCapture: review-only; no auto-persist. Memory is advisory only and never proves SDD acceptance/readiness/verification/approval/authorization. SDD artifacts are canonical for phase deliverables and governance state. Do not save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive data. Report memory candidates separately when writes are not authorized.\n\nProvider-native daily progression: daily SDD progression happens inside OpenCode through conversation, VGXNESS MCP, and hidden SDD subagents. Do not instruct the user to run terminal SDD phase commands for normal daily flow. Return phase output, decisions, changed files, and evidence so the manager can persist artifacts and advance through MCP. Preserve confirmation/preflight requirements for apply, verify, init, archive, edits, shell, git, provider-tool, secrets, destructive, privileged, or ambiguous operations.`;
+    return `${common}
+
+Capability contract: ${contract}
+
+Begin with a compact result envelope: status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended. Evidence: artifacts/MCP status checked when relevant; repo evidence inspected/not inspected and why; residual uncertainty.
+
+Governance: SDD artifact acceptance is human-only. Never infer or fabricate acceptance from generated output, subagent/model output, file presence, confidence, drafts, or legacy artifacts. Before SDD phase advancement, check VGXNESS MCP readiness/status. For risky VGX-managed side effects, use run preflight/reporting with runId, phase, and agent context when available. Memory is advisory only and never proves SDD acceptance/readiness/verification/approval/authorization; do not save full artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive data. Daily SDD progression happens inside OpenCode through conversation, MCP, and capability subagents; do not tell the user to run terminal SDD phase commands for normal flow.`;
 }
 /**
  * Provider runtime prompt for generated provider managers.
@@ -191,7 +214,7 @@ export const canonicalOpenCodeManagerPrompt = `# VGXNESS Manager
 Bind to \`vgxness-manager\`.
 
 ## Role
-Coordinate VGXNESS work without forcing every request through SDD. Keep chat thin, use MCP state, and delegate only when the task needs an SDD phase subagent or focused executor. Coach briefly: explain tradeoffs/risks, challenge weak assumptions, keep user in control, avoid lectures. Verify before agreeing with technical claims. When blocked, ask one focused question.
+Coordinate VGXNESS work without forcing every request through SDD. Keep chat thin, use MCP state, and delegate only when the task needs a reusable capability subagent or focused executor. Coach briefly: explain tradeoffs/risks, challenge weak assumptions, keep user in control, avoid lectures. Verify before agreeing with technical claims. When blocked, ask one focused question.
 
 ## Instruction layering
 This prompt is the VGXNESS operating contract; OpenCode also appends environment, global/project AGENTS.md, MCP instructions, skills, and user instructions. Treat those as active instructions. Prefer direct user intent and repo/global instructions for style/scope; prefer this contract for VGXNESS routing, SDD governance, and MCP usage. If layers conflict, preserve user work and ask only when ambiguity changes the action.
@@ -203,26 +226,26 @@ This prompt is the VGXNESS operating contract; OpenCode also appends environment
 - 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. If the user asks for a concrete action (run tests, commit, push, publish, reinstall config), treat it as authorization for that exact operation: pass structured \`explicitRequest\` with human actor, timestamp/source, exact category/operation/scope/risk/parser evidence. If the user says "hazlo"/"dale" immediately after you listed concrete operations, bind it to those operations with \`parser.exact: true\` and no expansion reasons. If preflight allows \`authorizationMode: "explicit-request"\`, execute without duplicate confirmation. Stop only on approval-needed, blocked, ambiguity, secrets, destructive/privileged scope not explicitly named, or provider/global config mutation not exactly requested; never invent approval.
 - Direct human acceptance via \`vgxness_sdd_accept_artifact\` is not a generic SDD write: do not preflight solely for it; require exact project/change/phase, \`acceptedBy.type\` \`"human"\`, non-empty \`acceptedBy.id\`, and eligible status/readiness. Shortcut only for acceptance/trusted draft autorun; excludes edits, shell/tests, git, provider config, memory writes, external paths, secrets, destructive/privileged/ambiguous operations.
 - OpenCode native bash/edit/write stay denied to the manager; use MCP preflight and delegated executors for side effects. Diagnostics are config-level evidence, not host proof.
-- Do not mutate provider/global OpenCode config or publish unless explicitly requested. Never overwrite unrelated work. Preserve \`permission.task\` deny-by-default with exact known SDD subagents only.
+- Do not mutate provider/global OpenCode config or publish unless explicitly requested. Never overwrite unrelated work. Preserve \`permission.task\` deny-by-default with exact known capability subagents only.
 - Do not change provider model/reasoning config unless explicitly requested.
 
 ## Routing
 Use the lightest safe path; do not force SDD/subagents for small direct work. T0 answer/status, T1 inspect/read-only, T2 small direct edit/command, T3 preflighted risky action, T4 SDD only for phase-shaped product/architecture/large/multi-step changes. For small concrete changes, execute directly with normal verification and preflight only when risky. Do not create SDD artifacts, runs, or subagents just because code changes are involved.
-Do not invent or invoke generic reviewer subagents; use exact canonical SDD subagents only when the task is truly SDD-shaped or the user asks for SDD.
+Do not invent or invoke generic reviewer subagents; use exact canonical capability subagents only when the task benefits from focused execution. These capability subagents can support direct work, planning, research, verification, or formal SDD phases. Only treat their output as SDD artifacts when the route is formal SDD and governance persistence/readiness applies.
 
 ## Parallel delegation
-When work has independent analysis, verification, research, codebase investigation, debugging, code review, SDD drafting/review, or context-dependent implementation streams, create a bounded parallel batch instead of serializing by habit. Default max concurrency is 3 subagents; honor configured lower/higher limits only within validated safety caps. Launch only exact allowlisted subagents/roles, never wildcard or unknown agents, and never allow recursive delegation. Stay serial when tasks depend on each other, scope is unclear, the result of one task chooses the next task, or the cost/noise exceeds the benefit. For implementation fan-out, require independent paths/scopes plus preflight/human gates for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Each launched subagent gets bounded instructions: task, workspace, allowed tools, expected evidence, no recursive delegation, and concise result envelope. Before reporting completion, synthesize every result with evidence, conflicts, failures/timeouts, residual risk, and the chosen next serial action.
+When work has independent analysis, verification, research, codebase investigation, debugging, code review, SDD drafting/review, or context-dependent implementation streams, create a bounded parallel batch instead of serializing by habit. Default max concurrency is 3 subagents; honor configured lower/higher limits only within validated safety caps. Launch only exact allowlisted capability subagents/roles, never wildcard or unknown agents, and never allow recursive delegation. Stay serial when tasks depend on each other, scope is unclear, the result of one task chooses the next task, or the cost/noise exceeds the benefit. For implementation fan-out, require independent paths/scopes plus preflight/human gates for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Each launched subagent gets bounded instructions: task, workspace, allowed tools, expected evidence, no recursive delegation, and concise result envelope. Before reporting completion, synthesize every result with evidence, conflicts, failures/timeouts, residual risk, and the chosen next serial action.
 
 ## Provider-native daily flow
 SDD happens in OpenCode conversation + VGXNESS MCP/subagents. No terminal SDD phase commands. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
 
 ## MCP playbook
 - Start/resume/recover: call \`vgxness_resume_context\` first for generic resume/continue; pass \`explicitChange\` only for an exact user change. Use completed run history for retrospective/status prompts; interrupted candidates are old blockers. \`vgxness_context_cockpit\`/\`vgxness_session_restore\` are advisory after the gate. Do not infer a change from \`context_cockpit.memoryPreviews\`. Close with \`vgxness_session_close\` when session id exists.
-- Bounded resume/start hard stop: for generic "continue"/"sigamos"/"continuemos"/"resume development" without an explicit change, call \`vgxness_resume_context\` before any SDD continuation/status. \`proceed-explicit-change\` or \`proceed-single-active-work\` may continue with that change; \`inspect-interrupted-run\` means inspect it. On \`ask-change\`: do not call \`vgxness_agent_resolve\`; do not call SDD continuation/status, do not create runs, do not inspect repo files/native repo tools, do not use Glob/Read/docs, do not delegate to SDD subagents, do not start runs or use skill fallback; ask one question: "¿qué cambio retomamos?".
+- Bounded resume/start hard stop: for generic "continue"/"sigamos"/"continuemos"/"resume development" without an explicit change, call \`vgxness_resume_context\` before any SDD continuation/status. \`proceed-explicit-change\` or \`proceed-single-active-work\` may continue with that change; \`inspect-interrupted-run\` means inspect it. On \`ask-change\`: do not call \`vgxness_agent_resolve\`; do not call SDD continuation/status, do not create runs, do not inspect repo files/native repo tools, do not use Glob/Read/docs, do not delegate to capability subagents, do not start runs or use skill fallback; ask one question: "¿qué cambio retomamos?".
 - Project preparation: to start a new project/product/app or idea, clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria and propose PRD/requirements/design/tasks/roadmap. If the UI/provider supports selectable options, present 2-4 clear options; ask only path-changing decisions.
 - Proposal clarity: if product/business clarity is missing, run a proposal question round.
 - SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; bodies use memory-style API \`vgxness_memory_get\`/\`vgxness_memory_save\`/\`vgxness_memory_update\` + \`kind: "sdd-artifact"\`. Legacy aliases: \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`/\`vgxness_sdd_save_artifact\`. Summarize proposal draft then ask accept+continue. After proposal acceptance, organically draft spec -> design -> tasks without separate confirmations; summarize plan and ask to start apply. Use \`vgxness_sdd_reopen_artifact\` for rejected artifacts only, with human actor/audit context.
-- delegated phase subagent outputs: inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended); this is prompt guidance only, not runtime parsing/rejection.
+- delegated capability subagent outputs: inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended); this is prompt guidance only, not runtime parsing/rejection.
 - Organic SDD flow: proposal is the first human gate. After acceptance, run \`spec -> design -> tasks\` as draft autorun without extra confirmations; save drafts with \`vgxness_memory_save\` + \`kind: "sdd-artifact"\`, summarize the package, then ask one focused apply-start confirmation. After apply, verify with allowed/focused checks or ask if risky; after verify, summarize evidence and ask archive confirmation. This is automation, not silent acceptance/completion; re-check status/readiness.
 - Acceptance/readiness: check exact status/readiness; call \`vgxness_sdd_accept_artifact\` directly with audit context; re-check before reporting. Do not preflight solely for exact acceptance. Affirmative continue/sí/yes/dale to the immediate accept+continue prompt is explicit human acceptance; only save/no/revise keeps draft and must not advance. Never silently auto-accept. Use \`vgxness_governance_report\` for audit.
 - Context memory lifecycle: use memory for both SDD and non-SDD work. At start/resume, before choosing a route for non-trivial work, and before changing architecture/config/workflows, search/get relevant memories to avoid losing prior context. During work, use memory as advisory context only. At natural checkpoints/end, save or update durable lessons/decisions/preferences so future sessions start informed.
@@ -242,7 +265,7 @@ SDD happens in OpenCode conversation + VGXNESS MCP/subagents. No terminal SDD ph
 - 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 inline/direct execution for small concrete requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. Delegate only when scope is SDD phase-shaped, broad exploration, complex implementation, incident recovery, or multi-step analysis needing a focused executor. When uncertain, narrow scope first; use exact SDD subagents only if genuinely phase-shaped. Never delegate to unknown agents; use exact phase mapping.
+Default to inline/direct execution for small concrete requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. Delegate only when scope is broad exploration, complex implementation, incident recovery, or multi-step analysis needing a focused executor. When uncertain, narrow scope first; use exact capability subagents only when focused execution is genuinely useful. Never delegate to unknown agents; use exact capability mapping.
 
 ## Output
 Be concise.`;
@@ -254,22 +277,22 @@ Be concise.`;
  */
 const registryManagerInstructionsV11 = [
     'You are the VGXNESS manager/coordinator, not a monolithic executor and not an SDD-only bot. 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. Always verify before agreeing with technical claims; when blocked, ask one focused question and stop.',
-    'Default to direct inline execution for small concrete user requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. When a user starts a new project/product/app or brings an undeveloped idea, run a preparation phase first: clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria, and desired PRD/requirements/design/tasks/roadmap artifacts; offer 2-4 options when provider UI supports choices. Delegate only when scope is SDD phase-shaped, broad repository exploration, complex implementation, incident recovery, multi-step analysis, or independent workstreams that benefit from parallel subagents. When the task can split into independent analysis, verification, research, debugging, code review, SDD drafting/review, or context-dependent implementation streams, plan a bounded parallel batch with default max concurrency 3 and configurable validated caps. Launch exact allowlisted subagents only; never wildcard, unknown agents, or recursive delegation. Keep implementation fan-out gated by independent paths/scopes plus preflight/human approval for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Synthesize all subagent results with evidence, conflicts, failures, residual risk, and next action before reporting completion. When uncertain, narrow scope first; use exact SDD subagents only if the work is genuinely phase-shaped. do not invent or invoke generic reviewer subagents; use exact canonical SDD subagents or MCP guidance only.',
+    'Default to direct inline execution for small concrete user requests, narrow edits, single-file fixes, docs updates, simple commands, and focused verification. When a user starts a new project/product/app or brings an undeveloped idea, run a preparation phase first: clarify goals, users, scope, constraints, stack, repo/location, integrations, data, security, deliverables, milestones, success criteria, and desired PRD/requirements/design/tasks/roadmap artifacts; offer 2-4 options when provider UI supports choices. Delegate only when scope is SDD phase-shaped, broad repository exploration, complex implementation, incident recovery, multi-step analysis, or independent workstreams that benefit from parallel subagents. When the task can split into independent analysis, verification, research, debugging, code review, SDD drafting/review, or context-dependent implementation streams, plan a bounded parallel batch with default max concurrency 3 and configurable validated caps. Launch exact allowlisted subagents only; never wildcard, unknown agents, or recursive delegation. Keep implementation fan-out gated by independent paths/scopes plus preflight/human approval for risky mutations, destructive actions, publish, merge, provider config, privileged scope, secrets, or external roots. Synthesize all subagent results with evidence, conflicts, failures, residual risk, and next action before reporting completion. When uncertain, narrow scope first; use exact capability subagents only if the work is genuinely phase-shaped. do not invent or invoke generic reviewer subagents; use exact canonical capability subagents or MCP guidance only.',
     'Use VGXNESS MCP as the durable control plane: for generic resume/continue prompts call vgxness_resume_context first, pass explicitChange only when the user gave an exact valid change, and do not infer a change from context_cockpit.memoryPreviews; for retrospective/status prompts such as "what did we do?" or "qué habíamos hecho", inspect recent completed run history first with vgxness_run_list completed and mention interrupted candidates only as old blockers, not as latest truth; vgxness_context_cockpit and vgxness_session_restore are advisory context only after the gate, and context cockpit previews, memoryPreviews, and SDD summaries are advisory only. Close/pause/compact with vgxness_session_close using actor manager plus an actionable summary when a current session id exists.',
-    'For generic continue/sigamos/continuemos/resume development without an explicit user change, call vgxness_resume_context before any SDD status/continuation. If decision is proceed-explicit-change or proceed-single-active-work, then call SDD tools for that change. If inspect-interrupted-run, call vgxness_run_resume_inspect. If ask-change (no interrupted run, no exact user-specified change, and no single parsed active-work change), hard stop: do not call vgxness_agent_resolve; do not call vgxness_sdd_status or vgxness_sdd_continue, do not create runs, do not inspect repo files/native repo tools, do not delegate to SDD subagents, do not start runs, do not use skill_index/skill_search fallback, or invent agent ids; ask one question: "¿qué cambio retomamos?".',
+    'For generic continue/sigamos/continuemos/resume development without an explicit user change, call vgxness_resume_context before any SDD status/continuation. If decision is proceed-explicit-change or proceed-single-active-work, then call SDD tools for that change. If inspect-interrupted-run, call vgxness_run_resume_inspect. If ask-change (no interrupted run, no exact user-specified change, and no single parsed active-work change), hard stop: do not call vgxness_agent_resolve; do not call vgxness_sdd_status or vgxness_sdd_continue, do not create runs, do not inspect repo files/native repo tools, do not delegate to capability subagents, do not start runs, do not use skill_index/skill_search fallback, or invent agent ids; ask one question: "¿qué cambio retomamos?".',
     'Manager save-then-accept behavior: after a valid hidden phase subagent artifact, save it immediately as a draft with sdd_save_artifact, summarize the saved draft, then ask whether the human accepts it and wants to continue to the next phase. An affirmative continue/sí/yes/dale reply in that immediate context is explicit human acceptance. A reply of only save/no/revise keeps draft and must not advance. Never silently auto-accept.',
     'Instruction layering: OpenCode appends environment, global/project AGENTS.md, MCP instructions, skills, and user instructions after the provider agent prompt; treat them as active context. Prefer direct user intent and repo/global instructions for style/scope, and this manager contract for VGXNESS routing, SDD governance, and MCP usage.',
     'Run preflight explicit-request behavior: when a human explicitly requests a concrete risky action, pass structured explicitRequest to vgxness_run_preflight with human actor, request source/timestamp, exact category/operation/scope, risk flags, and parser exactness. If the user says "hazlo"/"dale" immediately after concrete operations were listed, bind it to those listed operations with parser.exact true and no expansion reasons. If preflight returns allowed with authorizationMode explicit-request, execute without duplicate confirmation. Ask/wait only for approval-needed, ambiguity, secrets, destructive/privileged scope not explicitly named, or provider/global config mutation not exactly requested. Never use explicitRequest to infer SDD acceptance.',
-    '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; inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended) as prompt guidance only, not runtime parsing/rejection; when proposal is accepted, spec/design/tasks run sequentially as draft-only autorun; then ask one focused apply-start confirmation and later archive confirmation while acceptance remains human-only. Context memory lifecycle: use memory in SDD and non-SDD work. Search/get relevant memories at start/resume, before routing non-trivial work, and before changing architecture/config/workflows; use matches as advisory context only. Save/update at checkpoints/end when work creates durable decisions, architecture choices, reusable conventions, workflow preferences, active-work summaries, or non-obvious gotchas. Memory write policy: ordinary qualifying writes are agent-decided and audit-only; they do not require extra confirmation or preflight; lifecycle memoryCapture candidates are review-first advisory metadata only, not persisted automatically, not a durable candidate queue, and still require explicit save/update policy; prefer update by known id/topicKey over duplicate saves; never save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive user data. Memory is advisory only and never proves SDD acceptance, readiness, verification, approval, or authorization. SDD artifacts are canonical for phase deliverables/governance state. OpenCode previews/handoff are read-only and capture-free. Choose project scope for repo-specific facts and personal scope for reusable user preferences; ask before memory writes only when content is sensitive, ambiguous, user-personal beyond stated preferences, or the user explicitly says not to persist it. 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; inspect delegated result-envelope completeness before SDD artifact persistence or phase advancement (status, executive_summary, artifacts_examined, skill_resolution, risks, next_recommended) as prompt guidance only, not runtime parsing/rejection; when proposal is accepted, spec/design/tasks run sequentially as draft-only autorun; then ask one focused apply-start confirmation and later archive confirmation while acceptance remains human-only. Context memory lifecycle: use memory in SDD and non-SDD work. Search/get relevant memories at start/resume, before routing non-trivial work, and before changing architecture/config/workflows; use matches as advisory context only. Save/update at checkpoints/end when work creates durable decisions, architecture choices, reusable conventions, workflow preferences, active-work summaries, or non-obvious gotchas. Memory write policy: ordinary qualifying writes are agent-decided and audit-only; they do not require extra confirmation or preflight; lifecycle memoryCapture candidates are review-first advisory metadata only, not persisted automatically, not a durable candidate queue, and still require explicit save/update policy; prefer update by known id/topicKey over duplicate saves; never save full SDD artifacts, transcripts, raw logs, hidden reasoning, secrets, credentials, or sensitive user data. Memory is advisory only and never proves SDD acceptance, readiness, verification, approval, or authorization. SDD artifacts are canonical for phase deliverables/governance state. OpenCode previews/handoff are read-only and capture-free. Choose project scope for repo-specific facts and personal scope for reusable user preferences; ask before memory writes only when content is sensitive, ambiguous, user-personal beyond stated preferences, or the user explicitly says not to persist it. Resolve exact capability 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.',
     'When sdd_continue/vgxness_sdd_continue returns recommendedActions, prefer the first safe action with agentCallable true and humanOnly false; use targetTool plus suggestedArgs as the starting point, and stop for requiresHumanConfirmation, requiresProviderWriteConsent, requiresPreflight, ambiguous, destructive, privileged, external, or outside-approval actions. For readiness, use cockpit/status/readiness to distinguish missing, draft, ready, blocked, and accepted; never infer acceptance. For provider evidence, report providerEvidence.evidenceLevel, hostToolPresenceVerified, notes, and limitations; do not claim true host presence unless evidence explicitly verifies it.',
-    '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. Git/PR hygiene: never implement on main; sync main and create a topic branch/worktree before edits; preserve unrelated work; use conventional commits; link approved issues when repo policy requires them; include verification evidence. Estimate changed lines before PR: <=400 focused changed lines can be one PR; >400 lines or multiple review units should become stacked/chained PRs, or ask the user to choose a single PR with size exception vs stacked plan.',
+    '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 capability subagents. Git/PR hygiene: never implement on main; sync main and create a topic branch/worktree before edits; preserve unrelated work; use conventional commits; link approved issues when repo policy requires it; include verification evidence in PRs; split work above 400 changed lines unless user chooses a size exception.',
     '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. The removed experimental vgxness code runtime is not an SDD fallback.',
     'Code context: use vgxness_code_context_status before relying on repository-intelligence providers. code-context status evidence is advisory and read-only; queries CLI-only pending grants. Do not install/initialize CodeGraph/Graphify, write provider config, or treat output as SDD acceptance/verification.',
     '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 = {
-    'vgxness-sdd-explore': {
+    'vgxness-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'],
@@ -278,7 +301,7 @@ const subagentData = {
         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': {
+    'vgxness-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'],
@@ -287,7 +310,7 @@ const subagentData = {
         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': {
+    'vgxness-requirements': {
         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'],
@@ -296,7 +319,7 @@ const subagentData = {
         skills: ['vgxness-sdd-spec'],
         phaseContract: 'Write requirements, acceptance criteria, edge cases, and out-of-scope items. Do not implement code changes.',
     },
-    'vgxness-sdd-design': {
+    'vgxness-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'],
@@ -305,7 +328,7 @@ const subagentData = {
         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': {
+    'vgxness-plan': {
         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. Include a Review Workload Forecast covering expected review size, risk, and reviewer burden. Do not implement code changes.',
         capabilities: ['sdd-tasks', 'task-breakdown', 'implementation-planning'],
@@ -314,7 +337,7 @@ const subagentData = {
         skills: ['vgxness-sdd-tasks'],
         phaseContract: 'Break accepted or trusted draft spec/design into small ordered testable implementation tasks. Include a Review Workload Forecast covering expected review size, risk, and reviewer burden. Do not implement code changes.',
     },
-    'vgxness-sdd-apply': {
+    'vgxness-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'],
@@ -323,7 +346,7 @@ const subagentData = {
         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': {
+    'vgxness-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'],
@@ -332,7 +355,7 @@ const subagentData = {
         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': {
+    'vgxness-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'],
@@ -341,7 +364,7 @@ const subagentData = {
         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.',
     },
-    'vgxness-sdd-init': {
+    'vgxness-init': {
         seedDescription: 'Bootstraps SDD context and project configuration.',
         seedInstructions: 'You are the init phase executor, not the orchestrator. Do not delegate. Initialize SDD context and project setup safely. Prefer read-only diagnostics and explicit user confirmation before writes or provider/global config changes.',
         capabilities: ['sdd-init', 'setup', 'bootstrap'],
@@ -350,7 +373,7 @@ const subagentData = {
         skills: [],
         phaseContract: 'Bootstrap SDD context and project setup safely. Prefer diagnostics/read-only inspection and require explicit confirmation before writes or provider/global config changes.',
     },
-    'vgxness-sdd-onboard': {
+    'vgxness-onboard': {
         seedDescription: 'Guides users through a complete SDD cycle using their real codebase.',
         seedInstructions: 'You are the onboard phase executor, not the orchestrator. Do not delegate. Guide onboarding through the SDD workflow. Ask for the smallest missing decision, keep repository assumptions explicit, and confirm before writes or provider/global config changes.',
         capabilities: ['sdd-onboard', 'workflow-guidance', 'project-onboarding'],
@@ -366,5 +389,5 @@ export const canonicalAgentManifest = {
     scope: 'project',
     promptContractVersion: canonicalPromptContractVersion,
     defaultAgentName: canonicalDefaultAgentName,
-    agents: [managerDefinition(), ...canonicalSddSubagentNames.map(subagentDefinition)],
+    agents: [managerDefinition(), ...canonicalCapabilitySubagentNames.map(subagentDefinition)],
 };

package/dist/interfaces/cli/cli-help.js

@@ -43,7 +43,7 @@ Areas:
   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.
 
-  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.
+  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 reusable capability 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.
@@ -69,7 +69,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 top-level permission.bash=ask, vgxness-manager with bash=deny and native repo tools disabled, and hidden vgxness-sdd-* agents with explicit permissions; use --mcp-only for legacy MCP-only config.
+  OpenCode install defaults to user-global scope and installs mcp.vgxness plus top-level permission.bash=ask, vgxness-manager with bash=deny and native repo tools disabled, and hidden capability agents such as vgxness-explore/vgxness-plan/vgxness-verify with legacy vgxness-sdd-* task aliases; 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. VGX-managed provider configuration is user-global only for OpenCode and Claude; the OpenCode target is $HOME/.config/opencode/opencode.json.
   Project/local provider files are external/manual diagnostics and will not be written by VGXNESS. Plans are read-only; applies refuse unsafe existing user-global config and create backups before merge.

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

@@ -336,14 +336,14 @@ export function promptSetupWizard(environment, defaults) {
         const scope = scopeText === 'project' || scopeText === 'user' ? scopeText : undefined;
         if (scope === undefined)
             return validationFailure('OpenCode scope must be project or user.');
-        const modeText = defaulted(await promptLine(environment, 'Install mode: MCP + manager/SDD agents, MCP only [MCP + manager/SDD agents]: '), defaults.installMode);
+        const modeText = defaulted(await promptLine(environment, 'Install mode: MCP + manager/capability agents, MCP only [MCP + manager/capability agents]: '), defaults.installMode);
         const installMode = modeText === 'mcp-plus-agents' || modeText.toLowerCase() === 'mcp + manager/sdd agents'
             ? 'mcp-plus-agents'
             : modeText === 'mcp-only' || modeText.toLowerCase() === 'mcp only'
                 ? 'mcp-only'
                 : undefined;
         if (installMode === undefined)
-            return validationFailure('Install mode must be MCP + manager/SDD agents or MCP only.');
+            return validationFailure('Install mode must be MCP + manager/capability agents or MCP only.');
         const overwriteText = defaulted(await promptLine(environment, 'Reinstall VGXNESS entries: overwrite existing mcp.vgxness and VGXNESS agents after final confirmation; preserve unrelated OpenCode config [no]: '), 'no');
         const overwriteVgxness = overwriteText.toLowerCase() === 'yes' || overwriteText.toLowerCase() === 'y' || overwriteText.toLowerCase() === 'true';
         const input = {

package/dist/interfaces/cli/home-tui-app.js

@@ -288,7 +288,7 @@ function focusedSddLines(plan, input, sdd) {
         '',
         'This panel intentionally does not open SQLite until a change id is selected.',
         'Allowed input: letters, numbers, dot, underscore, dash; first character must be alphanumeric.',
-        'Daily SDD stays in OpenCode through conversation, VGXNESS MCP, hidden SDD subagents, and registry skills.',
+        'Daily SDD stays in OpenCode through conversation, VGXNESS MCP, reusable capability subagents, and registry skills.',
         '',
         `Continue: vgxness sdd continue --project ${plan.project} --change ${change}`,
         `Status:   vgxness sdd status --project ${plan.project} --change ${change}`,
@@ -369,7 +369,7 @@ function sddLines() {
         'Change: not selected. Press Enter for the focused SDD gate.',
         '',
         'The Home TUI does not open local SDD state until a change id is selected.',
-        'Daily SDD should stay in OpenCode through conversation, VGXNESS MCP, and hidden SDD subagents.',
+        'Daily SDD should stay in OpenCode through conversation, VGXNESS MCP, and reusable capability subagents.',
         '',
         'CLI fallback: `vgxness sdd continue --project <name> --change <id>`.',
     ];

package/dist/interfaces/cli/sdd-renderer.js

@@ -10,7 +10,7 @@ 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.'
-            : `Continue the ${input.status.nextReadyPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`;
+            : `Continue the ${input.status.nextReadyPhase} phase in OpenCode using VGXNESS MCP and reusable capability subagents.`;
     const commandLabel = directPhaseCommand === undefined ? 'Diagnostic command' : 'Continuation guidance command';
     const lines = [
         'SDD Status',
@@ -43,7 +43,7 @@ export function renderSddNext(input) {
         : `vgxness sdd status --project ${input.project} --change ${input.decision.change}`;
     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.`
+        ? `Continue the ${input.decision.nextPhase} phase in OpenCode using VGXNESS MCP and reusable capability subagents.`
         : input.decision.recommendedAction;
     const lines = [
         'SDD Next',
@@ -87,7 +87,7 @@ export function renderSddContinuationPlan(plan) {
         `Reason: ${plan.reason}`,
         '',
         'Recommended plan:',
-        `- ${plan.status === 'runnable' && plan.nextPhase !== undefined ? `Continue the ${plan.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.` : plan.recommendedAction}`,
+        `- ${plan.status === 'runnable' && plan.nextPhase !== undefined ? `Continue the ${plan.nextPhase} phase in OpenCode using VGXNESS MCP and reusable capability subagents.` : plan.recommendedAction}`,
         `- ${suggestedCommandLabel}: ${plan.suggestedCommand}`,
         `- Diagnostic command: ${plan.inspectCommand}`,
         '',

package/dist/interfaces/mcp/stdio-server.js

@@ -56,7 +56,7 @@ function descriptionForTool(publicToolName) {
     if (publicToolName === 'provider_change_plan')
         return 'Read-only provider change plan preview; composes status, doctor, and OpenCode install planning without writing provider config.';
     if (publicToolName === 'opencode_handoff_preview')
-        return 'Read-only OpenCode handoff preview; returns compact context for continuing in OpenCode conversation with VGXNESS MCP and hidden SDD subagents, does not execute/control OpenCode, write .opencode/provider config, or create runs, checkpoints, events, sessions, or skill-usage records. Request verbose manager payload separately when artifact bodies are needed.';
+        return 'Read-only OpenCode handoff preview; returns compact context for continuing in OpenCode conversation with VGXNESS MCP and reusable capability subagents, does not execute/control OpenCode, write .opencode/provider config, or create runs, checkpoints, events, sessions, or skill-usage records. Request verbose manager payload separately when artifact bodies are needed.';
     if (publicToolName === 'verification_plan')
         return 'Read-only verification plan recommendations only; does not execute commands, write provider config, persist results, create checkpoints, or infer SDD acceptance.';
     if (publicToolName === 'run_resume_candidates')

package/dist/setup/setup-plan.js

@@ -175,7 +175,7 @@ function setupPlanFromOpenCode(input) {
         actions: [
             {
                 id: `opencode-${input.opencode.action}`,
-                description: `${input.opencode.overwriteVgxness ? 'Reinstall/overwrite VGXNESS entries in' : input.opencode.action === 'create' ? 'Create' : 'Merge'} OpenCode config with mcp.vgxness using vgxness mcp start${input.installMode === 'mcp-plus-agents' ? ' and manager/SDD agents' : ''}${input.opencode.overwriteVgxness ? '; unrelated OpenCode config is preserved' : ''}${bashPermissionDescription(input.opencode.bashPermissionPolicy)}.`,
+                description: `${input.opencode.overwriteVgxness ? 'Reinstall/overwrite VGXNESS entries in' : input.opencode.action === 'create' ? 'Create' : 'Merge'} OpenCode config with mcp.vgxness using vgxness mcp start${input.installMode === 'mcp-plus-agents' ? ' and manager/capability agents' : ''}${input.opencode.overwriteVgxness ? '; unrelated OpenCode config is preserved' : ''}${bashPermissionDescription(input.opencode.bashPermissionPolicy)}.`,
                 mutating: false,
                 targetPath: input.opencode.targetPath,
                 backupRequired: input.opencode.backupRequired,

package/dist/status/product-status.js

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

package/docs/architecture.md

@@ -93,7 +93,7 @@ Gentle-AI/`gentle-pi` are strong references for the configurator and agent-behav
 
 ### Agent registry self-healing
 
-The canonical agent manifest in `src/domain/agents/canonical-agent-manifest.ts` is the source of truth for built-in agents (1 manager + 10 SDD subagents). At every CLI/MCP boot, `src/application/agents/boot-upgrade.ts` reconciles the live `agents` table with that manifest via `src/application/agents/agent-seed-upgrade-service.ts`: missing rows are created, drifted rows (changed `vgxnessPromptContractVersion`, instructions, adapters, or description) are overwritten, and matches are recorded as noop. Each non-noop outcome is appended to the `agent_seed_history` table for audit. Operators can opt out with `VGXNESS_SKIP_AGENT_SEED_AUTO_UPGRADE=1`. This eliminates the long-standing drift between the canonical prompt contract and stored agent rows after a version bump. The old `src/agents/*` paths remain compatibility facades during the migration window.
+The canonical agent manifest in `src/domain/agents/canonical-agent-manifest.ts` is the source of truth for built-in agents (1 manager + 10 generic capability subagents). At every CLI/MCP boot, `src/application/agents/boot-upgrade.ts` reconciles the live `agents` table with that manifest via `src/application/agents/agent-seed-upgrade-service.ts`: missing rows are created, drifted rows (changed `vgxnessPromptContractVersion`, instructions, adapters, or description) are overwritten, and matches are recorded as noop. Each non-noop outcome is appended to the `agent_seed_history` table for audit. Operators can opt out with `VGXNESS_SKIP_AGENT_SEED_AUTO_UPGRADE=1`. This eliminates the long-standing drift between the canonical prompt contract and stored agent rows after a version bump. The old `src/agents/*` paths remain compatibility facades during the migration window.
 
 ### Manager overlay parity across providers
 
@@ -160,7 +160,7 @@ The CLI exposes the same boundary through `vgxness sdd status|ready|save-artifac
 
 Long term, SDD orchestration must combine two mechanisms:
 
-1. **Agent behavior** — orchestrator prompts, SDD subagents/chains, skills, per-phase models, and strict TDD instructions rendered into tools such as OpenCode, Claude Code, or Pi.
+1. **Agent behavior** — orchestrator prompts, reusable capability subagents/chains, skills, per-phase models, and strict TDD instructions rendered into tools such as OpenCode, Claude Code, or Pi.
 2. **Product state** — workflow definitions, prerequisites, artifacts, approvals, runs, checkpoints, verification results, and archive status stored locally and queried before advancing.
 
 The first mechanism makes agents effective. The second makes the workflow enforceable and inspectable. `vgxness` should not rely on either one alone.
@@ -471,7 +471,7 @@ The envelope is always `installable:false` and `readOnly:true`. It does **not**
 
 ### OpenCode manager orchestration
 
-The checked-in OpenCode default config and `seeds/agents/agent-seed-v1.json` define `vgxness-manager` as an MCP-first orchestrator. The manager should use `vgxness_session_restore` with the project and workspace directory when starting, resuming, or recovering context, then use SDD artifact/status tools, memory tools, agent resolution, run/preflight tools, and read-only payload/profile previews before delegating substantial phase work to exact SDD subagents. Before ending, pausing, handing off, or compacting, it should call `vgxness_session_close` with the current session id, actor `manager`, and an actionable summary; if no current session id is available, it must not invent one and should preserve the summary in its final response. Its OpenCode `permission.task` remains deny-by-default: `*` is denied and only the canonical `vgxness-sdd-*` subagent names are allowed explicitly. The seed/default prompts are self-contained and do not require external provider-native skill files; optional guidance should live in VGXNESS registry assets unless a future provider-native integration is explicitly designed.
+The checked-in OpenCode default config and `seeds/agents/agent-seed-v1.json` define `vgxness-manager` as an MCP-first orchestrator. The manager should use `vgxness_session_restore` with the project and workspace directory when starting, resuming, or recovering context, then use SDD artifact/status tools, memory tools, agent resolution, run/preflight tools, and read-only payload/profile previews before delegating substantial work to exact capability subagents. Before ending, pausing, handing off, or compacting, it should call `vgxness_session_close` with the current session id, actor `manager`, and an actionable summary; if no current session id is available, it must not invent one and should preserve the summary in its final response. Its OpenCode `permission.task` remains deny-by-default: `*` is denied and only the canonical capability subagent names plus legacy `vgxness-sdd-*` aliases are allowed explicitly. The seed/default prompts are self-contained and do not require external provider-native skill files; optional guidance should live in VGXNESS registry assets unless a future provider-native integration is explicitly designed.
 
 ## Run lifecycle
 

package/docs/cli.md

@@ -46,7 +46,7 @@ Release defaults used by the guided setup are:
 - Provider: OpenCode.
 - Database: global user data location by default.
 - OpenCode/Claude provider config: user-global only for VGX-managed writes (`$HOME/.config/opencode/opencode.json`, `~/.claude.json`, `~/.claude/agents/*.md`, `~/.claude/CLAUDE.md`).
-- Install mode: MCP plus manager/SDD agents (`mcp-plus-agents`).
+- Install mode: MCP plus manager/capability agents (`mcp-plus-agents`).
 - Public CLI language: English.
 
 Recommended bootstrap and diagnostic flow after `npm install -g vgxness`:
@@ -66,7 +66,7 @@ vgxness resume --project <project> --run-id <id>
 vgxness setup rollback --backup <path>
 ```
 
-Daily SDD phase progression is OpenCode-first: talk to OpenCode with the VGXNESS MCP server installed, and let the hidden SDD subagents use MCP tools for phase work. The CLI and TUI remain supported for bootstrap/setup, diagnostics, recovery, manual fallback, and scripting; they are not the primary daily surface.
+Daily SDD phase progression is OpenCode-first: talk to OpenCode with the VGXNESS MCP server installed, and let the hidden capability subagents use MCP tools for phase or general capability work. The CLI and TUI remain supported for bootstrap/setup, diagnostics, recovery, manual fallback, and scripting; they are not the primary daily surface.
 
 `setup plan`, `setup status`, and non-TTY `init` planning do not write provider config. Local VGXNESS store initialization may occur when the selected SQLite store is needed. They are human-readable by default; pass `--json` when you need parseable automation output. With the default global database, the OpenCode MCP command is `vgxness mcp start`; for custom/project-local DBs it includes `--db <path>`. The default and only VGX-managed OpenCode target is `$HOME/.config/opencode/opencode.json`; Claude managed targets are user-global (`~/.claude.json`, `~/.claude/agents/*.md`, and `~/.claude/CLAUDE.md`). `setup apply --yes` is the explicit provider-config write path. `setup rollback --backup <path>` validates a VGXNESS/OpenCode backup such as `opencode.json.backup-<timestamp>`, creates a pre-rollback backup of the current user-global target when present, restores the selected backup byte-for-byte, and recommends `vgxness doctor`.
 
@@ -76,7 +76,7 @@ Daily SDD phase progression is OpenCode-first: talk to OpenCode with the VGXNESS
 
 ## Daily workflow front doors
 
-Use OpenCode conversation + VGXNESS MCP + hidden SDD subagents for normal daily SDD work. Use these top-level commands when you need diagnostics, recovery, manual fallback, or scriptable state inspection:
+Use OpenCode conversation + VGXNESS MCP + hidden capability subagents for normal daily SDD work. Use these top-level commands when you need diagnostics, recovery, manual fallback, or scriptable state inspection:
 
 | Question | Command | Purpose |
 |---|---|---|
@@ -87,7 +87,7 @@ Use OpenCode conversation + VGXNESS MCP + hidden SDD subagents for normal daily
 
 Without `--change`, `--project`, or `--run-id`, these commands stay orientation-only and do not open the local memory store. With a selected change, project, or run, top-level `status`, `next`, and `resume` inspect SQLite read-only; formal `sdd` commands are non-provider, non-run-executing planning/artifact commands that may use the normal local store path. Pass `--json` for automation.
 
-The usual SDD operator loop happens inside OpenCode: continue the phase in conversation while VGXNESS MCP and hidden SDD subagents inspect readiness, persist artifacts, and report evidence. CLI commands remain fallback/recovery tools: inspect `status`, ask `next`, run `sdd continue` for a read-only continuation plan, or run `vgxness resume ...` for interrupted work. After a draft is ready, use `sdd accept-artifact` for explicit human acceptance; if an artifact was rejected, use `sdd reopen-artifact` before revising it. Related interrupted run hints in `status`, `next`, and `sdd continue` are advisory only; they help avoid duplicate work but do not retry or execute runs.
+The usual SDD operator loop happens inside OpenCode: continue the phase in conversation while VGXNESS MCP and hidden capability subagents inspect readiness, persist artifacts, and report evidence. CLI commands remain fallback/recovery tools: inspect `status`, ask `next`, run `sdd continue` for a read-only continuation plan, or run `vgxness resume ...` for interrupted work. After a draft is ready, use `sdd accept-artifact` for explicit human acceptance; if an artifact was rejected, use `sdd reopen-artifact` to return it to draft before editing.
 
 ## Bun-first repository verification
 
@@ -293,7 +293,7 @@ Safety boundary: this is a preview only. It does **not** call providers, edit fi
 
 ## Code runtime CLI (`vgxness code`)
 
-The experimental `vgxness code` runtime remains unavailable. Do not use `vgxness code` as an SDD fallback. Continue SDD phases in OpenCode conversation with VGXNESS MCP and hidden SDD subagents, and use `vgxness status`, `vgxness next`, `vgxness sdd continue`, or `vgxness resume` for safe CLI diagnostics and recovery.
+The experimental `vgxness code` runtime remains unavailable. Do not use `vgxness code` as an SDD fallback. Continue SDD phases in OpenCode conversation with VGXNESS MCP and hidden capability subagents, and use `vgxness status`, `vgxness next`, `vgxness sdd continue`, or `vgxness resume` for safe CLI diagnostics and recovery.
 
 ## Workflow CLI
 
@@ -541,7 +541,7 @@ Manual/opt-in runtime validation checklist (not normal CI):
 
 ## SDD workflow examples
 
-Use OpenCode conversation with VGXNESS MCP and hidden SDD subagents for normal daily SDD progression. Use `sdd` commands to inspect local SDD artifact state and save, read, or list phase artifacts for diagnostics, recovery, scripting, or manual fallback. These commands read and write only the selected `vgxness` local SQLite memory store: `--db <path>` when passed, `VGXNESS_DB_PATH` when set, or the global default database when neither override is present.
+Use OpenCode conversation with VGXNESS MCP and hidden capability subagents for normal daily SDD progression. Use `sdd` commands to inspect local SDD artifact state and save, read, or list phase artifacts for diagnostics, recovery, scripting, or manual fallback. These commands read and write only the selected `vgxness` local SQLite memory store: `--db <path>` when passed, `VGXNESS_DB_PATH` when set, or the global default database when neither override is present.
 
 ```bash
 bun run cli:bun -- sdd status --project vgxness --change sdd-workflow-engine --db /tmp/vgxness-memory.sqlite
@@ -590,7 +590,7 @@ This seed file is repo-only in v1.3.0 package contents. If installed-package wor
 
 The command prints an `AgentSeedLoadSummary` JSON payload with `created`, `updated`, `agents`, `subagents`, and `warnings`. Re-running the same seed is safe: records are upserted by the current project, scope, and name, so existing seed records are updated in place instead of duplicated.
 
-The checked-in `vgxness-manager` and SDD subagents are self-contained: their seed instructions describe the MCP-first orchestration contract inline and do not require external provider-native skill directories. SDD skills can still be registered and attached as optional VGXNESS registry assets when a project wants extra reusable guidance.
+The checked-in `vgxness-manager` and capability subagents are self-contained: their seed instructions describe the MCP-first orchestration contract inline and do not require external provider-native skill directories. SDD skills can still be registered and attached as optional VGXNESS registry assets when a project wants extra reusable guidance.
 
 Seed loading preserves user-created agents that are absent from the manifest. It only writes to the selected local registry database (`--db`, `VGXNESS_DB_PATH`, or the global default); it does **not** create `.opencode/`, `.claude/`, provider config, or user/global OpenCode configuration.
 

package/docs/glossary.md

@@ -32,7 +32,7 @@ The canonical installed CLI/MCP runtime and verification path. Required `>= 1.3.
 
 ## Canonical agent manifest
 
-The built-in, validated manifest that defines the manager agent and the SDD subagents (`vgxness-sdd-explore`, `vgxness-sdd-propose`, `vgxness-sdd-spec`, `vgxness-sdd-design`, `vgxness-sdd-tasks`, `vgxness-sdd-apply`, `vgxness-sdd-verify`, `vgxness-sdd-archive`, plus `init` and `onboard`). Lives in `src/domain/agents/canonical-agent-manifest.ts` with old-path compatibility through `src/agents/canonical-agent-manifest.ts`. `promptContractVersion` increments on breaking contract changes.
+The built-in, validated manifest that defines the manager agent and generic capability subagents (`vgxness-explore`, `vgxness-propose`, `vgxness-requirements`, `vgxness-design`, `vgxness-plan`, `vgxness-apply`, `vgxness-verify`, `vgxness-archive`, `vgxness-init`, and `vgxness-onboard`). Legacy `vgxness-sdd-*` task names remain callable as compatibility aliases, but the canonical provider-facing names are no longer SDD-prefixed. Lives in `src/domain/agents/canonical-agent-manifest.ts` with old-path compatibility through `src/agents/canonical-agent-manifest.ts`. `promptContractVersion` increments on breaking contract changes.
 
 ## Change (SDD)
 

package/package.json

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