vgxness 1.20.10 → 1.20.12

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/runs/parallel-agent-batch-service.js

@@ -0,0 +1,85 @@
+import { parallelAgentBatchCategories, parallelAgentBatchDefaultMaxConcurrency, parallelAgentBatchHardMaxConcurrency, parallelAgentBatchMaxTasks, } from '../../domain/runs/parallel-agent-batch.js';
+const requiredSynthesis = {
+    required: true,
+    includeEvidence: true,
+    includeConflicts: true,
+    includeFailures: true,
+    includeResidualRisk: true,
+    includeNextAction: true,
+};
+export class ParallelAgentBatchService {
+    defaultMaxConcurrency;
+    hardMaxConcurrency;
+    allowedAgentNames;
+    constructor(options = {}) {
+        this.hardMaxConcurrency = options.hardMaxConcurrency ?? parallelAgentBatchHardMaxConcurrency;
+        this.defaultMaxConcurrency = options.defaultMaxConcurrency ?? parallelAgentBatchDefaultMaxConcurrency;
+        this.allowedAgentNames = options.allowedAgentNames === undefined ? undefined : new Set(options.allowedAgentNames);
+    }
+    validatePlan(plan) {
+        const issues = [];
+        const warnings = [];
+        const maxConcurrency = plan.maxConcurrency ?? this.defaultMaxConcurrency;
+        if (!isValidConcurrency(maxConcurrency, this.hardMaxConcurrency))
+            issues.push({
+                code: 'invalid-concurrency',
+                message: `maxConcurrency must be an integer between 1 and ${this.hardMaxConcurrency}; received ${String(maxConcurrency)}`,
+            });
+        if (!isValidConcurrency(this.defaultMaxConcurrency, this.hardMaxConcurrency))
+            issues.push({
+                code: 'invalid-concurrency',
+                message: `defaultMaxConcurrency must be an integer between 1 and ${this.hardMaxConcurrency}; received ${String(this.defaultMaxConcurrency)}`,
+            });
+        if (!Array.isArray(plan.tasks) || plan.tasks.length === 0)
+            issues.push({ code: 'invalid-task-count', message: 'parallel batch must contain at least one task' });
+        else if (plan.tasks.length > parallelAgentBatchMaxTasks)
+            issues.push({ code: 'invalid-task-count', message: `parallel batch cannot exceed ${parallelAgentBatchMaxTasks} tasks` });
+        if (plan.tasks.length > 0 && plan.tasks.length <= maxConcurrency)
+            warnings.push('task count does not exceed concurrency; batch may finish in a single wave');
+        if (!hasRequiredSynthesisContract(plan.synthesis))
+            issues.push({ code: 'invalid-synthesis-contract', message: 'synthesis contract must require evidence, conflicts, failures, residual risk, and next action' });
+        const taskIds = new Set(plan.tasks.map((task) => task.id).filter((id) => id.trim().length > 0));
+        for (const task of plan.tasks)
+            this.validateTask(task, taskIds, issues);
+        if (issues.length > 0)
+            return { ok: false, issues, warnings };
+        return { ok: true, value: { ...plan, maxConcurrency }, warnings };
+    }
+    validateTask(task, taskIds, issues) {
+        requireTrimmed(task.id, 'id', task.id, issues);
+        requireTrimmed(task.agentName, 'agentName', task.id, issues);
+        requireTrimmed(task.workspaceRoot, 'workspaceRoot', task.id, issues);
+        requireTrimmed(task.scopeSummary, 'scopeSummary', task.id, issues);
+        requireTrimmed(task.independenceRationale, 'independenceRationale', task.id, issues);
+        if (task.allowedTools.length === 0)
+            issues.push({ code: 'missing-field', taskId: task.id, message: 'allowedTools must name at least one permitted tool' });
+        if (!parallelAgentBatchCategories.includes(task.category))
+            issues.push({ code: 'unknown-category', taskId: task.id, message: `unsupported category: ${task.category}` });
+        if (this.allowedAgentNames !== undefined && !this.allowedAgentNames.has(task.agentName))
+            issues.push({ code: 'unknown-agent', taskId: task.id, message: `agent is not allowlisted: ${task.agentName}` });
+        if (task.recursiveDelegationAllowed === true)
+            issues.push({ code: 'recursive-delegation', taskId: task.id, message: 'subagents must not be allowed to launch subagents recursively' });
+        for (const dependency of task.dependsOn ?? []) {
+            if (taskIds.has(dependency))
+                issues.push({ code: 'dependent-task', taskId: task.id, message: `task depends on same-batch task ${dependency}; run these serially instead` });
+        }
+        if (task.riskTier !== 'read-only' && task.requiresPreflight !== true)
+            issues.push({ code: 'risky-preflight-required', taskId: task.id, message: 'risky or mutating tasks require preflight' });
+        if (task.category === 'implementation') {
+            if ((task.targetPaths ?? []).filter((path) => path.trim().length > 0).length === 0)
+                issues.push({ code: 'implementation-scope-required', taskId: task.id, message: 'implementation tasks must declare independent target paths or scopes' });
+            if (task.requiresPreflight !== true)
+                issues.push({ code: 'implementation-preflight-required', taskId: task.id, message: 'implementation tasks require preflight before launch' });
+        }
+    }
+}
+function isValidConcurrency(value, hardMaxConcurrency) {
+    return Number.isInteger(value) && value >= 1 && value <= hardMaxConcurrency;
+}
+function requireTrimmed(value, field, taskId, issues) {
+    if (value.trim().length === 0)
+        issues.push({ code: 'missing-field', taskId, message: `${field} is required` });
+}
+function hasRequiredSynthesisContract(value) {
+    return Object.entries(requiredSynthesis).every(([key, expected]) => value[key] === expected);
+}

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 = 24;
-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,9 +90,9 @@ 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', 'mcp-coordination', 'project-local-automation', 'coordination', 'workflow-selection', 'resume'],
+        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' },
         memory: { scopes: ['project'] },
         workflows: ['explore', 'quickfix', 'plan', 'build', 'debug', 'sdd', 'agent-seeding', 'opencode-install'],
@@ -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 {
@@ -161,6 +178,7 @@ export function createCanonicalOpenCodeSddMcpToolPermissions() {
         vgxness_opencode_manager_payload: 'allow',
         vgxness_run_list: 'allow',
         vgxness_run_get: 'allow',
+        vgxness_run_parallel_batch_validate: 'allow',
         vgxness_run_start: 'allow',
         vgxness_run_checkpoint: 'allow',
         vgxness_run_preflight: 'allow',
@@ -175,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.
@@ -190,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.
@@ -202,23 +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 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.
@@ -238,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.`;
@@ -250,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, or multi-step analysis that benefits from an exact focused executor. 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'],
@@ -274,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'],
@@ -283,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'],
@@ -292,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'],
@@ -301,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'],
@@ -310,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'],
@@ -319,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'],
@@ -328,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'],
@@ -337,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'],
@@ -346,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'],
@@ -362,5 +389,5 @@ export const canonicalAgentManifest = {
     scope: 'project',
     promptContractVersion: canonicalPromptContractVersion,
     defaultAgentName: canonicalDefaultAgentName,
-    agents: [managerDefinition(), ...canonicalSddSubagentNames.map(subagentDefinition)],
+    agents: [managerDefinition(), ...canonicalCapabilitySubagentNames.map(subagentDefinition)],
 };

package/dist/domain/runs/parallel-agent-batch.js

@@ -0,0 +1,13 @@
+export const parallelAgentBatchDefaultMaxConcurrency = 3;
+export const parallelAgentBatchHardMaxConcurrency = 8;
+export const parallelAgentBatchMaxTasks = 20;
+export const parallelAgentBatchCategories = [
+    'analysis',
+    'verification',
+    'research',
+    'sdd',
+    'codebase-investigation',
+    'debugging',
+    'code-review',
+    'implementation',
+];

package/dist/interfaces/mcp/control-plane/handlers/runs.js

@@ -1,3 +1,4 @@
+import { ParallelAgentBatchService } from '../../../../application/runs/parallel-agent-batch-service.js';
 import { AgentMemoryCaptureService } from '../../../../memory/agent-memory-capture-service.js';
 import { errorEnvelope, successEnvelope, } from '../../schema.js';
 function toEnvelope(tool, result) {
@@ -13,6 +14,39 @@ export function runListEnvelope(input, services) {
 export function runGetEnvelope(input, services) {
     return toEnvelope('vgxness_run_get', services.runs.getRun(input.id));
 }
+export function runParallelBatchValidateEnvelope(input) {
+    const options = {};
+    if (input.defaultMaxConcurrency !== undefined)
+        options.defaultMaxConcurrency = input.defaultMaxConcurrency;
+    if (input.hardMaxConcurrency !== undefined)
+        options.hardMaxConcurrency = input.hardMaxConcurrency;
+    if (input.allowedAgentNames !== undefined)
+        options.allowedAgentNames = input.allowedAgentNames;
+    const service = new ParallelAgentBatchService(options);
+    const { defaultMaxConcurrency: _defaultMaxConcurrency, hardMaxConcurrency: _hardMaxConcurrency, allowedAgentNames: _allowedAgentNames, ...plan } = input;
+    const validation = service.validatePlan(plan);
+    return successEnvelope('vgxness_run_parallel_batch_validate', {
+        kind: 'parallel-agent-batch-validation',
+        version: 1,
+        validation,
+        launchGuidance: {
+            launchSurface: 'opencode-native-delegate',
+            mcpExecutesSubagents: false,
+            nextStep: validation.ok
+                ? 'Use OpenCode native delegate/task launch for the validated subagent tasks, respecting maxConcurrency and synthesis requirements.'
+                : 'Fix validation issues before launching subagents.',
+        },
+        safety: {
+            readOnly: true,
+            validatesOnly: true,
+            launchesSubagents: false,
+            invokesProvider: false,
+            writesProviderConfig: false,
+            mutatesRunState: false,
+            mutatesSddArtifacts: false,
+        },
+    });
+}
 export function runPreflightEnvelope(input, services) {
     return toEnvelope('vgxness_run_preflight', services.runs.preflightOperation(input));
 }

package/dist/interfaces/mcp/control-plane.js

@@ -23,7 +23,7 @@ import { codeContextStatusEnvelope } from './control-plane/handlers/code-context
 import { contextCockpitEnvelope, resumeContextEnvelope } from './control-plane/handlers/context.js';
 import { memoryGetEnvelope, memorySaveEnvelope, memorySearchEnvelope, memoryUpdateEnvelope } from './control-plane/handlers/memory.js';
 import { providerChangePlanEnvelope, providerDoctorEnvelope, providerStatusEnvelope } from './control-plane/handlers/providers.js';
-import { runCheckpointEnvelope, runFinalizeEnvelope, runGetEnvelope, runListEnvelope, runPreflightEnvelope, runResumeCandidatesEnvelope, runResumeGateEnvelope, runResumeInspectEnvelope, runStartEnvelope, runTaskGrantCreateEnvelope, runTaskGrantGetEnvelope, runTaskGrantListEnvelope, runTaskGrantPreviewMatchEnvelope, runTaskGrantRevokeEnvelope, } from './control-plane/handlers/runs.js';
+import { runCheckpointEnvelope, runFinalizeEnvelope, runGetEnvelope, runListEnvelope, runParallelBatchValidateEnvelope, runPreflightEnvelope, runResumeCandidatesEnvelope, runResumeGateEnvelope, runResumeInspectEnvelope, runStartEnvelope, runTaskGrantCreateEnvelope, runTaskGrantGetEnvelope, runTaskGrantListEnvelope, runTaskGrantPreviewMatchEnvelope, runTaskGrantRevokeEnvelope, } from './control-plane/handlers/runs.js';
 import { governanceReportEnvelope, sddAcceptArtifactEnvelope, sddCockpitEnvelope, sddContinueEnvelope, sddGetArtifactEnvelope, sddGetReadinessEnvelope, sddListArtifactsEnvelope, sddNextEnvelope, sddReadyEnvelope, sddReopenArtifactEnvelope, sddSaveArtifactEnvelope, sddStatusEnvelope, } from './control-plane/handlers/sdd.js';
 import { sessionAppendActivityEnvelope, sessionCloseEnvelope, sessionRestoreEnvelope, sessionStartEnvelope } from './control-plane/handlers/sessions.js';
 import { skillActivateEnvelope, skillCreateDraftEnvelope, skillGetEnvelope, skillGetEvaluationEnvelope, skillIndexEnvelope, skillListEvaluationsEnvelope, skillListImprovementProposalsEnvelope, skillPayloadEnvelope, skillProposeImprovementEnvelope, skillPublishVersionEnvelope, skillRecordUsageEnvelope, skillRequestEvaluationEnvelope, skillSearchEnvelope, skillStatusEnvelope, skillUpdateDraftEnvelope, } from './control-plane/handlers/skills.js';
@@ -127,6 +127,8 @@ export function callVgxTool(call, services) {
             return runListEnvelope(validated.input, services);
         case 'vgxness_run_get':
             return runGetEnvelope(validated.input, services);
+        case 'vgxness_run_parallel_batch_validate':
+            return runParallelBatchValidateEnvelope(validated.input);
         case 'vgxness_run_preflight':
             return runPreflightEnvelope(validated.input, services);
         case 'vgxness_run_task_grant_create':

package/dist/interfaces/mcp/schema.js

@@ -48,6 +48,7 @@ export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
     'vgxness_opencode_handoff_preview',
     'vgxness_run_list',
     'vgxness_run_get',
+    'vgxness_run_parallel_batch_validate',
     'vgxness_run_preflight',
     'vgxness_run_task_grant_create',
     'vgxness_run_task_grant_list',
@@ -112,6 +113,7 @@ export const EXPOSED_VGX_MCP_TOOL_NAMES = [
     'opencode_handoff_preview',
     'run_list',
     'run_get',
+    'run_parallel_batch_validate',
     'run_preflight',
     'run_task_grant_create',
     'run_task_grant_list',

package/dist/interfaces/mcp/schemas/inputs/runs.js

@@ -1,5 +1,33 @@
 import { z } from 'zod';
 import { agentModes, explicitRequestInputSchema, finalRunStatuses, jsonValueSchema, permissionCategories, runOutcomes, runStatuses, taskGrantCategories, taskGrantCommandPolicyInputSchema, taskGrantHumanActorInputSchema, taskGrantRevocationActorInputSchema, taskGrantStatuses, workflowIds, } from '../common.js';
+const parallelBatchCategories = ['analysis', 'verification', 'research', 'sdd', 'codebase-investigation', 'debugging', 'code-review', 'implementation'];
+const parallelBatchRiskTiers = ['read-only', 'risky', 'mutation'];
+const parallelBatchSynthesisSchema = z
+    .object({
+    required: z.literal(true),
+    includeEvidence: z.literal(true),
+    includeConflicts: z.literal(true),
+    includeFailures: z.literal(true),
+    includeResidualRisk: z.literal(true),
+    includeNextAction: z.literal(true),
+})
+    .strict();
+const parallelBatchTaskSchema = z
+    .object({
+    id: z.string().min(1),
+    category: z.enum(parallelBatchCategories),
+    agentName: z.string().min(1),
+    workspaceRoot: z.string().min(1),
+    allowedTools: z.array(z.string().min(1)).min(1),
+    scopeSummary: z.string().min(1),
+    independenceRationale: z.string().min(1),
+    riskTier: z.enum(parallelBatchRiskTiers),
+    requiresPreflight: z.boolean(),
+    targetPaths: z.array(z.string().min(1)).optional(),
+    dependsOn: z.array(z.string().min(1)).optional(),
+    recursiveDelegationAllowed: z.boolean().optional(),
+})
+    .strict();
 export const RUNS_MCP_TOOL_INPUT_SCHEMAS = {
     vgxness_run_list: z
         .object({
@@ -13,6 +41,16 @@ export const RUNS_MCP_TOOL_INPUT_SCHEMAS = {
         id: z.string().min(1),
     })
         .passthrough(),
+    vgxness_run_parallel_batch_validate: z
+        .object({
+        maxConcurrency: z.number().int().min(1).optional(),
+        defaultMaxConcurrency: z.number().int().min(1).optional(),
+        hardMaxConcurrency: z.number().int().min(1).optional(),
+        allowedAgentNames: z.array(z.string().min(1)).optional(),
+        tasks: z.array(parallelBatchTaskSchema).min(1),
+        synthesis: parallelBatchSynthesisSchema,
+    })
+        .strict(),
     vgxness_run_preflight: z
         .object({
         runId: z.string().min(1),

package/dist/interfaces/mcp/validation/runs.js

@@ -30,6 +30,123 @@ export function validateRunGetInput(input, tool) {
         return id;
     return { ok: true, value: { id: id.value } };
 }
+const parallelBatchCategories = ['analysis', 'verification', 'research', 'sdd', 'codebase-investigation', 'debugging', 'code-review', 'implementation'];
+const parallelBatchRiskTiers = ['read-only', 'risky', 'mutation'];
+export function validateRunParallelBatchValidateInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'maxConcurrency',
+        'defaultMaxConcurrency',
+        'hardMaxConcurrency',
+        'allowedAgentNames',
+        'tasks',
+        'synthesis',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    for (const field of ['maxConcurrency', 'defaultMaxConcurrency', 'hardMaxConcurrency']) {
+        if (record.value[field] === undefined)
+            continue;
+        if (!Number.isInteger(record.value[field]) || record.value[field] < 1)
+            return validationFailure(`${field} must be a positive integer`, tool);
+        result[field] = record.value[field];
+    }
+    const allowedAgentNames = readOptionalStringArray(record.value, 'allowedAgentNames', tool);
+    if (!allowedAgentNames.ok)
+        return allowedAgentNames;
+    if (allowedAgentNames.value !== undefined)
+        result.allowedAgentNames = allowedAgentNames.value;
+    const tasks = readParallelBatchTasks(record.value.tasks, tool);
+    if (!tasks.ok)
+        return tasks;
+    result.tasks = tasks.value;
+    const synthesis = readParallelBatchSynthesis(record.value.synthesis, tool);
+    if (!synthesis.ok)
+        return synthesis;
+    result.synthesis = synthesis.value;
+    return { ok: true, value: result };
+}
+function readParallelBatchTasks(value, tool) {
+    if (!Array.isArray(value) || value.length === 0)
+        return validationFailure('tasks must be a non-empty array', tool);
+    const tasks = [];
+    for (const [index, item] of value.entries()) {
+        const record = asRecord(item, tool, `tasks[${index}] must be an object`);
+        if (!record.ok)
+            return record;
+        const unexpected = Object.keys(record.value).find((key) => !['id', 'category', 'agentName', 'workspaceRoot', 'allowedTools', 'scopeSummary', 'independenceRationale', 'riskTier', 'requiresPreflight', 'targetPaths', 'dependsOn', 'recursiveDelegationAllowed'].includes(key));
+        if (unexpected !== undefined)
+            return validationFailure(`Unexpected tasks[${index}] field: ${unexpected}`, tool);
+        const id = readNonEmptyString(record.value, 'id', tool);
+        if (!id.ok)
+            return id;
+        const category = readRequiredOneOf(record.value, 'category', parallelBatchCategories, tool);
+        if (!category.ok)
+            return category;
+        const agentName = readNonEmptyString(record.value, 'agentName', tool);
+        if (!agentName.ok)
+            return agentName;
+        const workspaceRoot = readNonEmptyString(record.value, 'workspaceRoot', tool);
+        if (!workspaceRoot.ok)
+            return workspaceRoot;
+        const allowedTools = readRequiredStringArray(record.value, 'allowedTools', tool);
+        if (!allowedTools.ok)
+            return allowedTools;
+        const scopeSummary = readNonEmptyString(record.value, 'scopeSummary', tool);
+        if (!scopeSummary.ok)
+            return scopeSummary;
+        const independenceRationale = readNonEmptyString(record.value, 'independenceRationale', tool);
+        if (!independenceRationale.ok)
+            return independenceRationale;
+        const riskTier = readRequiredOneOf(record.value, 'riskTier', parallelBatchRiskTiers, tool);
+        if (!riskTier.ok)
+            return riskTier;
+        if (typeof record.value.requiresPreflight !== 'boolean')
+            return validationFailure('requiresPreflight must be a boolean', tool);
+        const task = {
+            id: id.value,
+            category: category.value,
+            agentName: agentName.value,
+            workspaceRoot: workspaceRoot.value,
+            allowedTools: allowedTools.value,
+            scopeSummary: scopeSummary.value,
+            independenceRationale: independenceRationale.value,
+            riskTier: riskTier.value,
+            requiresPreflight: record.value.requiresPreflight,
+        };
+        const targetPaths = readOptionalStringArray(record.value, 'targetPaths', tool);
+        if (!targetPaths.ok)
+            return targetPaths;
+        if (targetPaths.value !== undefined)
+            task.targetPaths = targetPaths.value;
+        const dependsOn = readOptionalStringArray(record.value, 'dependsOn', tool);
+        if (!dependsOn.ok)
+            return dependsOn;
+        if (dependsOn.value !== undefined)
+            task.dependsOn = dependsOn.value;
+        if (record.value.recursiveDelegationAllowed !== undefined) {
+            if (typeof record.value.recursiveDelegationAllowed !== 'boolean')
+                return validationFailure('recursiveDelegationAllowed must be a boolean', tool);
+            task.recursiveDelegationAllowed = record.value.recursiveDelegationAllowed;
+        }
+        tasks.push(task);
+    }
+    return { ok: true, value: tasks };
+}
+function readParallelBatchSynthesis(value, tool) {
+    const record = asRecord(value, tool, 'synthesis must be an object');
+    if (!record.ok)
+        return record;
+    const required = ['required', 'includeEvidence', 'includeConflicts', 'includeFailures', 'includeResidualRisk', 'includeNextAction'];
+    const unexpected = Object.keys(record.value).find((key) => !required.includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected synthesis field: ${unexpected}`, tool);
+    for (const field of required) {
+        if (record.value[field] !== true)
+            return validationFailure(`synthesis.${field} must be true`, tool);
+    }
+    return { ok: true, value: record.value };
+}
 export function validateRunPreflightInput(input, tool) {
     const record = inputRecord(input, tool, [
         'runId',

package/dist/interfaces/mcp/validation.js

@@ -5,7 +5,7 @@ import { asRecord, readString, toValidationResultFailure, validationFailure, val
 import { validateGovernanceReportInput } from './validation/governance.js';
 import { validateMemoryGetInput, validateMemorySaveInput, validateMemorySearchInput, validateMemoryUpdateInput } from './validation/memory.js';
 import { validateProviderChangePlanInput, validateProviderHealthInput } from './validation/providers.js';
-import { validateRunCheckpointInput, validateRunFinalizeInput, validateRunGetInput, validateRunListInput, validateRunPreflightInput, validateRunResumeCandidatesInput, validateRunResumeGateInput, validateRunResumeInspectInput, validateRunStartInput, validateRunTaskGrantCreateInput, validateRunTaskGrantGetInput, validateRunTaskGrantListInput, validateRunTaskGrantPreviewMatchInput, validateRunTaskGrantRevokeInput, } from './validation/runs.js';
+import { validateRunCheckpointInput, validateRunFinalizeInput, validateRunGetInput, validateRunListInput, validateRunParallelBatchValidateInput, validateRunPreflightInput, validateRunResumeCandidatesInput, validateRunResumeGateInput, validateRunResumeInspectInput, validateRunStartInput, validateRunTaskGrantCreateInput, validateRunTaskGrantGetInput, validateRunTaskGrantListInput, validateRunTaskGrantPreviewMatchInput, validateRunTaskGrantRevokeInput, } from './validation/runs.js';
 import { validateContextCockpitInput, validateResumeContextInput, validateSddAcceptArtifactInput, validateSddCockpitInput, validateSddContinueInput, validateSddGetArtifactInput, validateSddGetReadinessInput, validateSddListArtifactsInput, validateSddNextInput, validateSddReadyInput, validateSddReopenArtifactInput, validateSddSaveArtifactInput, validateSddStatusInput, } from './validation/sdd.js';
 import { validateSessionAppendActivityInput, validateSessionCloseInput, validateSessionRestoreInput, validateSessionStartInput, } from './validation/sessions.js';
 import { validateSkillActivateInput, validateSkillCreateDraftInput, validateSkillGetEvaluationInput, validateSkillGetInput, validateSkillIndexInput, validateSkillListEvaluationsInput, validateSkillListImprovementProposalsInput, validateSkillPayloadInput, validateSkillProposeImprovementInput, validateSkillPublishVersionInput, validateSkillRecordUsageInput, validateSkillRequestEvaluationInput, validateSkillSearchInput, validateSkillStatusInput, validateSkillUpdateDraftInput, } from './validation/skills.js';
@@ -113,6 +113,8 @@ export function validateVgxMcpToolCall(call) {
             return validationSuccess(tool.value, validateRunListInput(input, tool.value));
         case 'vgxness_run_get':
             return validationSuccess(tool.value, validateRunGetInput(input, tool.value));
+        case 'vgxness_run_parallel_batch_validate':
+            return validationSuccess(tool.value, validateRunParallelBatchValidateInput(input, tool.value));
         case 'vgxness_run_preflight':
             return validationSuccess(tool.value, validateRunPreflightInput(input, tool.value));
         case 'vgxness_run_task_grant_create':

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/docs/mcp.md

@@ -1,6 +1,6 @@
 # MCP tools
 
-VGXNESS exposes 43 typed MCP tools over stdio through `vgxness mcp start`. The canonical list is the `SUPPORTED_VGX_MCP_TOOL_NAMES` array in `src/mcp/schema.ts` — treat that as the source of truth. The list below mirrors it; if a tool appears here that is not in the array, or vice versa, the array wins.
+VGXNESS exposes 63 typed MCP tools over stdio through `vgxness mcp start`. The canonical list is the `SUPPORTED_VGX_MCP_TOOL_NAMES` array in `src/mcp/schema.ts` — treat that as the source of truth. The list below mirrors it; if a tool appears here that is not in the array, or vice versa, the array wins.
 
 Tools are exposed under the `vgxness_*` prefix. Some MCP hosts strip the prefix and accept the short form (`sdd_status`, `memory_save`, etc.). The schema accepts both.
 
@@ -83,12 +83,13 @@ Payload tools that accept `agentId` resolve it as a canonical registry id first.
 | `vgxness_opencode_manager_payload` | Build the OpenCode manager payload envelope. | `OpenCodeManagerPayloadInput` shape (project, scope, agent, workflow/phase, workspaceRoot, maxSourceBytes, payloadMode) | `installable: false`, `readOnly: true`. |
 | `vgxness_opencode_handoff_preview` | Compose a full handoff preview: provider artifacts + skill diagnostics + SDD status + provider status + safety flags. | `project`; optional `scope`, `agentId`, `agentName`, `workspaceRoot`, `maxSourceBytes`, `change`, `phase` | Read-only preview. Does not execute OpenCode, install hooks, write provider config, or capture memory candidates. |
 
-## Runs (9)
+## Runs (15)
 
 | Tool | Purpose | Required inputs | Notes |
 |---|---|---|---|
 | `vgxness_run_list` | List runs with filters. | `limit`; optional `project`, `status` (one of the 8 `RunStatus` values) | |
 | `vgxness_run_get` | Read a run with `events`, `checkpoints`, `approvals`, `operationAttempts`. | `id` | |
+| `vgxness_run_parallel_batch_validate` | Validate a bounded parallel subagent batch plan before provider-native launch. | `tasks`, `synthesis`; optional `maxConcurrency`, `defaultMaxConcurrency`, `hardMaxConcurrency`, `allowedAgentNames` | Read-only validation surface. Default concurrency is 3 unless configured. Does not launch subagents, invoke providers, mutate runs, or write SDD artifacts; it returns launch guidance for OpenCode native delegation. |
 | `vgxness_run_start` | Create a run record. | `CreateRunInput` shape | |
 | `vgxness_run_checkpoint` | Append a resumable JSON state. | `AppendRunCheckpointInput` shape | |
 | `vgxness_run_finalize` | Finalize a run with `outcome` and `outcomeReason`. | `FinalizeRunInput` shape | `outcome` must match a terminal `status`. Re-finalization is rejected. May return advisory `memoryCapture` candidates from bounded finalization fields; candidates are not persisted automatically. |
@@ -161,6 +162,20 @@ vgxness_run_finalize    { runId, outcome: "success", outcomeReason: "..." }
 
 `vgxness_run_preflight` output includes `workspaceStrategy` with one of `current-checkout`, `branch`, `manual-worktree`, or `stacked-prs`. This is advisory planning metadata only. Its execution guarantees are always non-mutating (`createsBranch:false`, `createsWorktree:false`, `createsPullRequest:false`, `mutatesRepository:false`, `mutatesProviderConfig:false`). Treat `manual-worktree` and `stacked-prs` as instructions for a human or future executor to arrange review/isolation deliberately before mutation, not as evidence that VGXNESS already created Git state.
 
+Validating a parallel subagent batch before provider-native launch:
+
+```text
+vgxness_run_parallel_batch_validate {
+  maxConcurrency: 3,
+  tasks: [
+    { id, category: "analysis", agentName, workspaceRoot, allowedTools, scopeSummary, independenceRationale, riskTier: "read-only", requiresPreflight: false }
+  ],
+  synthesis: { required: true, includeEvidence: true, includeConflicts: true, includeFailures: true, includeResidualRisk: true, includeNextAction: true }
+}
+```
+
+`vgxness_run_parallel_batch_validate` is a guardrail, not an executor. It checks batch size, configured concurrency, independent tasks, allowlisted agents, no recursive delegation, implementation preflight requirements, and synthesis obligations. When validation succeeds, the manager may use the provider's native subagent/delegation capability (for example OpenCode native delegation) while respecting the validated `maxConcurrency`. MCP itself does not launch or monitor those subagents.
+
 Finding interrupted runs when the run id is unknown:
 
 ```text
@@ -177,6 +192,7 @@ MCP tools do not:
 
 - Write project-local provider config (`.opencode/`, `.mcp.json`, `.claude/`, project-root `CLAUDE.md`). VGX-managed OpenCode and Claude writes are user-global only and must stay behind explicit install/apply confirmation outside read-only status/preview tools.
 - Execute providers (`opencode`, `claude`, etc.).
+- Launch subagents. Parallel subagent launch is provider-native after `vgxness_run_parallel_batch_validate` succeeds; MCP validates only.
 - Install global memory.
 - Persist `memoryCapture` lifecycle candidates automatically or use them as proof of SDD acceptance, readiness, verification, approval, or authorization.
 - Create `openspec/`.

package/docs/safety.md

@@ -68,6 +68,20 @@ The experimental `vgxness code` runtime approval flow was removed with `src/code
 
 The gateway is conservative by default: a non-`read` tool in a non-`apply-progress` phase defaults to `ask`. Even with `--approval-policy allow`, the gateway can re-promote to `ask` for risky categories or workspace boundary issues.
 
+## Parallel subagent delegation
+
+Parallel delegation is provider-native, not an MCP executor. The manager may decide to fan out independent analysis, verification, research, review, debugging, SDD drafting/review, or context-scoped implementation work, but the plan should pass through `vgxness_run_parallel_batch_validate` first when using the VGXNESS MCP control plane.
+
+`vgxness_run_parallel_batch_validate` is read-only and validates only:
+
+- default concurrency is 3 unless a smaller/larger bounded value is configured;
+- every task must declare category, agent, workspace root, allowed tools, scope, independence rationale, risk tier, and preflight requirement;
+- same-batch dependencies and recursive delegation are rejected;
+- implementation tasks require target paths and preflight declaration;
+- synthesis must include evidence, conflicts, failures, residual risk, and next action.
+
+The MCP tool does not launch subagents, invoke providers, mutate run state, write artifacts, or monitor provider-native executions. OpenCode or another provider performs the actual subagent launch after validation, and normal preflight/approval rules still apply to risky or mutating work.
+
 ## Task-scoped external command grants
 
 Task-scoped command grants are a narrow V1 escape hatch for a human to authorize a bounded external working directory for an allowlisted command preflight. They only convert an eligible `ask` decision to an audited `allow`; they never convert `deny` or hard-risk requests to `allow`, and apply/implementation work still requires the normal SDD governance gates.

package/package.json

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