opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/LICENSE.md

@@ -0,0 +1,82 @@
+# License
+
+Portions of this software are licensed as follows:
+
+- All third party components incorporated into the Matrixx Software are licensed under the original license
+  provided by the owner of the applicable component.
+- Content outside of the above mentioned files or restrictions is available under the "Sustainable Use
+  License" as defined below.
+
+## Sustainable Use License
+
+Version 1.0
+
+### Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+### Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license
+to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject
+to the limitations below.
+
+### Limitations
+
+You may use or modify the software only for your own internal business purposes or for non-commercial or
+personal use. You may distribute the software or provide it to others only if you do so free of charge for
+non-commercial purposes. You may not alter, remove, or obscure any licensing, copyright, or other notices of
+the licensor in the software. Any use of the licensor's trademarks is subject to applicable law.
+
+### Patents
+
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to
+license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case
+subject to the limitations and conditions in this license. This license does not cover any patent claims that
+you cause to be infringed by modifications or additions to the software. If you or your company make any
+written claim that the software infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company makes such a claim, your patent
+license ends immediately for work on behalf of your company.
+
+### Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these
+terms. If you modify the software, you must include in any modified copies of the software a prominent notice
+stating that you have modified the software.
+
+### No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+### Termination
+
+If you use the software in violation of these terms, such use is not licensed, and your license will
+automatically terminate. If the licensor provides you with a notice of your violation, and you cease all
+violation of this license no later than 30 days after you receive that notice, your license will be reinstated
+retroactively. However, if you violate these terms after such reinstatement, any additional violation of these
+terms will cause your license to terminate automatically and permanently.
+
+### No Liability
+
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will
+not be liable to you for any damages arising out of these terms or the use or nature of the software, under
+any kind of legal claim.
+
+### Definitions
+
+The "licensor" is the entity offering these terms.
+
+The "software" is the software the licensor makes available under these terms, including any portion of it.
+
+"You" refers to the individual or entity agreeing to these terms.
+
+"Your company" is any legal entity, sole proprietorship, or other kind of organization that you work for, plus
+all organizations that have control over, are under the control of, or are under common control with that
+organization. Control means ownership of substantially all the assets of an entity, or the power to direct its
+management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+"Your license" is the license granted to you for the software under these terms.
+
+"Use" means anything you do with the software requiring your license.
+
+"Trademark" means trademarks, service marks, and similar rights.

package/README.md

@@ -1,3 +1,206 @@
-# Temporary Holding Version
+[![Matrixx](./.github/assets/orchestrator-niobe.png?v=3)](https://github.com/klpanagi/opencode-matrixx)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<div align="center">
+
+# Matrixx
+
+[![npm](https://img.shields.io/npm/v/opencode-matrixx.svg)](https://www.npmjs.com/package/opencode-matrixx)
+[![License: SUL-1.0](https://img.shields.io/badge/license-SUL--1.0-blue.svg)](https://github.com/klpanagi/opencode-matrixx/blob/master/LICENSE)
+[![OpenCode](https://img.shields.io/badge/built_for-OpenCode-black.svg)](https://opencode.ai/docs)
+
+**Multi-model agent orchestration for [OpenCode](https://github.com/sst/opencode).**<br/>
+**17 specialized agents. 65 lifecycle hooks. 30 tools. 50 skills. One plugin.**
+
+> **OpenCode v2-only.** Matrixx v2 requires OpenCode v2 (OpenCode-v2-only line). Version restart: `2.6.18` was the last legacy v1 release; v2 restarts at `3.0.0` (`2.6.18` was the last legacy v1 release).
+
+[Quick Start](#quick-start) · [Why Matrixx?](#why-matrixx) · [How It Works](#how-it-works) · [Features](#features) · [Comparison](#how-matrixx-compares) · [Docs](docs/README.md)
+
+</div>
+
+---
+
+## Why Matrixx?
+
+One model doing everything is a compromise. Planning, implementation, security review, and frontend polish require different strengths — different models, different prompts, different tools.
+
+Matrixx turns OpenCode into a **team of specialists** coordinated by an orchestrator. The right model for the right job, in parallel, with persistent task state.
+
+```
+You: "Add OAuth2 with PKCE to the API"
+     ↓
+Morpheus                    → Plans the implementation
+  ├─ Keymaker               → Builds auth middleware + routes
+  ├─ Oracle                 → Reviews architecture in parallel
+  └─ Sentinel               → Audits for security vulnerabilities
+     ↓
+     Done. Tested. Secure.
+```
+
+| Problem with single-agent coding | What Matrixx does |
+|----------------------------------|-------------------|
+| One model does everything averagely | **14 specialists** — orchestration, planning, implementation, security, frontend, DSL, research, search |
+| Agent forgets what it was doing after `/clear` | **Persistent tasks** — file-backed `.matrixx/tasks`, survives compaction and restarts |
+| Slow sequential tool calls | **Parallel background agents** — 5+ running simultaneously, optional tmux visibility |
+| AI code looks like AI code | **Quality gates** — comment checking, TDD/BDD pipeline, 5-agent review |
+| Context window fills up fast | **5-layer context stack** — native recovery + RTK + context-mode + DCP + Headroom |
+| Fragile refactoring | **Deterministic tools** — LSP (goto-def, rename, diagnostics) + AST-Grep (structural search & replace) |
+| Secrets leak into commits | **Security by default** — secret scanning + env-file guards + read-only auditor |
+
+> Don't want to read docs? Just include `ultrawork` (or `ulw`) in your prompt. Parallel agents, deep exploration, relentless execution until completion.
+
+---
+
+## How It Works
+
+Matrixx is a plugin for OpenCode. Install it, and OpenCode gains a 3-tier runtime:
+
+1. **Orchestrator (Morpheus)** — sees your request, builds a task list, and delegates. Fires background agents in parallel instead of doing everything inline.
+2. **Specialists** — plan (Oracle), implement (Keymaker/Mouse), audit (Sentinel), design UI (Sati), research docs and OSS (Operator), search code (Trinity), design languages (Cipher), validate plans (Smith, Seraph, Merovingian).
+3. **Substrate** — file-backed tasks, lifecycle hooks, skills, and context compression keep work moving across sessions.
+
+### Two ways to work
+
+**Ultrawork — for speed.** Add `ultrawork` to any prompt:
+
+```
+ulw add authentication to my Next.js app
+```
+
+The agent explores your codebase, researches best practices, implements following your conventions, and verifies with diagnostics and tests. No planning ceremony.
+
+**Oracle → Niobe — for precision.** Press `Tab` for Oracle (planner), answer a short interview, get a work plan in `.matrixx/plans/*.md`, then run `/start-work`. The Niobe executes phase by phase with independent verification. Best for multi-day work, production changes, and large refactors.
+
+Full workflows: [Overview](docs/guide/overview.md) · [Orchestration](docs/orchestration.md) · [Task System](docs/task-system.md)
+
+---
+
+## Features
+
+| Area | What you get | Details |
+|------|--------------|---------|
+| **Agent Orchestration** | 17 agents, category routing (`source`, `deep-jack`, …), session continuity, parallel background execution | [Agents](docs/agents.md) |
+| **Developer Tools** | LSP, AST-Grep search & replace, tmux terminal, task tools, assembly (multi-model debate) | [Features](docs/features.md) |
+| **Lifecycle Hooks (65-enum)** | Context injection, think mode, task/todo continuation, error recovery, quality gates, session recovery | [Hooks](docs/hooks.md) |
+| **Skills (50)** | DSL engineering (11), security (9), frontend (7), BDD (4 + pipeline), git, browser, TDD, research, AI-slop removal | [Skills](docs/category-skill-guide.md) |
+| **Software Dev Pipeline** | 6-phase PLAN → BUILD → VERIFY → REVIEW → SECURE → SHIP with 5 team roles, adaptive to task size | [Quality](docs/quality.md) |
+| **Context Management (L0–L4)** | Native recovery + RTK (60–90% bash savings) + context-mode sandbox + DCP pruning + Headroom proxy (60–95% JSON) | [Context](docs/context-management.md) |
+| **Security** | Secret-leak guard (gitleaks), env-file write guard, read-only Sentinel auditor with CWE-rated findings | [Hooks](docs/hooks.md) · [Agents](docs/agents.md) |
+| **Knowledge & Research** | Saturation `/research` swarms, Context7 docs, Exa web search, `github_search`, document reader, external knowledge hubs | [Features](docs/features.md) |
+| **Configurability** | Every agent, model, temperature, and hook tunable via `matrixx.jsonc` with JSON schema + Config Studio UI | [Configuration](docs/configurations.md) |
+
+Counts are schema-official: 17 agents (`BuiltinAgentNameSchema`), 50 skills (skills schema), 65-enum hooks (`src/config/schema/hooks.ts`, 72 accepted incl. 7 literals), 23 commands (23 names / 21 templates), 2 MCPs (`context7`, `document_reader`), 30 tool dirs, 23 features. The roster lives in docs — this page links, never duplicates: [Agents](docs/agents.md) · [Hooks](docs/hooks.md) · [Skills](docs/category-skill-guide.md) · [Commands](docs/command-reference.md).
+
+### Session memory (new, EXPERIMENTAL)
+
+Matrixx now ships an **opt-in session memory** (native port of [opencode-lcm](https://github.com/Plutarch01/opencode-lcm) interop semantics, pinned `84103cca`). It archives conversation turns as JSONL under `.matrixx/memory/`, recalls them with scope-aware budgets, and collaborates with compaction — no SQLite, no new handler, off by default.
+
+```jsonc
+// matrixx.jsonc — pick one backend (default off)
+{ "memory": { "backend": "off" } }
+{ "memory": { "backend": "native", "native": { "enabled": true } } }
+{ "memory": { "backend": "lcm" } } // + opencode-lcm plugin (18 lcm_* tools, pin 84103cca)
+{ "memory": { "backend": "supermemory" } } // + supermemory.jsonc + SUPERMEMORY_API_KEY
+```
+
+```jsonc
+// opencode.jsonc — context-mode transport (verified working form, shows as Connected under MCP)
+{
+  "mcp": {
+    "servers": { "context-mode": { "type": "local", "command": ["context-mode"] } }
+  }
+}
+```
+
+- **Native (`memory.backend: native` + `memory.native.*`)**: JSONL-first store, deterministic recall (110 chars/msg, 900-char cap, 2/1/1 hit quotas), retention triple with tombstones (`[removed]`/`[pruned:id]`, pinned skipped). Details: [Context Management](docs/context-management.md) · FTS deferral note: [session-memory-fts.md](docs/session-memory-fts.md) · options: [Configuration](docs/configurations.md).
+- **External `opencode-lcm`**: use instead if you want the upstream SQLite/FTS5 build with its 18 `lcm_*` tools. Pair with context-mode via `ignoreToolPrefixes: ["ctx_"]`; keep scopes at `session` default. Native memory and upstream lcm solve the same gap — pick one.
+- **External `magic-context` (CortexKit)**: use for cross-session/cross-tool semantic memory (2.4k stars, local embeddings, zero per-turn LLM cost; historian/dreamer crons carry the spend). Runs alongside native memory with `compaction:false`-equivalent scoping; note it owns `ctx_search`/`ctx_reduce` naming that overlaps context-mode — resolve the collision before enabling both.
+
+---
+
+## Quick Start
+
+**Prerequisites:** Bun 1.4.0 · OpenCode ≥ 1.0.150
+
+```bash
+bunx opencode-matrixx-v2 install
+bunx opencode-matrixx-v2 doctor   # no "fail" = good
+opencode auth login             # connect at least one provider
+```
+
+Then open OpenCode and code. Matrixx activates automatically.
+
+```jsonc
+// matrixx.jsonc (project root) — minimal, everything else has sane defaults
+{
+  "$schema": "https://raw.githubusercontent.com/klpanagi/opencode-matrixx/refs/heads/dev/dist/matrixx.schema.json",
+  "agents": {}
+}
+```
+
+Full setup, CI mode, troubleshooting, and uninstall: [Installation guide](docs/guide/installation.md) · [CLI reference](docs/cli-guide.md)
+
+---
+
+## Honest Pros & Cons
+
+**Where Matrixx shines**
+
+- Right model for the right job — provider-resolved fallback chains work with free-tier OpenCode models out of the box, and mix freely with paid providers.
+- True parallelism — background agents explore, review, and audit while implementation proceeds.
+- Work survives interruptions — tasks persist across `/clear`, compaction, and restarts.
+- Engineering-grade edits — LSP + AST-Grep instead of regex guesswork.
+- Security and quality are built in, not bolted on — guards block secret leaks; Sentinel never writes code, only reports.
+- Context economics — five complementary layers instead of one trick; retrieval-on-demand instead of re-reading history.
+- Fully observable and tunable — every agent, model, and hook is config.
+
+**Trade-offs to know**
+
+- **OpenCode-only.** Matrixx is a plugin, not a standalone agent or IDE. You adopt OpenCode to use it.
+- **Learning curve.** 17 agents, 8 categories, 50 skills, 23 commands — `ultrawork` hides this well, but mastery takes time.
+- **Multiple providers help.** It runs on one provider, but the multi-model value shows with two or more connected (or the OpenCode free tier).
+- **Orchestration overhead.** Delegation costs extra tokens on trivial one-line tasks — use direct mode for those.
+- **Pinned toolchain.** Bun 1.4.0 and recent OpenCode are required; bleeding-edge OpenCode versions can break the plugin temporarily.
+- **Fast-moving project.** Conventions and config keys evolve; pin versions in CI.
+
+---
+
+## How Matrixx Compares
+
+| Tool | Approach | Where Matrixx differs |
+|------|----------|-----------------------|
+| **Vanilla OpenCode** | Single powerful agent + tools | Matrixx adds the team layer: specialists, persistent tasks, 65-enum hooks, skills, and context compression. Same base, orchestrated. |
+| **Claude Code** | Polished single-vendor agent (Anthropic models) | Matrixx is provider-agnostic and multi-model by design — mix Claude, OpenAI, Gemini, local models per role instead of one vendor. More setup, more control. |
+| **Cursor / Windsurf** | IDE-integrated agent with proprietary models | Matrixx lives in the terminal (OpenCode TUI), is fully open and configurable, and exposes its orchestration as code. No IDE lock-in, no black-box model routing. |
+| **Cline / Roo Code** | IDE-based autonomous agents, mode switching | Similar autonomy ethos; Matrixx goes further on parallelism (background swarms), persistent cross-session tasks, and deterministic refactoring tools (LSP/AST-Grep). |
+| **Aider / Continue** | Lightweight editor pair-programmers | Aider/Continue are fast and minimal for small edits. Matrixx targets larger multi-file work: planning, review, security audit, and BDD/TDD pipelines. |
+| **Other OpenCode plugins** | Single-concern extensions | Matrixx is a full harness — agents + hooks + tools + skills + tasks + context — rather than one feature. Heavier, but replaces several plugins at once. |
+
+**Rule of thumb:** for a quick single-file edit, any agent works — Matrixx adds little. For multi-file features, refactors, migrations, and production changes where planning, review, and security matter, orchestration pays off.
+
+---
+
+## Documentation
+
+| Start with | Then read |
+|------------|-----------|
+| [Overview](docs/guide/overview.md) — what Matrixx does, two ways to work | [Installation](docs/guide/installation.md) — setup, auth, troubleshooting |
+| [Features](docs/features.md) — capability index | [Agents](docs/agents.md) — full roster and when to use each |
+| [Orchestration](docs/orchestration.md) — how work runs | [Configuration](docs/configurations.md) — every `matrixx.jsonc` option |
+| [Context Management](docs/context-management.md) — 5-layer stack | [Quality](docs/quality.md) — BDD pipeline + TDD discipline |
+
+Full index: [docs/README.md](docs/README.md)
+
+
+## Acknowledgment
+
+Matrixx is developed at and supported by the [Information Systems & Software Engineering Laboratory (ISSEL)](https://issel.ee.auth.gr/), Department of Electrical and Computer Engineering, Aristotle University of Thessaloniki.
+
+Research, development, and infrastructure behind Matrixx are powered, and practically funded, by ISSEL. Thank you to the lab, its members, and its students for making this work possible.
+
+---
+
+If this saves you time, a ⭐ goes a long way.
+
+<sub>Productivity might spike too hard. Don't let your coworker notice. Actually, let's see who wins.</sub>
+
+---

package/dist/agents/agent-builder.d.ts

@@ -0,0 +1,28 @@
+import type { BrowserAutomationProvider, CategoriesConfig } from "../config/schema";
+import { type AgentConfig } from "./agent-config";
+import type { AgentFactory } from "./types";
+export type AgentSource = AgentFactory | AgentConfig;
+/**
+ * Static skill list for the orchestrator session agents
+ * (morpheus/keymaker/niobe/oracle). Consumed by the orchestrator
+ * construction sites via prependStaticSkillTemplates() — the same
+ * agent-builder skills mechanic, factored for call sites that bypass
+ * buildAgent (dynamic-prompt factories + oracle builder).
+ * NEVER add entries consumed by Mouse (BLOCKED subagent — the full
+ * template is orchestrator-only per spec section 5.1).
+ */
+export declare const ORCHESTRATOR_STATIC_SKILLS: readonly ["software-dev"];
+export interface StaticSkillInjectionOptions {
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}
+/**
+ * Prepend resolved skill templates to a built agent config's system prompt.
+ * Same mechanic as the buildAgent skills branch: names resolve through
+ * createBuiltinSkills (disabledSkills filtered AFTER construction in
+ * skills.ts), unknown/disabled names resolve to nothing, and an empty
+ * resolution leaves the config untouched.
+ */
+export declare function prependStaticSkillTemplates(config: AgentConfig, skillNames: readonly string[], options?: StaticSkillInjectionOptions): AgentConfig;
+export declare function isFactory(source: AgentSource): source is AgentFactory;
+export declare function buildAgent(source: AgentSource, model: string, categories?: CategoriesConfig, browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>): AgentConfig;

package/dist/agents/agent-config.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The agent definition matrixx builds and registers with OpenCode.
+ *
+ * OpenCode 2.x describes an agent as `Agent.Info` (packages/schema/src/agent.ts):
+ * the system prompt is `system`, permissions are a ruleset of
+ * `{action, resource, effect}`, sampling and provider parameters live under
+ * `request`, and the model is a reference rather than a "provider/model" string.
+ * Building that shape here keeps the translation out of the registration path.
+ */
+import type { PermissionRule } from "../shared/permission-compat";
+export type { PermissionEffect, PermissionRule } from "../shared/permission-compat";
+export { rule } from "../shared/permission-compat";
+/**
+ * Agent mode determines UI model selection behavior:
+ * - "primary": Respects user's UI-selected model (morpheus, niobe)
+ * - "subagent": Uses own fallback chain, ignores UI selection (merovingian, trinity, etc.)
+ * - "all": Available in both contexts (OpenCode compatibility)
+ */
+export type AgentMode = "primary" | "subagent" | "all";
+export interface ModelRef {
+    providerID: string;
+    id: string;
+    variant?: string;
+}
+export interface ProviderRequest {
+    settings?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+export interface AgentConfig {
+    model?: ModelRef;
+    request?: ProviderRequest;
+    system?: string;
+    description?: string;
+    mode?: AgentMode;
+    hidden?: boolean;
+    color?: string;
+    steps?: number;
+    disabled?: boolean;
+    permissions?: PermissionRule[];
+}
+/**
+ * `"provider/model#variant"` is the only form OpenCode treats as a variant
+ * selector; a "#" anywhere else belongs to the model id and is left alone.
+ */
+export declare function parseModelRef(selection: string | undefined): ModelRef | undefined;

package/dist/agents/agents.transform.d.ts

@@ -0,0 +1,67 @@
+/**
+ * V2-native agent domain transform (D4).
+ *
+ * Owned by `src/agents/`: pure entry replay + single `ctx.agent.transform`
+ * registration. `createBuiltinAgents` in `./builtin-agents` stays the (async,
+ * IO-at-the-edge) composer that resolves models and overrides; this module
+ * only folds already-built entries onto the domain, so repeated runs over the
+ * same entries replay identically with no filesystem or network effects.
+ */
+/** Minimal structural agent: the real V2 `AgentInfo` satisfies this. */
+export interface AgentTransformInfo {
+    model?: {
+        providerID: string;
+        id: string;
+        variant?: string;
+    };
+    request: {
+        settings?: Record<string, unknown>;
+        headers?: Record<string, string>;
+        body?: Record<string, unknown>;
+    };
+    system?: string;
+    description?: string;
+    mode: "primary" | "subagent" | "all";
+    hidden: boolean;
+    color?: string;
+    steps?: number;
+    permissions: unknown[];
+    [key: string]: unknown;
+}
+/** Minimal structural editor: the real V2 `AgentEditor` satisfies this. */
+export interface AgentTransformEditor {
+    update(id: string, update: (agent: AgentTransformInfo) => void): void;
+    remove(id: string): void;
+    default(id: string | undefined): void;
+}
+export interface AgentTransformDomain {
+    transform(callback: (editor: AgentTransformEditor) => void): Promise<unknown>;
+}
+export interface AgentTransformEntryFailure {
+    name: string;
+    error: string;
+}
+export interface RegisterAgentTransformInput {
+    agents?: Record<string, unknown>;
+    defaultAgent?: string;
+}
+export interface RegisterAgentTransformResult {
+    registration: unknown;
+    registered: string[];
+    failures: AgentTransformEntryFailure[];
+}
+/**
+ * Pure fold of one entry onto an agent record. MERGE, not replace, for
+ * permissions: evaluation is last-match-wins over `[...Info.default, ...ours]`,
+ * so our rules win where they overlap while the seeded ruleset keeps the
+ * default secret-read guard.
+ */
+export declare function applyAgentEntry(agent: AgentTransformInfo, entry: unknown): void;
+/**
+ * Pure replay: agent entries → `ctx.agent.transform`.
+ * The only effect is the single `transform` call; the callback only calls
+ * `editor.update` / `editor.remove` / `editor.default`, so re-running over
+ * the same input replays identically. `update` seeds a missing agent from its
+ * default, which makes it the registration path as well — the editor has no `add`.
+ */
+export declare function registerAgentTransform(agent: AgentTransformDomain, input: RegisterAgentTransformInput): Promise<RegisterAgentTransformResult>;

package/dist/agents/builtin-agents/agent-overrides.d.ts

@@ -0,0 +1,12 @@
+import type { CategoryConfig } from "../../config/schema";
+import { type AgentConfig } from "../agent-config";
+import type { AgentOverrideConfig } from "../types";
+/**
+ * Expands a category reference from an agent override into concrete config properties.
+ * Category properties are applied unconditionally (overwriting factory defaults),
+ * because the user's chosen category should take priority over factory base values.
+ * Direct override properties applied later via mergeAgentConfig() will supersede these.
+ */
+export declare function applyCategoryOverride(config: AgentConfig, categoryName: string, mergedCategories: Record<string, CategoryConfig>): AgentConfig;
+export declare function mergeAgentConfig(base: AgentConfig, override: AgentOverrideConfig, directory?: string): AgentConfig;
+export declare function applyOverrides(config: AgentConfig, override: AgentOverrideConfig | undefined, mergedCategories: Record<string, CategoryConfig>, directory?: string): AgentConfig;

package/dist/agents/builtin-agents/available-skills.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserAutomationProvider } from "../../config/schema";
+import { type BuiltinSkill } from "../../skills";
+import type { AvailableSkill } from "../dynamic-agent-prompt-builder";
+export declare function buildAvailableSkills(discoveredSkills: BuiltinSkill[], browserProvider?: BrowserAutomationProvider, disabledSkills?: Set<string>, currentAgent?: string): AvailableSkill[];

package/dist/agents/builtin-agents/general-agents.d.ts

@@ -0,0 +1,21 @@
+import type { BrowserAutomationProvider, CategoryConfig } from "../../config/schema";
+import type { AgentConfig } from "../agent-config";
+import type { AvailableAgent } from "../dynamic-agent-prompt-builder";
+import type { AgentOverrides, AgentPromptMetadata, BuiltinAgentName } from "../types";
+export declare function collectPendingBuiltinAgents(input: {
+    agentSources: Partial<Record<BuiltinAgentName, import("../agent-builder").AgentSource>>;
+    agentMetadata: Partial<Record<BuiltinAgentName, AgentPromptMetadata>>;
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    globalOverrideModel?: string;
+    directory?: string;
+    systemDefaultModel?: string;
+    mergedCategories: Record<string, CategoryConfig>;
+    browserProvider?: BrowserAutomationProvider;
+    uiSelectedModel?: string;
+    availableModels: Set<string>;
+    disabledSkills?: Set<string>;
+}): {
+    pendingAgentConfigs: Map<string, AgentConfig>;
+    availableAgents: AvailableAgent[];
+};

package/dist/agents/builtin-agents/keymaker-agent.d.ts

@@ -0,0 +1,20 @@
+import type { BrowserAutomationProvider, CategoryConfig } from "../../config/schema";
+import type { AgentConfig } from "../agent-config";
+import type { AvailableAgent, AvailableCategory, AvailableSkill } from "../dynamic-agent-prompt-builder";
+import type { AgentOverrides } from "../types";
+export declare function maybeCreateKeymakerConfig(input: {
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    globalOverrideModel?: string;
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+    isFirstRunNoCache: boolean;
+    availableAgents: AvailableAgent[];
+    availableSkills: AvailableSkill[];
+    availableCategories: AvailableCategory[];
+    mergedCategories: Record<string, CategoryConfig>;
+    directory?: string;
+    availableToolNames: string[];
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}): AgentConfig | undefined;

package/dist/agents/builtin-agents/model-resolution.d.ts

@@ -0,0 +1,25 @@
+export declare function applyModelResolution(input: {
+    globalOverrideModel?: string;
+    uiSelectedModel?: string;
+    userModel?: string;
+    requirement?: {
+        fallbackChain?: {
+            providers: string[];
+            model: string;
+            variant?: string;
+        }[];
+    };
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+}): import("../../shared").ModelResolutionResult | undefined;
+export declare function getFirstFallbackModel(requirement?: {
+    fallbackChain?: {
+        providers: string[];
+        model: string;
+        variant?: string;
+    }[];
+}): {
+    model: string;
+    provenance: "provider-fallback";
+    variant: string | undefined;
+} | undefined;

package/dist/agents/builtin-agents/morpheus-agent.d.ts

@@ -0,0 +1,22 @@
+import type { BrowserAutomationProvider, CategoriesConfig, CategoryConfig } from "../../config/schema";
+import type { AgentConfig } from "../agent-config";
+import type { AvailableAgent, AvailableCategory, AvailableSkill } from "../dynamic-agent-prompt-builder";
+import type { AgentOverrides } from "../types";
+export declare function maybeCreateMorpheusConfig(input: {
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    globalOverrideModel?: string;
+    uiSelectedModel?: string;
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+    isFirstRunNoCache: boolean;
+    availableAgents: AvailableAgent[];
+    availableSkills: AvailableSkill[];
+    availableCategories: AvailableCategory[];
+    mergedCategories: Record<string, CategoryConfig>;
+    directory?: string;
+    userCategories?: CategoriesConfig;
+    availableToolNames: string[];
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}): AgentConfig | undefined;

package/dist/agents/builtin-agents/niobe-agent.d.ts

@@ -0,0 +1,19 @@
+import type { BrowserAutomationProvider, CategoriesConfig, CategoryConfig } from "../../config/schema";
+import type { AgentConfig } from "../agent-config";
+import type { AvailableAgent, AvailableSkill } from "../dynamic-agent-prompt-builder";
+import type { AgentOverrides } from "../types";
+export declare function maybeCreateNiobeConfig(input: {
+    disabledAgents: string[];
+    agentOverrides: AgentOverrides;
+    globalOverrideModel?: string;
+    uiSelectedModel?: string;
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+    availableAgents: AvailableAgent[];
+    availableSkills: AvailableSkill[];
+    mergedCategories: Record<string, CategoryConfig>;
+    directory?: string;
+    userCategories?: CategoriesConfig;
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}): AgentConfig | undefined;

package/dist/agents/builtin-agents/resolve-file-uri.d.ts

@@ -0,0 +1 @@
+export declare function resolvePromptAppend(promptAppend: string, configDir?: string): string;

package/dist/agents/builtin-agents.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserAutomationProvider, CategoriesConfig } from "../config/schema";
+import type { BuiltinSkill } from "../skills";
+import type { AgentConfig } from "./agent-config";
+import type { AgentOverrides } from "./types";
+export declare function createBuiltinAgents(disabledAgents?: string[], agentOverrides?: AgentOverrides, directory?: string, systemDefaultModel?: string, categories?: CategoriesConfig, discoveredSkills?: BuiltinSkill[], customAgentSummaries?: unknown, browserProvider?: BrowserAutomationProvider, uiSelectedModel?: string, disabledSkills?: Set<string>, globalModel?: string, availableToolNames?: string[]): Promise<Record<string, AgentConfig>>;

package/dist/agents/cipher.d.ts

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

package/dist/agents/construct.d.ts

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

package/dist/agents/custom-agent-summaries.d.ts

@@ -0,0 +1,8 @@
+import type { AgentPromptMetadata } from "./types";
+type RegisteredAgentSummary = {
+    name: string;
+    description: string;
+};
+export declare function parseRegisteredAgentSummaries(input: unknown): RegisteredAgentSummary[];
+export declare function buildCustomAgentMetadata(agentName: string, description: string): AgentPromptMetadata;
+export {};