vgxness 1.20.4 → 1.20.6

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

@@ -1,245 +1 @@
-import { canonicalBehaviorContractVersion } from '../behavior/behavior-contract-manifest.js';
-export const canonicalDefaultAgentName = 'vgxness-manager';
-export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
-export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 18;
-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 function validateCanonicalAgentManifest(manifest) {
-    const errors = [];
-    if (manifest.version !== 1)
-        errors.push('manifest.version must be 1');
-    if (!manifest.project.trim())
-        errors.push('manifest.project is required');
-    if (manifest.scope !== 'project' && manifest.scope !== 'personal')
-        errors.push('manifest.scope must be project or personal');
-    if (!Number.isInteger(manifest.promptContractVersion) || manifest.promptContractVersion <= 0)
-        errors.push('manifest.promptContractVersion must be a positive integer');
-    if (!manifest.defaultAgentName.trim())
-        errors.push('manifest.defaultAgentName is required');
-    const ids = new Set();
-    const names = new Set();
-    const managers = manifest.agents.filter((agent) => agent.mode === 'agent');
-    if (managers.length !== 1)
-        errors.push(`manifest must declare exactly one manager agent; found ${managers.length}`);
-    if (!managers.some((agent) => agent.name === manifest.defaultAgentName))
-        errors.push(`manifest.defaultAgentName ${manifest.defaultAgentName} must match the manager agent`);
-    for (const agent of manifest.agents) {
-        const label = `agent ${agent.name || agent.id || '<unknown>'}`;
-        if (!agent.id.trim())
-            errors.push(`${label}.id is required`);
-        if (!agent.name.trim())
-            errors.push(`${label}.name is required`);
-        if (ids.has(agent.id))
-            errors.push(`duplicate canonical agent id: ${agent.id}`);
-        if (names.has(agent.name))
-            errors.push(`duplicate canonical agent name: ${agent.name}`);
-        ids.add(agent.id);
-        names.add(agent.name);
-        if (agent.builtIn !== true)
-            errors.push(`${label}.builtIn must be true`);
-        if (agent.mode === 'subagent' && !agent.parentAgentName?.trim())
-            errors.push(`${label}.parentAgentName is required for subagents`);
-        for (const [provider, support] of Object.entries(agent.providerSupport)) {
-            if (provider !== support.adapter)
-                errors.push(`${label}.providerSupport.${provider}.adapter must match provider key`);
-            if (support.level !== 'managed' && support.level !== 'preview' && support.level !== 'unsupported')
-                errors.push(`${label}.providerSupport.${provider}.level is invalid`);
-            if ((support.level === 'preview' || support.level === 'unsupported') && !support.reason?.trim())
-                errors.push(`${label}.providerSupport.${provider}.reason is required for ${support.level}`);
-        }
-    }
-    for (const agent of manifest.agents.filter((agent) => agent.mode === 'subagent')) {
-        if (agent.parentAgentName !== undefined && !names.has(agent.parentAgentName))
-            errors.push(`agent ${agent.name}.parentAgentName is missing: ${agent.parentAgentName}`);
-    }
-    return errors.length === 0 ? { ok: true } : { ok: false, errors };
-}
-function commonSupport() {
-    return {
-        opencode: { adapter: 'opencode', level: 'managed' },
-        claude: { adapter: 'claude', level: 'managed' },
-    };
-}
-function managerDefinition() {
-    return {
-        id: canonicalDefaultAgentName,
-        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.',
-        instructions: { kind: 'inline', value: registryManagerInstructionsV11 },
-        capabilities: ['sdd-orchestration', 'agent-routing', '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'],
-        skills: ['vgxness-sdd-manager'],
-        adapters: {
-            opencode: {
-                model: canonicalOpenCodeDefaultModel,
-                config: {
-                    options: {
-                        reasoningEffort: canonicalOpenCodeManagerReasoningEffort,
-                        vgxnessPromptContractVersion: canonicalPromptContractVersion,
-                        vgxnessBehaviorContractVersion: canonicalBehaviorContractVersion,
-                    },
-                    permission: { task: createCanonicalOpenCodeSddTaskPermissions(), ...createCanonicalOpenCodeSddMcpToolPermissions() },
-                },
-            },
-        },
-        providerSupport: commonSupport(),
-    };
-}
-function subagentDefinition(name) {
-    const data = subagentData[name];
-    return {
-        id: name,
-        mode: 'subagent',
-        builtIn: true,
-        parentAgentName: canonicalDefaultAgentName,
-        name,
-        description: data.seedDescription,
-        instructions: { kind: 'inline', value: data.seedInstructions },
-        capabilities: data.capabilities,
-        permissions: data.permissions,
-        memory: { scopes: ['project'] },
-        workflows: data.workflows,
-        skills: data.skills,
-        adapters: { opencode: { model: canonicalOpenCodeDefaultModel, config: { hidden: true, options: { vgxnessPromptContractVersion: canonicalPromptContractVersion, vgxnessBehaviorContractVersion: canonicalBehaviorContractVersion } } } },
-        providerSupport: commonSupport(),
-    };
-}
-export function createCanonicalOpenCodeSddTaskPermissions() {
-    return Object.fromEntries([['*', 'deny'], ...canonicalSddSubagentNames.map((name) => [name, 'allow'])]);
-}
-export function createCanonicalOpenCodeSddMcpToolPermissions() {
-    return {
-        vgxness_sdd_status: 'allow',
-        vgxness_sdd_next: 'allow',
-        vgxness_sdd_ready: 'allow',
-        vgxness_sdd_get_readiness: 'allow',
-        vgxness_sdd_get_artifact: 'allow',
-        vgxness_sdd_list_artifacts: 'allow',
-        vgxness_sdd_cockpit: 'allow',
-        vgxness_context_cockpit: 'allow',
-        vgxness_resume_context: 'allow',
-        vgxness_agent_resolve: 'allow',
-        vgxness_sdd_save_artifact: 'allow',
-        vgxness_memory_search: 'allow',
-        vgxness_memory_get: 'allow',
-        vgxness_memory_save: 'allow',
-        vgxness_memory_update: 'allow',
-        vgxness_skill_payload: 'allow',
-        vgxness_run_list: 'allow',
-        vgxness_run_preflight: 'allow',
-    };
-}
-export function createCanonicalOpenCodeSddSubagentPrompt(name) {
-    const phase = name.replace('vgxness-sdd-', '');
-    const common = `You are the VGXNESS SDD ${phase} executor, not the orchestrator. Do this phase's work yourself. Do NOT delegate, do NOT call task/delegate, and do NOT launch sub-agents. Use provided SDD artifacts, VGXNESS MCP state, and 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 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.`;
-}
-/**
- * Provider runtime prompt for generated provider managers.
- * This feeds the OpenCode default config and Claude generated agent files; it is
- * intentionally separate from registry/seed instructions below.
- */
-export const canonicalOpenCodeManagerPrompt = `# VGXNESS Manager
-
-Bind to \`vgxness-manager\` only.
-
-## Role
-Coordinate SDD; keep chat thin, use MCP state, delegate to exact SDD subagent. Coach while coordinating: teach briefly; explain practical tradeoffs, risk/effort/unknowns; challenge weak assumptions; keep user in control; avoid lectures. Always verify before agreeing with technical claims. When blocked, ask one focused question and stop.
-
-## Non-negotiable governance
-- VGXNESS uses SQLite artifacts/control-plane; OpenCode as primary provider; artifacts are not openspec files. Do not write to \`openspec/\`.
-- SDD artifact acceptance is human-only. Artifact presence is not acceptance. Never infer or fabricate acceptance from generated output, subagent/model output, file presence, confidence, or legacy artifacts; draft/rejected/superseded/stale/unaccepted artifacts are not accepted until a human acceptance record exists.
-- Before phase advancement, call \`vgxness_sdd_status\`/\`vgxness_sdd_next\` plus \`vgxness_sdd_ready\` or \`vgxness_sdd_get_readiness\`.
-- Before risky VGX-managed side effects (edit, shell/tests, git, network, provider-tool, secrets, external-directory, destructive, privileged, ambiguous), call \`vgxness_run_preflight\` with runId/workflow/phase/agent when available. Stop on approval/block; never invent approval.
-- Direct human acceptance 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.
-- bounded read/search repo tools may be enabled for inspection; bash, edit, and write remain denied. Diagnostics are config-level evidence, not host runtime proof.
-- Do not mutate provider/global OpenCode config. Do not publish packages unless explicitly requested. Never revert/overwrite unrelated user work. Preserve \`permission.task\` deny-by-default with only exact known SDD subagents.
-- Do not change provider model/reasoning config unless explicitly requested.
-
-## Routing
-Use lightest safe path: T0-2 direct, T3 preflight, T4 SDD.
-Do not invent or invoke generic reviewer subagents; use only exact canonical SDD subagents or MCP guidance.
-
-## 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\`. End/pause/handoff/compact with \`vgxness_session_close\` when a 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?".
-- Proposal clarity: if product/business clarity is missing, run a proposal question round.
-- SDD artifacts: guide with \`vgxness_sdd_next\`/\`vgxness_sdd_cockpit\`; read/list compact (payloadMode: "compact") via \`vgxness_sdd_get_artifact\`/\`vgxness_sdd_list_artifacts\`. After hidden subagent returns a valid current-phase artifact, save draft immediately with \`vgxness_sdd_save_artifact\`, summarize it, then ask: "Do you accept this artifact and should I continue to the next phase?" Use \`vgxness_sdd_reopen_artifact\` for rejected artifacts only, with explicit 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.
-- Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, run \`spec -> design -> tasks\` without extra human confirmation via subagents; save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Excludes explore/proposal/apply-progress/verify/archive, accepted overwrites, risky side effects; 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.
-- Memory: search/get for prior work and duplicate avoidance. Save/update only durable, actionable, scoped, evidence-backed, compact, non-sensitive observations. Prefer \`vgxness_memory_update\` over duplicate save when you know the id/topic key. Treat lifecycle \`memoryCapture\` as review-first advisory metadata only: no automatic persistence, no durable queue. Do not 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/authorization. SDD artifacts are canonical for phase deliverables and governance state. OpenCode previews/handoff are read-only and capture-free. Choose scope intentionally: \`project\` for repo facts, \`personal\` for reusable user preferences; \`memory-write\` requires preflight/explicit consent when governed or risky.
-- Active-work memory uses existing memory APIs only: \`active-work/{change}/summary\` (+others). No secrets or hidden reasoning. Active-work memory is advisory only; never proves SDD acceptance/readiness, verification, approval, or authorization.
-- Agents/skills: Use \`vgxness_skill_payload\` first for contextual skill guidance; preview/context-only, no provider execution or config writes. Use \`vgxness_skill_index\`/\`vgxness_skill_search\` only for explicit diagnostics/catalog, not normal resume fallback. Resolve phase with \`vgxness_agent_resolve\`; if none resolves, report evidence and ask for the smallest decision instead of inventing agent ids. \`vgxness_agent_activate\` and \`vgxness_opencode_manager_payload\` are preview/context-only. \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` needs explicit human authorization.
-- Runs/recovery: \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\`; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect; never pass runId as approvalId. Follow safe \`recommendedActions[]\`.
-- Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report \`providerEvidence.evidenceLevel\` and \`hostToolPresenceVerified\` limits; use vgxness_provider_status for configured/phase/next questions plus vgxness_provider_doctor for read-only OpenCode MCP/manager health.
-
-## Minimum flows
-- Proposal/spec/design/tasks: status/next -> readiness -> prereqs -> subagent -> save draft -> summarize -> ask accept+continue; trusted autorun may draft spec/design/tasks after accepted proposal; drafts stay unaccepted until human acceptance.
-- Apply/verify: prereqs -> artifacts -> exact subagent -> start/recover run -> preflight writes/shell/git/tests -> delegate -> checkpoint -> save -> finalize. Before apply/PR, review workload guard: estimate size/risk/reviewer load; recommend slicing into work units or chained PRs when large.
-- Config/provider/prompt change: inspect manager/profile/payload first; persistence needs explicit human authorization.
-- Recovery: MCP first. Continue: use \`vgxness_sdd_continue\`; read-only/advisory: no provider execution, run creation, artifact mutation, provider config/openspec writes, or acceptance/apply-progress bypass. CLI \`vgxness sdd continue\` is human fallback only. \`vgxness resume --project\` is for candidate runs. The removed experimental \`vgxness code\` runtime is not an SDD fallback.
-
-## Delegation thresholds
-Default to delegation for SDD phase-shaped work, repository exploration beyond one narrow lookup, implementation, verification, incident recovery, or multi-step analysis. Inline only conversational guidance, single-fact lookup, MCP/status/readiness checks, and trivial mechanical edits when safe. When uncertain between inline work and subagent work, delegate to the exact smallest SDD subagent. Never delegate to unknown agents; use exact phase mapping.
-
-## Output
-Be concise.`;
-/**
- * Registry/seed instructions for the manager agent definition.
- * These feed the canonical manifest, checked-in seed, boot upgrade, registry
- * render baselines, and manager profile overlay baselines; they are
- * intentionally distinct from the provider runtime prompt above.
- */
-const registryManagerInstructionsV11 = [
-    'You are the VGXNESS SDD coordinator, not a monolithic executor. Coach briefly while coordinating: explain useful tradeoffs, be realistic about risks and unknowns, respectfully challenge weak assumptions with better options, keep the user comfortable and in control, and stay concise. Always verify before agreeing with technical claims; when blocked, ask one focused question and stop.',
-    'Default to delegation for SDD phase-shaped work, repository exploration beyond one narrow lookup, implementation, verification, incident recovery, or multi-step analysis. Inline only conversational guidance, single-fact lookup, MCP/status/readiness checks, and trivial mechanical edits when safe. When uncertain between inline work and subagent work, delegate to the exact smallest SDD subagent. do not invent or invoke generic reviewer subagents; use exact canonical SDD 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?".',
-    '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.',
-    '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 may run sequentially as draft-only autorun without extra confirmation, while acceptance remains human-only. Memory capture policy: save/update only durable, future-relevant, actionable, scoped, evidence-backed, compact, non-sensitive observations; lifecycle memoryCapture candidates are review-first advisory metadata only, not persisted automatically, not a durable candidate queue, and still require explicit save/update policy and consent; 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; memory-write requires preflight/explicit consent when governed/risky. 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.',
-    '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.',
-    '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.',
-    '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': { seedDescription: 'Investigates codebase context and identifies options before proposals.', seedInstructions: 'You are the explore phase executor, not the orchestrator. Do not delegate. Explore repository evidence for the requested SDD change. Do not implement code changes. Return concise findings, risks, and recommended next artifacts.', capabilities: ['sdd-exploration', 'codebase-research', 'discovery'], permissions: { read: 'allow', edit: 'deny', shell: 'allow', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:explore'], skills: ['vgxness-sdd-explore'], phaseContract: 'Investigate codebase context, constraints, options, and risks. Do not implement code changes. Return findings and recommended next artifacts.' },
-    'vgxness-sdd-propose': { seedDescription: 'Creates focused change proposals from exploration findings.', seedInstructions: 'You are the proposal phase executor, not the orchestrator. Do not delegate. Create a focused SDD proposal from exploration evidence. Do not implement code changes. Identify scope, tradeoffs, non-goals, and acceptance direction.', capabilities: ['sdd-proposal', 'proposal-planning', 'scope-definition'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:proposal'], skills: ['vgxness-sdd-proposal'], phaseContract: 'Create or refine a focused SDD proposal from exploration evidence. Do not implement code changes. Include scope, tradeoffs, non-goals, and acceptance direction.' },
-    'vgxness-sdd-spec': { seedDescription: 'Writes detailed requirements and acceptance criteria for SDD changes.', seedInstructions: 'You are the spec phase executor, not the orchestrator. Do not delegate. Write a detailed SDD specification with requirements, acceptance criteria, edge cases, and out-of-scope items. Do not implement code changes.', capabilities: ['sdd-specification', 'requirements', 'acceptance-criteria'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:spec'], skills: ['vgxness-sdd-spec'], phaseContract: 'Write requirements, acceptance criteria, edge cases, and out-of-scope items. Do not implement code changes.' },
-    'vgxness-sdd-design': { seedDescription: 'Creates technical design from accepted proposals and accepted or trusted draft specs.', seedInstructions: 'You are the design phase executor, not the orchestrator. Do not delegate. Create a technical design grounded in the repository. Identify affected modules, data shapes, risks, rollout, and verification strategy. Do not implement code changes.', capabilities: ['sdd-design', 'technical-design', 'architecture-planning'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:design'], skills: ['vgxness-sdd-design'], phaseContract: 'Create technical design grounded in the repository: affected modules, data shapes, safety, rollout, and verification. You may use an accepted spec or a trusted draft spec produced in the manager autorun chain. Do not implement code changes.' },
-    'vgxness-sdd-tasks': { seedDescription: 'Breaks accepted or trusted draft specs and designs into implementation tasks.', seedInstructions: 'You are the tasks phase executor, not the orchestrator. Do not delegate. Break the SDD spec/design into small, ordered, testable implementation tasks. 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'], permissions: { read: 'allow', edit: 'deny', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:tasks'], skills: ['vgxness-sdd-tasks'], phaseContract: 'Break accepted or trusted draft spec/design into small ordered testable implementation tasks. Include a Review Workload Forecast covering expected review size, risk, and reviewer burden. Do not implement code changes.' },
-    'vgxness-sdd-apply': { seedDescription: 'Implements code changes from SDD task definitions.', seedInstructions: 'You are the apply phase executor, not the orchestrator. Implement only the assigned SDD tasks directly. Do not delegate. Keep changes small, preserve unrelated user work, run focused checks when authorized, and report changed files plus verification evidence.', capabilities: ['sdd-apply', 'implementation', 'code-change'], permissions: { read: 'allow', edit: 'ask', shell: 'allow', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:apply-progress'], skills: ['vgxness-sdd-apply'], phaseContract: 'Implement only assigned SDD tasks. Preserve unrelated dirty files and user work. Use focused tests when authorized. Report changed files, tests/evidence, and residual risks.' },
-    'vgxness-sdd-verify': { seedDescription: 'Validates implementation against specs, tasks, and evidence.', seedInstructions: 'You are the verify phase executor, not the orchestrator. Do not delegate. Verify the implementation against SDD artifacts. Prefer focused local tests, inspect evidence, and report residual risk. Do not implement unrelated changes.', capabilities: ['sdd-verify', 'verification', 'test-review', 'risk-review'], permissions: { read: 'allow', edit: 'deny', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:verify'], skills: ['vgxness-sdd-verify'], phaseContract: 'Validate implementation against SDD artifacts and task acceptance criteria. Prefer focused local tests and evidence review. Do not implement unrelated changes.' },
-    'vgxness-sdd-archive': { seedDescription: 'Archives completed SDD change artifacts and outcomes.', seedInstructions: 'You are the archive phase executor, not the orchestrator. Do not delegate. Archive completed SDD artifacts and summarize final outcome, verification, and follow-ups. Confirm before writes beyond the requested archive artifact.', capabilities: ['sdd-archive', 'artifact-archive', 'release-notes'], permissions: { read: 'allow', edit: 'ask', shell: 'deny', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:archive'], skills: ['vgxness-sdd-archive'], phaseContract: 'Archive completed SDD outcome with summary, verification evidence, follow-ups, and residual risks. Confirm before any repository writes beyond the requested archive artifact.' },
-    'vgxness-sdd-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'], permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:init', 'setup'], 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': { 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'], permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'deny', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' }, workflows: ['sdd:onboard', 'sdd'], skills: [], phaseContract: 'Guide the user through the SDD cycle with the smallest missing decision at each step. Keep assumptions explicit and confirm before writes or provider/global config changes.' },
-};
-export const canonicalAgentManifest = {
-    version: 1,
-    project: 'vgxness',
-    scope: 'project',
-    promptContractVersion: canonicalPromptContractVersion,
-    defaultAgentName: canonicalDefaultAgentName,
-    agents: [managerDefinition(), ...canonicalSddSubagentNames.map(subagentDefinition)],
-};
+export * from '../domain/agents/canonical-agent-manifest.js';

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

@@ -1,236 +1 @@
-import { canonicalAgentManifest, canonicalDefaultAgentName, canonicalOpenCodeManagerReasoningEffort, canonicalOpenCodeManagerPrompt, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddSubagentPrompt, createCanonicalOpenCodeSddTaskPermissions, validateCanonicalAgentManifest, } from './canonical-agent-manifest.js';
-import { composeManagerInstructions } from './manager-profile-overlay-service.js';
-export function canonicalManifestValidationErrors(manifest = canonicalAgentManifest) {
-    const validation = validateCanonicalAgentManifest(manifest);
-    return validation.ok ? [] : validation.errors;
-}
-export function projectCanonicalAgentManifestToSeed(manifest = canonicalAgentManifest) {
-    assertValidCanonicalManifest(manifest);
-    const agents = manifest.agents.filter((agent) => agent.mode === 'agent').map(toSeedAgent);
-    const subagents = manifest.agents.filter((agent) => agent.mode === 'subagent').map(toSeedSubagent);
-    return { version: 1, project: manifest.project, scope: manifest.scope, agents, subagents };
-}
-export function projectCanonicalAgentManifestToOpenCode(manifest = canonicalAgentManifest) {
-    assertValidCanonicalManifest(manifest);
-    const manager = manifest.agents.find((agent) => agent.name === manifest.defaultAgentName && agent.mode === 'agent');
-    if (manager === undefined)
-        throw new Error(`Canonical OpenCode projection missing manager agent: ${manifest.defaultAgentName}`);
-    const agents = {
-        [canonicalDefaultAgentName]: {
-            description: 'VGXNESS SDD Manager - coordinates MCP state and SDD sub-agents, avoids inline execution when delegation is safer',
-            mode: 'primary',
-            ...(manager.adapters?.opencode?.model !== undefined ? { model: manager.adapters.opencode.model } : {}),
-            options: { reasoningEffort: canonicalOpenCodeManagerReasoningEffort, vgxnessPromptContractVersion: canonicalPromptContractVersion },
-            permission: openCodeManagerPermissionsFor(manager),
-            prompt: canonicalOpenCodeManagerPrompt,
-            reasoningEffort: canonicalOpenCodeManagerReasoningEffort,
-            tools: openCodeManagerTools(),
-            variant: '',
-        },
-    };
-    for (const name of canonicalSddSubagentNames) {
-        const subagent = manifest.agents.find((agent) => agent.name === name && agent.mode === 'subagent');
-        if (subagent === undefined)
-            throw new Error(`Canonical OpenCode projection missing subagent: ${name}`);
-        agents[name] = {
-            description: openCodeSubagentDescriptions[name],
-            hidden: true,
-            mode: 'subagent',
-            ...(subagent.adapters?.opencode?.model !== undefined ? { model: subagent.adapters.opencode.model } : {}),
-            options: { vgxnessPromptContractVersion: canonicalPromptContractVersion },
-            prompt: createCanonicalOpenCodeSddSubagentPrompt(name),
-            permission: openCodePermissionsFor(subagent),
-            tools: { bash: true, edit: true, read: true, write: true },
-        };
-    }
-    return { defaultAgent: canonicalDefaultAgentName, agents };
-}
-export function withEffectiveOpenCodeManagerInstructions(projection, instructions) {
-    const trimmed = instructions?.trim() ?? '';
-    if (trimmed === '')
-        return projection;
-    const manager = projection.agents[projection.defaultAgent];
-    if (manager === undefined)
-        return projection;
-    return {
-        defaultAgent: projection.defaultAgent,
-        agents: {
-            ...projection.agents,
-            [projection.defaultAgent]: { ...manager, prompt: composeManagerInstructions(manager.prompt, trimmed) },
-        },
-    };
-}
-export function projectCanonicalAgentManifestToClaudeCode(manifest = canonicalAgentManifest) {
-    assertValidCanonicalManifest(manifest);
-    const manager = manifest.agents.find((agent) => agent.name === manifest.defaultAgentName && agent.mode === 'agent');
-    if (manager === undefined)
-        throw new Error(`Canonical Claude projection missing manager agent: ${manifest.defaultAgentName}`);
-    const agents = [
-        {
-            name: canonicalDefaultAgentName,
-            canonicalName: canonicalDefaultAgentName,
-            description: manager.description,
-            fileName: `${canonicalDefaultAgentName}.md`,
-            instructions: canonicalOpenCodeManagerPrompt,
-            promptContractVersion: canonicalPromptContractVersion,
-        },
-    ];
-    for (const mapping of claudeSddNameMappings) {
-        const subagent = manifest.agents.find((agent) => agent.name === mapping.canonical && agent.mode === 'subagent');
-        if (subagent === undefined)
-            throw new Error(`Canonical Claude projection missing subagent: ${mapping.canonical}`);
-        agents.push({
-            name: mapping.claude,
-            canonicalName: mapping.canonical,
-            description: claudeSubagentDescriptions[mapping.claude],
-            fileName: `${mapping.claude}.md`,
-            instructions: createCanonicalOpenCodeSddSubagentPrompt(mapping.canonical),
-            promptContractVersion: canonicalPromptContractVersion,
-        });
-    }
-    return { defaultAgent: canonicalDefaultAgentName, agents };
-}
-export function withEffectiveManagerInstructions(projection, instructions) {
-    const trimmed = instructions?.trim() ?? '';
-    if (trimmed === '')
-        return projection;
-    const agents = projection.agents.map((agent) => agent.canonicalName === projection.defaultAgent ? { ...agent, instructions: composeManagerInstructions(agent.instructions, trimmed) } : agent);
-    return { defaultAgent: projection.defaultAgent, agents };
-}
-export function projectCanonicalAgentManifestToClaudeProjectMemory(manifest = canonicalAgentManifest) {
-    assertValidCanonicalManifest(manifest);
-    return {
-        defaultAgent: canonicalDefaultAgentName,
-        promptContractVersion: canonicalPromptContractVersion,
-        repositoryInstructions: 'AGENTS.md',
-        guidance: [
-            `Use \`${canonicalDefaultAgentName}\` as the VGXNESS project manager/personality for this project.`,
-            'Follow project-root `AGENTS.md` when present.',
-            'Use VGXNESS MCP as durable state for SDD artifacts, runs, memory, agents, permissions, and provider diagnostics.',
-            'SDD artifact acceptance is human-only; never infer acceptance from generated output or file presence.',
-            'Before phase advancement, check VGXNESS SDD readiness/status.',
-            'Preserve confirmation and preflight requirements for risky side effects.',
-            'Do not tell users to run terminal SDD phase commands for normal daily SDD flow.',
-            'Be concise, evidence-grounded, user-controlled, practical, and willing to challenge unsafe assumptions.',
-        ],
-    };
-}
-export function canonicalProviderProjection(provider, manifest = canonicalAgentManifest) {
-    assertValidCanonicalManifest(manifest);
-    const normalized = provider.trim().toLowerCase();
-    if (normalized === 'opencode')
-        return { provider: normalized, level: 'managed', manifest, projection: projectCanonicalAgentManifestToOpenCode(manifest) };
-    if (normalized === 'claude')
-        return { provider: normalized, level: 'managed', manifest, projection: projectCanonicalAgentManifestToClaudeCode(manifest) };
-    return { provider: normalized, level: 'unsupported', manifest, reason: `Unsupported provider projection: ${provider}` };
-}
-function assertValidCanonicalManifest(manifest) {
-    const errors = canonicalManifestValidationErrors(manifest);
-    if (errors.length > 0)
-        throw new Error(`Invalid canonical agent manifest: ${errors.join('; ')}`);
-}
-function openCodePermissionsFor(agent, additional = {}) {
-    const adapterPermission = asRecord(agent.adapters?.opencode?.config?.permission);
-    return { ...adapterPermission, ...additional, ...mapCanonicalPermissionsToOpenCode(agent.permissions) };
-}
-function openCodeManagerPermissionsFor(agent) {
-    return {
-        ...openCodePermissionsFor(agent, { task: createCanonicalOpenCodeSddTaskPermissions() }),
-        bash: 'deny',
-        edit: 'deny',
-        read: 'allow',
-        write: 'deny',
-    };
-}
-function openCodeManagerTools() {
-    return {
-        bash: false,
-        delegate: true,
-        delegation_list: true,
-        delegation_read: true,
-        edit: false,
-        glob: true,
-        grep: true,
-        read: true,
-        write: false,
-    };
-}
-function mapCanonicalPermissionsToOpenCode(permissions) {
-    const mapped = {};
-    if (permissions === undefined)
-        return mapped;
-    for (const [canonical, openCode] of openCodePermissionMappings) {
-        const decision = permissions[canonical];
-        if (decision !== undefined)
-            mapped[openCode] = decision;
-    }
-    return mapped;
-}
-function asRecord(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    return value;
-}
-const openCodePermissionMappings = [
-    ['read', 'read'],
-    ['edit', 'edit'],
-    ['shell', 'bash'],
-    ['external-directory', 'external_directory'],
-];
-function toSeedAgent(agent) {
-    const seed = {
-        name: agent.name,
-        description: agent.description,
-        instructions: agent.instructions,
-    };
-    if (agent.capabilities !== undefined)
-        seed.capabilities = agent.capabilities;
-    if (agent.permissions !== undefined)
-        seed.permissions = agent.permissions;
-    if (agent.memory !== undefined)
-        seed.memory = agent.memory;
-    if (agent.workflows !== undefined)
-        seed.workflows = agent.workflows;
-    if (agent.skills !== undefined)
-        seed.skills = agent.skills;
-    if (agent.adapters !== undefined)
-        seed.adapters = agent.adapters;
-    return seed;
-}
-function toSeedSubagent(agent) {
-    if (agent.parentAgentName === undefined)
-        throw new Error(`Canonical subagent ${agent.name} is missing parentAgentName`);
-    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',
-};
-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' },
-];
-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.',
-};
+export * from '../application/agents/canonical-agent-projection.js';

package/dist/agents/manager-profile-overlay-service.js

@@ -1,60 +1 @@
-import { AgentRegistryService } from './agent-registry-service.js';
-import { ManagerProfileOverlayRepository } from './repositories/manager-profile-overlays.js';
-export class ManagerProfileOverlayService {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
-    save(input) {
-        return this.dependencies.overlays.save(input);
-    }
-    get(project, scope, managerName) {
-        return this.dependencies.overlays.get(project, scope, managerName);
-    }
-    resolveEffectiveManager(input) {
-        const manager = this.dependencies.agents.getAgentByName(input.project, input.scope, input.managerName);
-        if (!manager.ok)
-            return manager;
-        if (manager.value.mode !== 'agent')
-            return validationFailure('Effective manager requires a top-level agent');
-        const overlay = this.dependencies.overlays.get(input.project, input.scope, input.managerName);
-        if (!overlay.ok) {
-            if (overlay.error.code === 'not_found')
-                return ok({ manager: manager.value });
-            return overlay;
-        }
-        return ok({
-            manager: {
-                ...manager.value,
-                instructions: { kind: 'inline', value: composeManagerInstructions(manager.value.instructions.value, overlay.value.instructions) },
-            },
-            overlay: overlay.value,
-        });
-    }
-}
-export function composeManagerInstructions(baseline, overlay) {
-    const baselineInstructions = baseline.trim();
-    const overlayInstructions = overlay.trim();
-    if (baselineInstructions === '')
-        return overlayInstructions;
-    if (overlayInstructions === '')
-        return baselineInstructions;
-    if (overlayInstructions.includes(baselineInstructions))
-        return overlayInstructions;
-    return `${baselineInstructions}\n\n## Manager profile overlay\n${overlayInstructions}`;
-}
-function ok(value) {
-    return { ok: true, value };
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
-export function computeEffectiveManagerInstructions(database, project = 'vgxness', scope = 'project', managerName = 'vgxness-manager') {
-    const registry = new AgentRegistryService(database);
-    const overlays = new ManagerProfileOverlayRepository(database);
-    const service = new ManagerProfileOverlayService({ agents: registry, overlays });
-    const resolved = service.resolveEffectiveManager({ project, scope, managerName });
-    if (!resolved.ok || resolved.value.overlay === undefined)
-        return undefined;
-    return resolved.value.manager.instructions.value.trim() || undefined;
-}
+export * from '../application/agents/manager-profile-overlay-service.js';

package/dist/agents/profile-model-routing.js

@@ -1,30 +1 @@
-export function resolveAgentProfileModel(input) {
-    const providerAdapter = input.providerAdapter?.trim() || 'opencode';
-    const adapters = input.agent.adapters;
-    const adapterNames = Object.keys(adapters);
-    const adapter = adapters[providerAdapter];
-    if (adapterNames.length > 0 && adapter === undefined) {
-        return validationFailure(`Agent ${input.agent.name} does not declare provider adapter: ${providerAdapter}`);
-    }
-    const model = adapter?.model?.trim();
-    if (model !== undefined && model.length > 0) {
-        const profile = profileFromAdapter(adapter?.config);
-        return ok({ providerAdapter, model, ...(profile === undefined ? {} : { profile }), source: 'agent-adapter-model', warnings: [] });
-    }
-    const previewModel = `${providerAdapter}-preview`;
-    const warnings = adapter === undefined
-        ? [`Agent does not declare adapters; using provider-neutral preview model ${previewModel}.`]
-        : [`Adapter ${providerAdapter} does not declare a model; using ${previewModel}.`];
-    const profile = profileFromAdapter(adapter?.config);
-    return ok({ providerAdapter, model: previewModel, ...(profile === undefined ? {} : { profile }), source: 'provider-preview-default', warnings });
-}
-function profileFromAdapter(config) {
-    const profile = config?.profile;
-    return typeof profile === 'string' && profile.trim().length > 0 ? profile.trim() : undefined;
-}
-function ok(value) {
-    return { ok: true, value };
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
+export * from '../application/agents/profile-model-routing.js';