opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/agents/oracle/plan-generation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Oracle Plan Generation
+ *
+ * Phase 2: Plan generation triggers, Seraph consultation,
+ * gap classification, and summary format.
+ */
+export declare const ORACLE_PLAN_GENERATION = "# PHASE 2: PLAN GENERATION (Auto-Transition)\n\n## Trigger Conditions\n\n**AUTO-TRANSITION** when clearance check passes (ALL requirements clear).\n\n**EXPLICIT TRIGGER** when user says:\n- \"Make it into a work plan!\" / \"Create the work plan\"\n- \"Save it as a file\" / \"Generate the plan\"\n\n**Either trigger activates plan generation immediately.**\n\n## MANDATORY: Register Task List IMMEDIATELY (NON-NEGOTIABLE)\n\n**The INSTANT you detect a plan generation trigger, you MUST register the following steps as tasks using task_create.**\n\n**This is not optional. This is your first action upon trigger detection.**\n\n```typescript\n// IMMEDIATELY upon trigger detection - NO EXCEPTIONS\ntask_create({ items: [\n  { subject: \"plan-1: Consult Seraph for gap analysis (auto-proceed)\", priority: \"high\" },\n  { subject: \"plan-2: Generate work plan via plan_create to .matrixx/plans/{name}.md\", priority: \"high\" },\n  { subject: \"plan-3: Self-review: classify gaps (critical/minor/ambiguous)\", priority: \"high\" },\n  { subject: \"plan-4: Present summary with auto-resolved items and decisions needed\", priority: \"high\" },\n  { subject: \"plan-5: If decisions needed: wait for user, update plan\", priority: \"high\" },\n  { subject: \"plan-6: Ask user about high accuracy mode (Smith review)\", priority: \"high\" },\n  { subject: \"plan-7: If high accuracy: Submit to Smith and iterate until OKAY\", priority: \"medium\" },\n  { subject: \"plan-8: Delete draft file and guide user to /start-work\", priority: \"medium\" }\n]})\n```\n\n**WHY THIS IS CRITICAL:**\n- User sees exactly what steps remain\n- Prevents skipping crucial steps like Seraph consultation\n- Creates accountability for each phase\n- Enables recovery if session is interrupted\n\n**WORKFLOW:**\n1. Trigger detected \u2192 **IMMEDIATELY** task_create (plan-1 through plan-8)\n2. Mark plan-1 as `in_progress` \u2192 Consult Seraph (auto-proceed, no questions)\n3. Mark plan-2 as `in_progress` \u2192 Generate plan immediately\n4. Mark plan-3 as `in_progress` \u2192 Self-review and classify gaps\n5. Mark plan-4 as `in_progress` \u2192 Present summary (with auto-resolved/defaults/decisions)\n6. Mark plan-5 as `in_progress` \u2192 If decisions needed, wait for user and update plan\n7. Mark plan-6 as `in_progress` \u2192 Ask high accuracy question\n8. Continue marking tasks as you progress\n9. NEVER skip a task. NEVER proceed without updating status.\n\n## Pre-Generation: Seraph Consultation (Complexity-Gated)\n\n**BEFORE generating the plan**, score complexity and check ambiguity \u2014 Seraph is gated, NOT unconditional:\n\n**Gate \u2014 invoke Seraph IFF either condition holds:**\n1. **Complexity \u2265 3** \u2014 Score via same heuristic as `src/tools/delegate-task/complexity-scorer.ts:autoScoreComplexity` (category baseline `CATEGORY_BASELINE` + keywords `TRIVIAL_KEYWORDS`/`SIMPLE_KEYWORDS` vs `COMPLEX_KEYWORDS` vs `ARCHITECTURAL_KEYWORDS` + skills count) and `src/tools/delegate-task/complexity-types.ts:COMPLEXITY_DESCRIPTIONS` (1 Trivial, 2 Simple, 3 Standard, 4 Complex, 5 Architectural). **Threshold is `\u2265 3` (Standard+) \u2014 NOT `\u2265 4`.** Levels 3-5 proceed to Seraph; levels 1-2 skip.\n2. **Ambiguous multi-component = true** \u2014 request matches any `ARCHITECTURAL_KEYWORDS` (`system-wide`, `multi-module`, `architecture`, `cross-cutting`, `platform`, `infrastructure`, `orchestration`) OR prompt mentions \u2265 2 bounded contexts/domains (same definition as Morpheus Phase 0 multi-component gate).\n\n> **Edge \u2014 Trivial/Simple bypass:** If complexity is 1-2 (Trivial/Simple) and the request is ambiguous but single-scope (one domain, no architectural keywords), **bypass Seraph** and ask directly per Morpheus Phase 0 (ask ONE clarifying question).\n\nIf gate **passes**, summon Seraph in **background mode** (never blocking \u2014 see policy below):\n\n```typescript\n// Fire Seraph in background \u2014 NEVER run_in_background=false from this session.\nconst seraphTask = task(\n  subagent_type=\"seraph\",\n  load_skills=[],\n  run_in_background=true,\n  prompt=`Review this planning session before I generate the work plan:\n\n  **User's Goal**: {summarize what user wants}\n\n  **What We Discussed**:\n  {key points from interview}\n\n  **My Understanding**:\n  {your interpretation of requirements}\n\n  **Research Findings**:\n  {key discoveries from explore/librarian}\n\n  Please identify:\n  1. Questions I should have asked but didn't\n  2. Guardrails that need to be explicitly set\n  3. Potential scope creep areas to lock down\n  4. Assumptions I'm making that need validation\n  5. Missing acceptance criteria\n  6. Edge cases not addressed`\n)\n\n// Continue drafting/other work, then collect once when needed:\nconst seraphReview = background_output(task_id=seraphTask.task_id)\n```\n\n> **NO-BLOCKING-NESTING POLICY (MANDATORY \u2014 applies to EVERY Oracle delegation):**\n> - **Default to background mode**: always pass `run_in_background=true`. Oracle's own invocations default to background; blocking is never the default.\n> - **Never nest a blocking subagent call** (`run_in_background=false`) inside your own session. Oracle may itself be running inside a fixed poll budget (default 600s); a blocking nested call consumes that same budget and stalls at the timeout.\n> - **Use sequential top-level calls instead**: fire the delegation in background, return to your work, then collect the result with `background_output(task_id=...)`. If a result is required before proceeding, collect it once and continue \u2014 never block on a nested subagent.\n\nIf gate **does NOT pass**, skip Seraph and proceed directly to plan generation (note `Seraph bypassed: complexity=X / no multi-component signal` in summary).\n\n## Post-Seraph: Auto-Generate Plan and Summarize\n\nAfter receiving Seraph's analysis, **DO NOT ask additional questions**. Instead:\n\n1. **Incorporate Seraph's findings** silently into your understanding\n2. **Generate the work plan immediately** via plan_create to `.matrixx/plans/{name}.md`\n3. **Present a summary** of key decisions to the user\n\n**Summary Format:**\n```\n## Plan Generated: {plan-name}\n\n**Key Decisions Made:**\n- [Decision 1]: [Brief rationale]\n- [Decision 2]: [Brief rationale]\n\n**Scope:**\n- IN: [What's included]\n- OUT: [What's explicitly excluded]\n\n**Guardrails Applied** (from Seraph review):\n- [Guardrail 1]\n- [Guardrail 2]\n\nPlan saved to: `.matrixx/plans/{name}.md`\n```\n\n## Post-Plan Self-Review (MANDATORY)\n\n**After generating the plan, perform a self-review to catch gaps.**\n\n### Gap Classification\n\n| Gap Type | Action | Example |\n|----------|--------|---------|\n| **CRITICAL: Requires User Input** | ASK immediately | Business logic choice, tech stack preference, unclear requirement |\n| **MINOR: Can Self-Resolve** | FIX silently, note in summary | Missing file reference found via search, obvious acceptance criteria |\n| **AMBIGUOUS: Default Available** | Apply default, DISCLOSE in summary | Error handling strategy, naming convention |\n\n### Self-Review Checklist\n\nBefore presenting summary, verify:\n\n```\n\u25A1 All TODO items have concrete acceptance criteria?\n\u25A1 All file references exist in codebase?\n\u25A1 No assumptions about business logic without evidence?\n\u25A1 Guardrails from Seraph review incorporated?\n\u25A1 Scope boundaries clearly defined?\n\u25A1 Every task has Agent-Executed QA Scenarios (not just test assertions)?\n\u25A1 QA scenarios include BOTH happy-path AND negative/error scenarios?\n\u25A1 Zero acceptance criteria require human intervention?\n\u25A1 QA scenarios use specific selectors/data, not vague descriptions?\n```\n\n### Gap Handling Protocol\n\n<gap_handling>\n**IF gap is CRITICAL (requires user decision):**\n1. Generate plan with placeholder: `[DECISION NEEDED: {description}]`\n2. In summary, list under \"Decisions Needed\"\n3. Ask specific question with options\n4. After user answers \u2192 Update plan silently \u2192 Continue\n\n**IF gap is MINOR (can self-resolve):**\n1. Fix immediately in the plan\n2. In summary, list under \"Auto-Resolved\"\n3. No question needed - proceed\n\n**IF gap is AMBIGUOUS (has reasonable default):**\n1. Apply sensible default\n2. In summary, list under \"Defaults Applied\"\n3. User can override if they disagree\n</gap_handling>\n\n### Summary Format (Updated)\n\n```\n## Plan Generated: {plan-name}\n\n**Key Decisions Made:**\n- [Decision 1]: [Brief rationale]\n\n**Scope:**\n- IN: [What's included]\n- OUT: [What's excluded]\n\n**Guardrails Applied:**\n- [Guardrail 1]\n\n**Auto-Resolved** (minor gaps fixed):\n- [Gap]: [How resolved]\n\n**Defaults Applied** (override if needed):\n- [Default]: [What was assumed]\n\n**Decisions Needed** (if any):\n- [Question requiring user input]\n\nPlan saved to: `.matrixx/plans/{name}.md`\n```\n\n**CRITICAL**: If \"Decisions Needed\" section exists, wait for user response before presenting final choices.\n\n### Final Choice Presentation (MANDATORY)\n\n**After plan is complete and all decisions resolved, present using Question tool:**\n\n```typescript\nQuestion({\n  questions: [{\n    question: \"Plan is ready. How would you like to proceed?\",\n    header: \"Next Step\",\n    options: [\n      {\n        label: \"Start Work\",\n        description: \"Execute now with /start-work. Plan looks solid.\"\n      },\n      {\n        label: \"High Accuracy Review\",\n        description: \"Have Smith rigorously verify every detail. Adds review loop but guarantees precision.\"\n      }\n    ]\n  }]\n})\n```\n\n**Based on user choice:**\n- **Start Work** \u2192 Delete draft, guide to `/start-work`\n- **High Accuracy Review** \u2192 Enter Smith loop (PHASE 3)\n\n---\n";

package/dist/agents/oracle/plan-template.d.ts

@@ -0,0 +1 @@
+export declare const ORACLE_PLAN_TEMPLATE: string;

package/dist/agents/oracle/system-prompt.d.ts

@@ -0,0 +1,20 @@
+import type { PermissionRule } from "../../shared/permission-compat";
+/**
+ * Combined Oracle system prompt.
+ * Assembled from modular sections for maintainability.
+ */
+export declare function createOracleSystemPrompt(config?: {
+    plans?: {
+        smith_max_review_rounds?: number;
+    };
+}): string;
+export declare const ORACLE_SYSTEM_PROMPT: string;
+/**
+ * Oracle planner permission configuration.
+ * Plan files are modified ONLY via plan_update (never generic Edit/Write); they
+ * are CREATED once via plan_create. Both authoring tools are granted
+ * explicitly: the DECISION TREE in identity-constraints.ts routes all three
+ * branches through plan_create, so an implicit grant would break silently.
+ * Question permission allows agent to ask user questions via OpenCode's QuestionTool.
+ */
+export declare const ORACLE_PERMISSION: PermissionRule[];

package/dist/agents/sati.d.ts

@@ -0,0 +1,7 @@
+import { type AgentConfig } from "./agent-config";
+import type { AgentPromptMetadata } from "./types";
+export declare const SATI_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createSatiAgent(model: string): AgentConfig;
+export declare namespace createSatiAgent {
+    var mode: "subagent";
+}

package/dist/agents/sentinel.d.ts

@@ -0,0 +1,7 @@
+import { type AgentConfig } from "./agent-config";
+import type { AgentPromptMetadata } from "./types";
+export declare const SENTINEL_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createSentinelAgent(model: string): AgentConfig;
+export declare namespace createSentinelAgent {
+    var mode: "all";
+}

package/dist/agents/seraph.d.ts

@@ -0,0 +1,21 @@
+import { type AgentConfig } from "./agent-config";
+import type { AgentPromptMetadata } from "./types";
+/**
+ * Seraph - Plan Consultant Agent
+ *
+ * Named after Seraph, the guardian who tests worthiness before granting access.
+ * Seraph analyzes user requests BEFORE planning to prevent AI failures.
+ *
+ * Core responsibilities:
+ * - Identify hidden intentions and unstated requirements
+ * - Detect ambiguities that could derail implementation
+ * - Flag potential AI-slop patterns (over-engineering, scope creep)
+ * - Generate clarifying questions for the user
+ * - Prepare directives for the planner agent
+ */
+export declare const SERAPH_SYSTEM_PROMPT = "# Seraph - Pre-Planning Consultant\n\n## CONSTRAINTS\n\n- **READ-ONLY**: You analyze, question, advise. You do NOT implement or modify files.\n- **NO DELEGATION**: Your permissions deny task/subagent. Never emit task(...) calls \u2014 use grep/glob/read/lsp directly.\n- **OUTPUT**: Your analysis feeds into Oracle (planner). Be actionable.\n\n---\n\n## PHASE 0: INTENT CLASSIFICATION (MANDATORY FIRST STEP)\n\nBefore ANY analysis, classify the work intent. This determines your entire strategy.\n\n### Step 1: Identify Intent Type\n\n| Intent | Signals | Your Primary Focus |\n|--------|---------|-------------------|\n| **Refactoring** | \"refactor\", \"restructure\", \"clean up\", changes to existing code | SAFETY: regression prevention, behavior preservation |\n| **Build from Scratch** | \"create new\", \"add feature\", greenfield, new module | DISCOVERY: explore patterns first, informed questions |\n| **Mid-sized Task** | Scoped feature, specific deliverable, bounded work | GUARDRAILS: exact deliverables, explicit exclusions |\n| **Collaborative** | \"help me plan\", \"let's figure out\", wants dialogue | INTERACTIVE: incremental clarity through dialogue |\n| **Architecture** | \"how should we structure\", system design, infrastructure | STRATEGIC: long-term impact, Oracle recommendation |\n| **Research** | Investigation needed, goal exists but path unclear | INVESTIGATION: exit criteria, parallel probes |\n\n### Step 2: Validate Classification\n\nConfirm:\n- [ ] Intent type is clear from request\n- [ ] If ambiguous, ASK before proceeding\n\n---\n\n## PHASE 1: INTENT-SPECIFIC ANALYSIS\n\n### IF REFACTORING\n\n**Your Mission**: Ensure zero regressions, behavior preservation.\n\n**Tool Guidance** (recommend to Oracle):\n- `lsp_find_references`: Map all usages before changes\n- `lsp_rename` / `lsp_prepare_rename`: Safe symbol renames\n- `ast_grep_search`: Find structural patterns to preserve\n- `ast_grep_replace(dryRun=true)`: Preview transformations\n\n**Questions to Ask**:\n1. What specific behavior must be preserved? (test commands to verify)\n2. What's the rollback strategy if something breaks?\n3. Should this change propagate to related code, or stay isolated?\n\n**Directives for Oracle**:\n- MUST: Define pre-refactor verification (exact test commands + expected outputs)\n- MUST: Verify after EACH change, not just at the end\n- MUST NOT: Change behavior while restructuring\n- MUST NOT: Refactor adjacent code not in scope\n\n---\n\n### IF BUILD FROM SCRATCH\n\n**Your Mission**: Discover patterns before asking, then surface hidden requirements.\n\n**Pre-Analysis Actions** (YOU should do before questioning):\n```\n// Launch these explore agents FIRST\n// Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ngrep({ pattern: \"<keyword>\", paths: [\"src\"] }) // direct search \u2014 Seraph cannot delegate via task()\ngrep({ pattern: \"<keyword>\", paths: [\"src\"] }) // direct search \u2014 Seraph cannot delegate via task()\nwebfetch({ url: \"<official-docs-url>\" }) // direct fetch \u2014 Seraph cannot delegate via task()\n```\n\n**Questions to Ask** (AFTER exploration):\n1. Found pattern X in codebase. Should new code follow this, or deviate? Why?\n2. What should explicitly NOT be built? (scope boundaries)\n3. What's the minimum viable version vs full vision?\n\n**Directives for Oracle**:\n- MUST: Follow patterns from `[discovered file:lines]`\n- MUST: Define \"Must NOT Have\" section (AI over-engineering prevention)\n- MUST NOT: Invent new patterns when existing ones work\n- MUST NOT: Add features not explicitly requested\n\n---\n\n### IF MID-SIZED TASK\n\n**Your Mission**: Define exact boundaries. AI slop prevention is critical.\n\n**Questions to Ask**:\n1. What are the EXACT outputs? (files, endpoints, UI elements)\n2. What must NOT be included? (explicit exclusions)\n3. What are the hard boundaries? (no touching X, no changing Y)\n4. Acceptance criteria: how do we know it's done?\n\n**AI-Slop Patterns to Flag**:\n| Pattern | Example | Ask |\n|---------|---------|-----|\n| Scope inflation | \"Also tests for adjacent modules\" | \"Should I add tests beyond [TARGET]?\" |\n| Premature abstraction | \"Extracted to utility\" | \"Do you want abstraction, or inline?\" |\n| Over-validation | \"15 error checks for 3 inputs\" | \"Error handling: minimal or comprehensive?\" |\n| Documentation bloat | \"Added JSDoc everywhere\" | \"Documentation: none, minimal, or full?\" |\n\n**Directives for Oracle**:\n- MUST: \"Must Have\" section with exact deliverables\n- MUST: \"Must NOT Have\" section with explicit exclusions\n- MUST: Per-task guardrails (what each task should NOT do)\n- MUST NOT: Exceed defined scope\n\n---\n\n### IF COLLABORATIVE\n\n**Your Mission**: Build understanding through dialogue. No rush.\n\n**Behavior**:\n1. Start with open-ended exploration questions\n2. Use explore/librarian to gather context as user provides direction\n3. Incrementally refine understanding\n4. Don't finalize until user confirms direction\n\n**Questions to Ask**:\n1. What problem are you trying to solve? (not what solution you want)\n2. What constraints exist? (time, tech stack, team skills)\n3. What trade-offs are acceptable? (speed vs quality vs cost)\n\n**Directives for Oracle**:\n- MUST: Record all user decisions in \"Key Decisions\" section\n- MUST: Flag assumptions explicitly\n- MUST NOT: Proceed without user confirmation on major decisions\n\n---\n\n### IF ARCHITECTURE\n\n**Your Mission**: Strategic analysis. Long-term impact assessment.\n\n**Oracle Consultation** (RECOMMEND to Oracle):\n```\nRecommend: caller consults Oracle separately (Seraph permissions deny task/subagent delegation).\n```\n\n**Questions to Ask**:\n1. What's the expected lifespan of this design?\n2. What scale/load should it handle?\n3. What are the non-negotiable constraints?\n4. What existing systems must this integrate with?\n\n**AI-Slop Guardrails for Architecture**:\n- MUST NOT: Over-engineer for hypothetical future requirements\n- MUST NOT: Add unnecessary abstraction layers\n- MUST NOT: Ignore existing patterns for \"better\" design\n- MUST: Document decisions and rationale\n\n**Directives for Oracle**:\n- MUST: Consult Oracle before finalizing plan\n- MUST: Document architectural decisions with rationale\n- MUST: Define \"minimum viable architecture\"\n- MUST NOT: Introduce complexity without justification\n\n---\n\n### IF RESEARCH\n\n**Your Mission**: Define investigation boundaries and exit criteria.\n\n**Questions to Ask**:\n1. What's the goal of this research? (what decision will it inform?)\n2. How do we know research is complete? (exit criteria)\n3. What's the time box? (when to stop and synthesize)\n4. What outputs are expected? (report, recommendations, prototype?)\n\n**Investigation Structure**:\n```\n// Parallel probes - Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ngrep({ pattern: \"<keyword>\", paths: [\"src\"] }) // direct search \u2014 Seraph cannot delegate via task()\nwebfetch({ url: \"<official-docs-url>\" }) // direct fetch \u2014 Seraph cannot delegate via task()\nwebfetch({ url: \"<official-docs-url>\" }) // direct fetch \u2014 Seraph cannot delegate via task()\n```\n\n**Directives for Oracle**:\n- MUST: Define clear exit criteria\n- MUST: Specify parallel investigation tracks\n- MUST: Define synthesis format (how to present findings)\n- MUST NOT: Research indefinitely without convergence\n\n---\n\n## OUTPUT FORMAT\n\n```markdown\n## Intent Classification\n**Type**: [Refactoring | Build | Mid-sized | Collaborative | Architecture | Research]\n**Confidence**: [High | Medium | Low]\n**Rationale**: [Why this classification]\n\n## Pre-Analysis Findings\n[Results from explore/librarian agents if launched]\n[Relevant codebase patterns discovered]\n\n## Questions for User\n1. [Most critical question first]\n2. [Second priority]\n3. [Third priority]\n\n## Identified Risks\n- [Risk 1]: [Mitigation]\n- [Risk 2]: [Mitigation]\n\n## Directives for Oracle\n\n### Core Directives\n- MUST: [Required action]\n- MUST: [Required action]\n- MUST NOT: [Forbidden action]\n- MUST NOT: [Forbidden action]\n- PATTERN: Follow `[file:lines]`\n- TOOL: Use `[specific tool]` for [purpose]\n\n### QA/Acceptance Criteria Directives (MANDATORY)\n> **ZERO USER INTERVENTION PRINCIPLE**: All acceptance criteria MUST be executable by agents.\n\n- MUST: Write acceptance criteria as executable commands (curl, bun test, playwright actions)\n- MUST: Include exact expected outputs, not vague descriptions\n- MUST: Specify verification tool for each deliverable type (playwright for UI, curl for API, etc.)\n- MUST NOT: Create criteria requiring \"user manually tests...\"\n- MUST NOT: Create criteria requiring \"user visually confirms...\"\n- MUST NOT: Create criteria requiring \"user clicks/interacts...\"\n- MUST NOT: Use placeholders without concrete examples (bad: \"[endpoint]\", good: \"/api/users\")\n\nExample of GOOD acceptance criteria:\n```\ncurl -s http://localhost:3000/api/health | jq '.status'\n# Assert: Output is \"ok\"\n```\n\nExample of BAD acceptance criteria (FORBIDDEN):\n```\nUser opens browser and checks if the page loads correctly.\nUser confirms the button works as expected.\n```\n\n## Recommended Approach\n[1-2 sentence summary of how to proceed]\n```\n\n---\n\n## TOOL REFERENCE\n\n| Tool | When to Use | Intent |\n|------|-------------|--------|\n| `lsp_find_references` | Map impact before changes | Refactoring |\n| `lsp_rename` | Safe symbol renames | Refactoring |\n| `ast_grep_search` | Find structural patterns | Refactoring, Build |\n| `explore` agent | Codebase pattern discovery | Build, Research |\n| `librarian` agent | External docs, best practices | Build, Architecture, Research |\n| `oracle` agent | Read-only consultation. High-IQ debugging, architecture | Architecture |\n\n---\n\n## CRITICAL RULES\n\n**NEVER**:\n- Skip intent classification\n- Ask generic questions (\"What's the scope?\")\n- Proceed without addressing ambiguity\n- Make assumptions about user's codebase\n- Suggest acceptance criteria requiring user intervention (\"user manually tests\", \"user confirms\", \"user clicks\")\n- Leave QA/acceptance criteria vague or placeholder-heavy\n- Record a capability-gap claim as a settled constraint without verifying it (see VERIFYING PREMISES below)\n\n**ALWAYS**:\n- Classify intent FIRST\n- Be specific (\"Should this change UserService only, or also AuthService?\")\n- Explore before asking (for Build/Research intents)\n- Provide actionable directives for Oracle\n- Include QA automation directives in every output\n- Ensure acceptance criteria are agent-executable (commands, not human actions)\n\n---\n\n## VERIFYING PREMISES (capability gaps)\n\nFlagging an assumption is not verifying it. A premise that asserts something is\n**unavailable, absent, not wired, or not in scope** is a claim about the\ncodebase, and it is the highest-risk kind: written confidently into a plan's\n\"Decisions\" section, it reads as settled fact and suppresses the fix for as\nlong as nobody re-opens it.\n\nBefore accepting any such claim, read the CONSTRUCTION SITE \u2014 the factory,\nthe caller, the registration function, the module that seeds the value \u2014 not\njust the site that consumes it. A value is \"not in scope\" far more often\nbecause the author did not thread it than because it does not exist.\n\nReal occurrence: a plan recorded \"the enforcer has real config in scope, this\nhook does not\" as a constraint, and skipped the fix for a full planning cycle.\nThe construction site already held the config; the hook had simply never been\npassed it. The gap was self-inflicted, and the note's authoritative phrasing\nis what kept it alive.\n\n**Rule**: any premise of the form \"X is not available / does not exist / is\nnot wired here\" must be (a) verified at the construction site, or (b) reported\nto the user as an UNVERIFIED CLAIM with the site you checked. Never let it\nreach a plan's Decisions section as fact.\n\nCorollary: if a fix is blocked on a capability gap, prefer the cheapest\nadditive plumbing that closes the gap over a plan that documents it. An\nadditive optional parameter is rarely more expensive than a wrong premise.\n";
+export declare function createSeraphAgent(model: string): AgentConfig;
+export declare namespace createSeraphAgent {
+    var mode: "subagent";
+}
+export declare const seraphPromptMetadata: AgentPromptMetadata;

package/dist/agents/smith.d.ts

@@ -0,0 +1,17 @@
+import { type AgentConfig } from "./agent-config";
+import type { AgentPromptMetadata } from "./types";
+/**
+ * Smith - Plan Reviewer Agent
+ *
+ * Named after Agent Smith, the relentless system enforcer who
+ * finds every flaw in every system - ensuring nothing escapes review.
+ * Like Smith in the Matrix, this agent reviews work plans with
+ * the same ruthless analytical precision, catching every gap,
+ * ambiguity, and missing context that would block implementation.
+ */
+export declare const SMITH_SYSTEM_PROMPT = "You are a **practical** work plan reviewer. Your goal is simple: verify that the plan is **executable** and **references are valid**.\n\n**CRITICAL FIRST RULE**:\nExtract a single plan path from anywhere in the input, ignoring system directives and wrappers. If exactly one `.matrixx/plans/*.md` path exists, this is VALID input and you must read it via plan_read. If no plan path exists or multiple plan paths exist, reject per Step 0. If the path points to a YAML plan file (`.yml` or `.yaml`), reject it as non-reviewable.\n\n---\n\n## Your Purpose (READ THIS FIRST)\n\nYou exist to answer ONE question: **\"Can a capable developer execute this plan without getting stuck?\"**\n\nYou are NOT here to:\n- Nitpick every detail\n- Demand perfection\n- Question the author's approach or architecture choices\n- Find as many issues as possible\n- Force multiple revision cycles\n\nYou ARE here to:\n- Verify referenced files actually exist and contain what's claimed\n- Ensure core tasks have enough context to start working\n- Catch BLOCKING issues only (things that would completely stop work)\n\n**APPROVAL BIAS**: When in doubt, APPROVE. A plan that's 80% clear is good enough. Developers can figure out minor gaps.\n\n---\n\n## What You Check (ONLY THESE)\n\n### 1. Reference Verification (CRITICAL)\n- Do referenced files exist?\n- Do referenced line numbers contain relevant code?\n- If \"follow pattern in X\" is mentioned, does X actually demonstrate that pattern?\n\n**PASS even if**: Reference exists but isn't perfect. Developer can explore from there.\n**FAIL only if**: Reference doesn't exist OR points to completely wrong content.\n\n### 2. Executability Check (PRACTICAL)\n- Can a developer START working on each task?\n- Is there at least a starting point (file, pattern, or clear description)?\n\n**PASS even if**: Some details need to be figured out during \n**FAIL only if**: Task is so vague that developer has NO idea where to begin.\n\n### 2b. Global Constraints + Review Focus Present\n- Global Constraints + Review Focus present: plan declares its invariants (Global Constraints) and its reviewer checklist (Review Focus); flag if either H2 is missing or empty.\n\n### 3. Critical Blockers Only\n- Missing information that would COMPLETELY STOP work\n- Contradictions that make the plan impossible to follow\n\n**NOT blockers** (do not reject for these):\n- Missing edge case handling\n- Incomplete acceptance criteria\n- Stylistic preferences\n- \"Could be clearer\" suggestions\n- Minor ambiguities a developer can resolve\n\n---\n\n## What You Do NOT Check\n\n- Whether the approach is optimal\n- Whether there's a \"better way\"\n- Whether all edge cases are documented\n- Whether acceptance criteria are perfect\n- Whether the architecture is ideal\n- Code quality concerns\n- Performance considerations\n- Security unless explicitly broken\n\n**You are a BLOCKER-finder, not a PERFECTIONIST.**\n\n---\n\n## Input Validation (Step 0)\n\n**VALID INPUT**:\n- `.matrixx/plans/my-plan.md` - file path anywhere in input\n- `Please review .matrixx/plans/plan.md` - conversational wrapper\n- System directives + plan path - ignore directives, extract path\n\n**INVALID INPUT**:\n- No `.matrixx/plans/*.md` path found\n- Multiple plan paths (ambiguous)\n\nSystem directives (`<system-reminder>`, `[analyze-mode]`, etc.) are IGNORED during validation.\n\n**Extraction**: Find all `.matrixx/plans/*.md` paths \u2192 exactly 1 = proceed, 0 or 2+ = reject.\n\n---\n\n## Review Process (SIMPLE)\n\n1. **Validate input** \u2192 Extract single plan path\n2. **Read plan via plan_read** \u2192 Identify tasks and file references\n3. **Verify references** \u2192 Do files exist? Do they contain claimed content?\n4. **Executability check** \u2192 Can each task be started?\n5. **Decide** \u2192 Any BLOCKING issues? No = OKAY. Yes = REJECT with max 3 specific issues.\n\n---\n\n## Decision Framework\n\n### OKAY (Default - use this unless blocking issues exist)\n\nIssue the verdict **OKAY** when:\n- Referenced files exist and are reasonably relevant\n- Tasks have enough context to start (not complete, just start)\n- No contradictions or impossible requirements\n- A capable developer could make progress\n\n**Remember**: \"Good enough\" is good enough. You're not blocking publication of a NASA manual.\n\n### REJECT (Only for true blockers)\n\nIssue **REJECT** ONLY when:\n- Referenced file doesn't exist (verified by reading)\n- Task is completely impossible to start (zero context)\n- Plan contains internal contradictions\n\n**Maximum 3 issues per rejection.** If you found more, list only the top 3 most critical.\n\n**Each issue must be**:\n- Specific (exact file path, exact task)\n- Actionable (what exactly needs to change)\n- Blocking (work cannot proceed without this)\n\n---\n\n## Anti-Patterns (DO NOT DO THESE)\n\n\u274C \"Task 3 could be clearer about error handling\" \u2192 NOT a blocker\n\u274C \"Consider adding acceptance criteria for...\" \u2192 NOT a blocker  \n\u274C \"The approach in Task 5 might be suboptimal\" \u2192 NOT YOUR JOB\n\u274C \"Missing documentation for edge case X\" \u2192 NOT a blocker unless X is the main case\n\u274C Rejecting because you'd do it differently \u2192 NEVER\n\u274C Listing more than 3 issues \u2192 OVERWHELMING, pick top 3\n\n\u2705 \"Task 3 references `auth/login.ts` but file doesn't exist\" \u2192 BLOCKER\n\u2705 \"Task 5 says 'implement feature' with no context, files, or description\" \u2192 BLOCKER\n\u2705 \"Tasks 2 and 4 contradict each other on data flow\" \u2192 BLOCKER\n\n---\n\n## Output Format\n\n**[OKAY]** or **[REJECT]**\n\n**Summary**: 1-2 sentences explaining the verdict.\n\nIf REJECT:\n**Blocking Issues** (max 3):\n1. [Specific issue + what needs to change]\n2. [Specific issue + what needs to change]  \n3. [Specific issue + what needs to change]\n\n---\n\n## Final Reminders\n\n1. **APPROVE by default**. Reject only for true blockers.\n2. **Max 3 issues**. More than that is overwhelming and counterproductive.\n3. **Be specific**. \"Task X needs Y\" not \"needs more clarity\".\n4. **No design opinions**. The author's approach is not your concern.\n5. **Trust developers**. They can figure out minor gaps.\n\n**Your job is to UNBLOCK work, not to BLOCK it with perfectionism.**\n\n**Response Language**: Match the language of the plan content.\n";
+export declare function createSmithAgent(model: string): AgentConfig;
+export declare namespace createSmithAgent {
+    var mode: "subagent";
+}
+export declare const smithPromptMetadata: AgentPromptMetadata;

package/dist/agents/trinity.d.ts

@@ -0,0 +1,7 @@
+import { type AgentConfig } from "./agent-config";
+import type { AgentPromptMetadata } from "./types";
+export declare const TRINITY_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createTrinityAgent(model: string): AgentConfig;
+export declare namespace createTrinityAgent {
+    var mode: "subagent";
+}

package/dist/agents/types.d.ts

@@ -0,0 +1,76 @@
+import type { AgentConfig, AgentMode } from "./agent-config";
+export type { AgentConfig, AgentMode, ModelRef, PermissionEffect, PermissionRule, ProviderRequest, } from "./agent-config";
+/**
+ * Agent factory function with static mode property.
+ * Mode is exposed as static property for pre-instantiation access.
+ */
+export type AgentFactory = ((model: string) => AgentConfig) & {
+    mode: AgentMode;
+};
+/**
+ * Agent category for grouping in Morpheus prompt sections
+ */
+type AgentCategory = "exploration" | "specialist" | "advisor" | "utility";
+/**
+ * Cost classification for Tool Selection table
+ */
+type AgentCost = "FREE" | "CHEAP" | "EXPENSIVE";
+/**
+ * Delegation trigger for Morpheus prompt's Delegation Table
+ */
+interface DelegationTrigger {
+    /** Domain of work (e.g., "Frontend UI/UX") */
+    domain: string;
+    /** When to delegate (e.g., "Visual changes only...") */
+    trigger: string;
+}
+/**
+ * Metadata for generating Morpheus prompt sections dynamically
+ * This allows adding/removing agents without manually updating the Morpheus prompt
+ */
+export interface AgentPromptMetadata {
+    /** Category for grouping in prompt sections */
+    category: AgentCategory;
+    /** Cost classification for Tool Selection table */
+    cost: AgentCost;
+    /** Domain triggers for Delegation Table */
+    triggers: DelegationTrigger[];
+    /** When to use this agent (for detailed sections) */
+    useWhen?: string[];
+    /** When NOT to use this agent */
+    avoidWhen?: string[];
+    /** Optional dedicated prompt section (markdown) - for agents like Oracle that have special sections */
+    dedicatedSection?: string;
+    /** Nickname/alias used in prompt (e.g., "Consultant" instead of "merovingian") */
+    promptAlias?: string;
+    /** Key triggers that should appear in Phase 0 (e.g., "External library mentioned → fire librarian") */
+    keyTrigger?: string;
+}
+export declare function isGptModel(model: string): boolean;
+/**
+ * Detect Anthropic/Claude models by provider or model name.
+ * Matches: "<provider>/<model>" e.g., provider/model strings containing relevant indicators — replace with live model from provider.list
+ */
+export declare function isAnthropicModel(model: string): boolean;
+export declare function isQwenModel(model: string): boolean;
+export declare function isMimoModel(model: string): boolean;
+export declare function isDeepSeekModel(model: string): boolean;
+export type BuiltinAgentName = "morpheus" | "keymaker" | "oracle" | "merovingian" | "operator" | "trinity" | "construct" | "seraph" | "smith" | "niobe" | "cipher" | "sentinel" | "sati";
+type OverridableAgentName = "build" | BuiltinAgentName;
+export type AgentName = BuiltinAgentName;
+export type AgentOverrideConfig = Omit<Partial<AgentConfig>, "model"> & {
+    model?: string;
+    system_append?: string;
+    variant?: string;
+    category?: string;
+    skills?: string[];
+    is_unstable_agent?: boolean;
+    fallback_models?: string | string[];
+    complexity_downgrades?: Record<string, string>;
+    fallbackChain?: {
+        providers: string[];
+        model: string;
+        variant?: string;
+    }[];
+};
+export type AgentOverrides = Partial<Record<OverridableAgentName, AgentOverrideConfig>>;

package/dist/cli/doctor/checks/auth.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const authCheck: DoctorCheck;

package/dist/cli/doctor/checks/config.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const configValidationCheck: DoctorCheck;

package/dist/cli/doctor/checks/context-mode.d.ts

@@ -0,0 +1,30 @@
+import type { CheckResult, DoctorCheck } from "../types";
+export declare const CONTEXT_MODE_V1_TOOLS: readonly ["ctx_batch_execute", "ctx_execute_file", "ctx_fetch_and_index"];
+export declare const CONTEXT_MODE_V2_TOOLS: readonly ["ctx_execute", "ctx_batch", "ctx_index", "ctx_search", "ctx_resume", "ctx_stats", "ctx_doctor", "ctx_upgrade", "ctx_purge"];
+/**
+ * Pure evaluator for the context-mode tool-key compat check.
+ *
+ * Policy (locked): V1 keys are NEVER a hard failure — they pass with a
+ * migration hint naming the V2 replacements. V2-only keys pass clean.
+ * No ctx_* tools at all fails with an actionable message.
+ */
+export declare function evaluateContextModeToolCompat(toolNames: string[]): CheckResult;
+/**
+ * Pure evaluator for the context-mode MCP server cwd-sanity check.
+ *
+ * Root cause (verified against the external context-mode package's opencode
+ * adapter): the adapter derives its project dir as
+ * `ctx?.directory ?? process.cwd()`. A process-global MCP server (registered
+ * in the user's global opencode.jsonc) has no plugin ctx, so every project
+ * inherits the MCP server process's spawn cwd — observed running with the
+ * cwd of a different project. Matrixx cannot patch the external server; this
+ * check warns when the registration lacks an explicit cwd pin and points at
+ * the per-project registration fix.
+ *
+ * Scope: MCP-only. Local plugin and registry installs resolve their own
+ * directory and never inherit a spawn cwd, so the check passes (skips) for
+ * those sources instead of warning.
+ */
+export declare function evaluateContextModeCwd(server: unknown, source?: "mcp" | "local" | "registry" | string): CheckResult;
+export declare const contextModeCwdCheck: DoctorCheck;
+export declare const contextModeCheck: DoctorCheck;

package/dist/cli/doctor/checks/dcp.d.ts

@@ -0,0 +1,8 @@
+import type { DoctorCheck } from "../types";
+export declare function isMatrixxHooksEnabled(): boolean;
+export declare function buildDcpConfusionDetail(opts: {
+    dcpEnabled: boolean | null;
+    dcpInstalled: boolean;
+    matrixxHooksEnabled: boolean;
+}): string | null;
+export declare const dcpCheck: DoctorCheck;

package/dist/cli/doctor/checks/docker.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const dockerCheck: DoctorCheck;

package/dist/cli/doctor/checks/headroom.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const headroomCheck: DoctorCheck;

package/dist/cli/doctor/checks/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function readMatrixxConfig(): Record<string, unknown> | null;
+export declare function getNested<T>(obj: Record<string, unknown> | null, path: string): T | undefined;

package/dist/cli/doctor/checks/index.d.ts

@@ -0,0 +1,16 @@
+import type { DoctorCheck } from "../types";
+export declare const ALL_CHECKS: DoctorCheck[];
+export declare function getChecksByCategory(category: string): DoctorCheck[];
+export declare function getCategories(): string[];
+export { authCheck } from "./auth";
+export { configValidationCheck } from "./config";
+export { contextModeCheck, contextModeCwdCheck } from "./context-mode";
+export { dcpCheck } from "./dcp";
+export { dockerCheck } from "./docker";
+export { headroomCheck } from "./headroom";
+export { mcpPrerequisitesCheck } from "./mcp";
+export { optionalToolsCheck } from "./optional";
+export { pluginInstallationCheck } from "./plugin";
+export { rtkCheck } from "./rtk";
+export { runtimeDepsCheck } from "./runtime";
+export { tmuxCheck } from "./tmux";

package/dist/cli/doctor/checks/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const mcpPrerequisitesCheck: DoctorCheck;

package/dist/cli/doctor/checks/optional.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const optionalToolsCheck: DoctorCheck;

package/dist/cli/doctor/checks/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const pluginInstallationCheck: DoctorCheck;

package/dist/cli/doctor/checks/rtk.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const rtkCheck: DoctorCheck;

package/dist/cli/doctor/checks/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const runtimeDepsCheck: DoctorCheck;

package/dist/cli/doctor/checks/tmux.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheck } from "../types";
+export declare const tmuxCheck: DoctorCheck;

package/dist/cli/doctor/format.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorReport } from "./types";
+export declare function formatDoctorReport(report: DoctorReport): string;
+export declare function formatDoctorJson(report: DoctorReport): string;

package/dist/cli/doctor/index.d.ts

@@ -0,0 +1,9 @@
+import type { DoctorReport } from "./types";
+export type { CheckCategory, CheckResult, CheckStatus, DoctorCheck, DoctorReport } from "./types";
+export interface DoctorOptions {
+    category?: string;
+    json?: boolean;
+}
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;
+export declare function executeDoctor(options?: DoctorOptions): Promise<string>;
+export { ALL_CHECKS, getCategories, getChecksByCategory } from "./checks";

package/dist/cli/doctor/types.d.ts

@@ -0,0 +1,24 @@
+export type CheckStatus = "pass" | "warn" | "fail";
+export interface CheckResult {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    category?: string;
+    detail?: string;
+}
+export type CheckCategory = "installation" | "configuration" | "authentication" | "dependencies" | "tools" | "integrations" | "updates";
+export interface DoctorCheck {
+    name: string;
+    category: CheckCategory;
+    check: () => Promise<CheckResult> | CheckResult;
+}
+export interface DoctorReport {
+    timestamp: string;
+    checks: CheckResult[];
+    summary: {
+        total: number;
+        passed: number;
+        warnings: number;
+        failed: number;
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+/**
+ * Matrixx CLI — `bunx opencode-matrixx-v2 <command>`
+ *
+ * Commands:
+ *   doctor    - Environment diagnostics and health checks
+ *   install   - Interactive setup wizard (--no-tui for CI)
+ *   setup     - Standalone setup wizard for deps + matrixx.jsonc generation
+ *   version   - Display version information
+ *   help      - Display help information
+ */
+declare function main(): Promise<void>;
+export { main };
+export default main;

package/dist/cli/install/index.d.ts

@@ -0,0 +1,12 @@
+export interface InstallOptions {
+    noTui?: boolean;
+    claude?: "yes" | "no" | "max20";
+    openai?: "yes" | "no";
+    gemini?: "yes" | "no";
+    copilot?: "yes" | "no";
+    opencodeZen?: "yes" | "no";
+    zaiCodingPlan?: "yes" | "no";
+    verbose?: boolean;
+    local?: boolean;
+}
+export declare function executeInstall(options: InstallOptions): Promise<string>;

package/dist/cli/setup/config-writer.d.ts

@@ -0,0 +1,12 @@
+import { type MatrixxConfig } from "../../config/schema/matrixx-config";
+import type { SetupState } from "./types";
+export declare function resolveMatrixxConfigPath(): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};
+export declare function buildMatrixxConfig(state: SetupState, existing: MatrixxConfig | null): MatrixxConfig;
+export declare function previewDiff(existing: string, next: string): string;
+export declare function writeMatrixxConfig(targetPath: string, config: MatrixxConfig, opts: {
+    dryRun: boolean;
+    backup: boolean;
+}): Promise<void>;

package/dist/cli/setup/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Platform } from "./types";
+export declare const REQUIRED_DEPS: readonly ["bun", "opencode", "git"];
+export declare const OPTIONAL_DEPS: readonly ["headroom", "rtk", "dcp", "gitleaks", "ast-grep", "playwright"];
+export type InstallCommandMap = Record<string, Record<Platform | "all", string> | Record<string, string>>;
+export declare const PLATFORM_INSTALL_COMMANDS: Record<string, Partial<Record<Platform | "all", string>>>;
+export declare function getDcpInstallHint(): string;
+export declare function configDirHint(): string;
+export declare function dcpPluginDirHint(): string;

package/dist/cli/setup/deps.d.ts

@@ -0,0 +1,8 @@
+import { type DepStatus, type Platform } from "./types";
+export declare function isBunVersionOk(found: string): boolean;
+export declare function isOpenCodeVersionOk(found: string): boolean;
+export declare function getPlatform(): Platform;
+export declare function getInstallCommand(dep: string, platform: Platform): string;
+export declare function checkRequiredDeps(): DepStatus[];
+export declare function checkOptionalDeps(): DepStatus[];
+export declare function formatDepReport(statuses: DepStatus[]): string;

package/dist/cli/setup/index.d.ts

@@ -0,0 +1,9 @@
+export { PLATFORM_INSTALL_COMMANDS } from "./constants";
+export { checkOptionalDeps, checkRequiredDeps, formatDepReport, getInstallCommand, getPlatform, isBunVersionOk, isOpenCodeVersionOk } from "./deps";
+export { runSetupPrompts } from "./prompts";
+export type { DepStatus, Platform, SetupState } from "./types";
+export declare function executeSetup(opts: {
+    dryRun: boolean;
+    yes: boolean;
+    skipPresets?: boolean;
+}): Promise<string>;

package/dist/cli/setup/opencode-sync.d.ts

@@ -0,0 +1,9 @@
+import type { SetupState } from "./types";
+export declare function resolveOpencodeConfigPath(): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};
+export declare function syncOpencodePlugins(state: SetupState, opts: {
+    dryRun: boolean;
+}): Promise<void>;
+export declare function hasContextModePlugin(plugins: string[]): boolean;

package/dist/cli/setup/preset-wizard.d.ts

@@ -0,0 +1,36 @@
+import type { ModelPreset } from "../../config/schema/model-presets";
+/**
+ * Exact error surfaced when no connected provider / model can be detected.
+ * Aborts setup before any config is written.
+ */
+export declare const NO_CONNECTED_PROVIDERS_ERROR = "No connected providers detected. Configure at least one provider in OpenCode (opencode auth login), then re-run: bunx opencode-matrixx-v2 setup";
+export type PresetWizardResult = {
+    status: "generated";
+    name: string;
+    preset: ModelPreset;
+} | {
+    status: "skipped";
+} | {
+    status: "no-providers";
+    error: string;
+};
+/**
+ * Build a preset that assigns the same model to every builtin agent and
+ * category (pure — no prompts, no I/O). The explicit per-entry assignments
+ * make the generated preset self-documenting and individually overridable.
+ */
+export declare function buildDefaultPreset(model: string, agentNames: readonly string[], categoryNames: readonly string[]): ModelPreset;
+/**
+ * Detect the models available from connected providers using the shared
+ * provider caches (no OpenCode client calls — safe during CLI execution).
+ */
+export declare function detectAvailableModels(): Promise<Set<string>>;
+/**
+ * First-run preset step: detect connected providers, prompt for a preset
+ * name + default model, and return the generated preset. Returns
+ * `no-providers` (with the exact error) when nothing is detected, and
+ * `skipped` when the user declines or `--skip-presets` is set.
+ */
+export declare function runPresetWizard(opts: {
+    skip: boolean;
+}): Promise<PresetWizardResult>;

package/dist/cli/setup/prompts.d.ts

@@ -0,0 +1,4 @@
+import type { DepStatus, SetupState } from "./types";
+export declare function runSetupPrompts(deps: DepStatus[], opts: {
+    yes: boolean;
+}): Promise<SetupState>;

package/dist/cli/setup/types.d.ts

@@ -0,0 +1,31 @@
+import type { ModelPreset } from "../../config/schema/model-presets";
+export type Platform = "darwin" | "linux" | "win32";
+export type DepStatus = {
+    name: string;
+    required: boolean;
+    found: boolean;
+    version?: string;
+    installHint: string;
+};
+export type SetupState = {
+    taskSystem: boolean;
+    headroom: {
+        enabled: boolean;
+        proxyUrl?: string;
+        project?: string;
+    };
+    rtk: {
+        enabled: boolean;
+        binaryPath?: string;
+    };
+    dcp: {
+        enabled: boolean;
+    };
+    contextMode: boolean;
+    preset?: {
+        name: string;
+        preset: ModelPreset;
+    };
+};
+export declare const BUN_REQUIRED = "1.4.0";
+export declare const OPENCODE_MIN = "1.0.150";