@opencode_weave/weave 0.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Weave
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,317 @@
+<p align="center">
+  <img src="assets/weave_logo.png" alt="Weave" width="400">
+</p>
+
+# Weave
+
+Weave is a lean OpenCode plugin with multi-agent orchestration. It provides a cohesive framework for weaving agents, tools, and skills into structured workflows. By delegating complex tasks to specialized agents and monitoring execution state through hooks, Weave ensures reliable and efficient project development.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Agents](#agents)
+  - [Agent Modes](#agent-modes)
+  - [Agent Details](#agent-details)
+- [Workflow](#workflow)
+  - [When the Full Workflow Is Used](#when-the-full-workflow-is-used)
+  - [1. Plan](#1-plan)
+  - [2. Review (Optional)](#2-review-optional)
+  - [3. Execute](#3-execute)
+  - [Resuming Interrupted Work](#resuming-interrupted-work)
+  - [Quick Tasks (No Plan Needed)](#quick-tasks-no-plan-needed)
+- [Installation](#installation)
+  - [Prerequisites](#prerequisites)
+  - [Step 1: Install](#step-1-install)
+  - [Step 2: Register in opencode.json](#step-2-register-in-opencodejson)
+  - [Step 3: Restart OpenCode](#step-3-restart-opencode)
+  - [Troubleshooting](#troubleshooting)
+- [Uninstalling](#uninstalling)
+- [Configuration](#configuration)
+  - [Example Configuration](#example-configuration)
+  - [Configuration Fields](#configuration-fields)
+- [Features](#features)
+  - [Hooks](#hooks)
+  - [Skills](#skills)
+  - [Background Agents](#background-agents)
+  - [Tool Permissions](#tool-permissions)
+- [Development](#development)
+- [License](#license)
+
+## Overview
+
+- **8 specialized agents** with weaving-themed names designed for specific roles in the development lifecycle.
+- **Category-based task dispatch** to route work to domain-optimized models and configurations.
+- **Skill system** for injecting domain-specific expertise that modifies agent behavior via prompt orchestration.
+- **Background agent management** for parallel asynchronous sub-agent execution with concurrency control.
+- **Context window monitoring** to track token usage and suggest recovery strategies when limits are approached.
+- **Tool permissions** enforced per-agent to ensure safety and prevent unauthorized file modifications.
+- **JSONC configuration** supporting comments and trailing commas with hierarchical user and project-level merging.
+
+## Agents
+
+| Agent | Role | Mode | Description |
+| :--- | :--- | :--- | :--- |
+| **Loom** | main orchestrator | primary | The central team lead that plans tasks, coordinates work, and delegates to specialized agents. |
+| **Tapestry** | execution orchestrator | primary | Manages todo-list driven execution of multi-step plans, focusing on sequential implementation without subagent spawning. |
+| **Shuttle** | category worker | all | Domain-specific specialist worker with full tool access, dispatched dynamically via the category system. |
+| **Pattern** | strategic planner | subagent | Analyzes requirements and produces detailed implementation plans with research and dependency mapping. |
+| **Thread** | codebase explorer | subagent | Fast, read-only codebase navigation and analysis using grep, glob, and read tools. |
+| **Spindle** | external researcher | subagent | Performs external documentation lookups and reference searches, providing synthesized answers with source citations. |
+| **Weft** | reviewer/auditor | subagent | Reviews completed work and plans with a critical but fair eye, rejecting only for true blocking issues. |
+| **Warp** | security auditor | subagent | Audits code changes for security vulnerabilities and specification compliance with a skeptical bias. |
+
+### Agent Modes
+
+- `primary`: Respects the user-selected model in the OpenCode UI.
+- `subagent`: Uses its own model or fallback chain, ignoring UI selection for predictable specialization.
+- `all`: Available in both primary and subagent contexts.
+
+### Agent Details
+
+**Loom** is the central orchestrator and the default entry point for every request. It breaks down complex problems into tasks, decides which agents to delegate to, and tracks progress obsessively via todo lists. Loom never implements code directly — it plans and delegates. For quick fixes it acts immediately; for complex work it kicks off the plan → review → execute workflow.
+
+**Pattern** is the strategic planner. When a task requires 5+ steps or involves architectural decisions, Loom delegates to Pattern, which researches the codebase (via Thread) and external docs (via Spindle), then produces a structured implementation plan saved to `.weave/plans/{name}.md`. Plans use `- [ ]` checkboxes for every actionable task. Pattern never writes code — only plans.
+
+**Weft** is the reviewer and auditor. It validates plans before execution and reviews completed work after implementation. Weft is approval-biased and only rejects for true blocking issues (max 3 per review). It checks that file references are correct, tasks have sufficient context, implementations match requirements, and no stubs or TODOs are left behind. Weft is read-only.
+
+**Warp** is the security and specification compliance auditor. It reviews code changes for security vulnerabilities (injection, auth bypass, token handling, crypto weaknesses) and verifies compliance with standards like OAuth2, OIDC, WebAuthn, and JWT. Warp has a skeptical bias — unlike Weft, it rejects by default when security patterns are detected. It self-triages to fast-exit on non-security changes, and can webfetch RFCs for verification. Warp is read-only.
+
+**Tapestry** is the execution engine. Activated by the `/start-work` command, it reads a plan from `.weave/plans/` and works through tasks sequentially — writing code, running commands, verifying output, and marking checkboxes as it goes. Tapestry cannot spawn subagents; it focuses on heads-down implementation. If interrupted, it resumes from the first unchecked task.
+
+**Thread** is the fast codebase explorer. Loom delegates to Thread whenever it needs to understand code structure, find files, or answer questions about the repository. Thread uses grep, glob, and read tools with zero creativity (temperature 0.0) to return precise, factual answers with file paths and line numbers. Thread is read-only.
+
+**Spindle** is the external researcher. When Loom needs documentation for a library, API reference, or any information outside the codebase, Spindle fetches URLs, reads docs, and synthesizes findings with source citations. Spindle is read-only.
+
+**Shuttle** is the domain specialist. When work falls into a specific category (e.g., visual engineering, data processing), Loom dispatches Shuttle with full tool access to execute the task. Shuttle's model and configuration can be overridden per-category for domain-optimized performance.
+
+## Workflow
+
+Weave uses a structured **Plan → Review → Execute** workflow for complex tasks. Simple requests are handled directly by Loom without the full cycle.
+
+### When the Full Workflow Is Used
+
+- Tasks requiring 5+ steps or architectural decisions
+- Multi-file refactors or new feature implementations
+- Work that benefits from a reviewable plan before execution
+
+### 1. Plan
+
+Loom delegates to **Pattern**, which researches the codebase and produces a detailed implementation plan:
+
+```
+User Request → Loom (assesses complexity) → Pattern (researches + plans)
+                                              ↓
+                                     .weave/plans/{name}.md
+```
+
+The plan includes clear objectives, deliverables, and atomic tasks marked with `- [ ]` checkboxes. Pattern never writes code.
+
+### 2. Review (Optional)
+
+For high-stakes or complex plans, Loom delegates to **Weft** to validate the plan before execution:
+
+```
+.weave/plans/{name}.md → Weft (validates) → APPROVE or REJECT
+```
+
+Weft checks that referenced files exist, tasks have sufficient context, and there are no contradictions. If rejected, issues are sent back to Pattern for revision.
+
+### 3. Execute
+
+The user runs `/start-work` to begin execution:
+
+```
+/start-work [plan-name] → creates .weave/state.json → switches to Tapestry
+```
+
+**Tapestry** reads the plan and executes tasks sequentially:
+
+1. Find the first unchecked `- [ ]` task
+2. Implement the task (write code, run commands, create files)
+3. Verify completion (read files, run tests, check acceptance criteria)
+4. Mark the checkbox `- [x]`
+5. Move to the next unchecked task
+6. When all tasks are complete, report a final summary
+
+### Resuming Interrupted Work
+
+If a session is interrupted, running `/start-work` again resumes from the first unchecked task — no re-planning or restarting. The work state is persisted in `.weave/state.json`, so progress is never lost.
+
+### Quick Tasks (No Plan Needed)
+
+For simple requests — single-file fixes, quick questions, small edits — Loom handles the work directly or delegates to the appropriate agent without creating a formal plan.
+
+## Installation
+
+This package is published on [npm](https://www.npmjs.com/package/@opencode_weave/weave).
+
+### Prerequisites
+
+- [OpenCode](https://opencode.ai)
+- Bun or Node.js
+
+### Step 1: Install
+
+```bash
+bun add @opencode_weave/weave
+# or
+npm install @opencode_weave/weave
+```
+
+### Step 2: Register in opencode.json
+
+Add the plugin to your `opencode.json` file:
+
+```json
+{
+  "plugin": ["@opencode_weave/weave"]
+}
+```
+
+### Step 3: Restart OpenCode
+
+The plugin loads automatically upon restart and works with zero configuration out of the box.
+
+### Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| `404 Not Found` | Ensure the package name is correct: `@opencode_weave/weave`. |
+| Package not found after publish | npm can take a few minutes to propagate. Wait and retry. |
+
+## Uninstalling
+
+To fully remove the Weave plugin from your project:
+
+### Step 1: Remove from opencode.json
+
+Delete the `@opencode_weave/weave` entry from the `plugin` array in your `opencode.json`:
+
+```json
+{
+  "plugin": []
+}
+```
+
+### Step 2: Uninstall the package
+
+```bash
+bun remove @opencode_weave/weave
+# or
+npm uninstall @opencode_weave/weave
+```
+
+### Step 3: Clean up project artifacts (optional)
+
+Weave may have created plan and state files during usage. Remove them if no longer needed:
+
+```bash
+rm -rf .weave/
+```
+
+You can also remove any project-level configuration if present:
+
+```bash
+rm -f .opencode/weave-opencode.jsonc .opencode/weave-opencode.json
+```
+
+### Step 4: Clean up user-level configuration (optional)
+
+If you no longer use Weave in any project, remove the global configuration:
+
+```bash
+rm -f ~/.config/opencode/weave-opencode.jsonc ~/.config/opencode/weave-opencode.json
+```
+
+## Configuration
+
+Weave searches for configuration files in the following locations, merging them in order (user config → project config → defaults):
+
+- **Project**: `.opencode/weave-opencode.jsonc` or `.opencode/weave-opencode.json`
+- **User**: `~/.config/opencode/weave-opencode.jsonc` or `~/.config/opencode/weave-opencode.json`
+
+The configuration uses JSONC format, allowing for comments and trailing commas.
+
+### Example Configuration
+
+```jsonc
+{
+  // Override agent models and parameters
+  "agents": {
+    "loom": { 
+      "model": "anthropic/claude-3-5-sonnet", 
+      "temperature": 0.1 
+    },
+    "thread": { 
+      "model": "openai/gpt-4o-mini" 
+    }
+  },
+  // Category-based dispatch overrides
+  "categories": {
+    "visual-engineering": { 
+      "model": "google/gemini-2-pro" 
+    }
+  },
+  // Selective feature toggling
+  "disabled_hooks": [],
+  "disabled_agents": [],
+  "disabled_tools": [],
+  "disabled_skills": [],
+  // Background agent concurrency limits
+  "background": {
+    "defaultConcurrency": 5
+  }
+}
+```
+
+### Configuration Fields
+
+- `agents` — Override model, temperature, prompt_append, tools, and skills per agent.
+- `categories` — Custom model and tool configurations for category-based dispatch.
+- `disabled_hooks` / `disabled_agents` / `disabled_tools` / `disabled_skills` — Selective feature disabling.
+- `background` — Concurrency limits and timeouts for parallel background agents.
+- `tmux` — Terminal multiplexer layout settings for TUI integration.
+- `skills` — Custom skill discovery paths and recursion settings.
+- `experimental` — Plugin load timeouts and context window threshold adjustments.
+
+## Features
+
+### Hooks
+
+Weave includes 5 built-in hooks that monitor and modify agent behavior:
+
+- `context-window-monitor` — Warns when token usage approaches limits and suggests recovery strategies.
+- `write-existing-file-guard` — Tracks file reads to prevent agents from overwriting files they haven't examined.
+- `rules-injector` — Automatically injects contextual rules when agents enter directories containing AGENTS.md.
+- `first-message-variant` — Applies specific prompt variants on session start for consistent behavior.
+- `keyword-detector` — Detects keywords in messages to trigger behavioral changes or agent switches.
+
+All hooks are enabled by default and can be disabled via the `disabled_hooks` configuration.
+
+### Skills
+
+Skills are injectable prompt expertise loaded from markdown files (SKILL.md). They modify agent behavior by prepending domain-specific instructions to the agent's system prompt.
+
+Skills are discovered across three scopes:
+- `builtin` — Provided by the Weave plugin.
+- `user` — Located in the user's global configuration directory.
+- `project` — Located in the current project's `.opencode/skills/` directory.
+
+### Background Agents
+
+Weave supports parallel asynchronous sub-agent management via the BackgroundManager. This allows Loom to spawn multiple agents simultaneously to handle independent tasks, with configurable concurrency limits to manage API rate limits.
+
+### Tool Permissions
+
+Tool access is controlled per-agent to ensure safety and specialized focus. For example, **Thread** and **Spindle** are strictly read-only; they are denied access to write, edit, and task management tools. These permissions can be customized globally or per-agent in the configuration.
+
+## Development
+
+- **Build**: `bun run build`
+- **Test**: `bun test`
+- **Typecheck**: `bun run typecheck`
+- **Clean**: `bun run clean`
+
+## License
+
+MIT

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

@@ -0,0 +1,10 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentSource } from "./types";
+import type { CategoriesConfig } from "../config/schema";
+export type ResolveSkillsFn = (skillNames: string[], disabledSkills?: Set<string>) => string;
+export type BuildAgentOptions = {
+    categories?: CategoriesConfig;
+    disabledSkills?: Set<string>;
+    resolveSkills?: ResolveSkillsFn;
+};
+export declare function buildAgent(source: AgentSource, model: string, options?: BuildAgentOptions): AgentConfig;

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

@@ -0,0 +1,16 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata, WeaveAgentName } from "./types";
+import type { CategoriesConfig, AgentOverrideConfig } from "../config/schema";
+import type { ResolveSkillsFn } from "./agent-builder";
+export interface CreateBuiltinAgentsOptions {
+    disabledAgents?: string[];
+    agentOverrides?: Record<string, AgentOverrideConfig>;
+    categories?: CategoriesConfig;
+    uiSelectedModel?: string;
+    systemDefaultModel?: string;
+    availableModels?: Set<string>;
+    disabledSkills?: Set<string>;
+    resolveSkills?: ResolveSkillsFn;
+}
+export declare const AGENT_METADATA: Record<WeaveAgentName, AgentPromptMetadata>;
+export declare function createBuiltinAgents(options?: CreateBuiltinAgentsOptions): Record<string, AgentConfig>;

package/dist/agents/dynamic-prompt-builder.d.ts

@@ -0,0 +1,29 @@
+import type { AgentPromptMetadata } from "./types";
+export interface AvailableAgent {
+    name: string;
+    description: string;
+    metadata: AgentPromptMetadata;
+}
+export interface AvailableTool {
+    name: string;
+    category: "lsp" | "ast" | "search" | "session" | "command" | "other";
+}
+export interface AvailableSkill {
+    name: string;
+    description: string;
+    location: "user" | "project" | "builtin";
+}
+export interface AvailableCategory {
+    name: string;
+    description: string;
+    model?: string;
+}
+export declare function categorizeTools(toolNames: string[]): AvailableTool[];
+export declare function buildKeyTriggersSection(agents: AvailableAgent[], _skills?: AvailableSkill[]): string;
+export declare function buildToolSelectionTable(agents: AvailableAgent[], tools?: AvailableTool[], _skills?: AvailableSkill[]): string;
+export declare function buildThreadSection(agents: AvailableAgent[]): string;
+export declare function buildSpindleSection(agents: AvailableAgent[]): string;
+export declare function buildWeftSection(agents: AvailableAgent[]): string;
+export declare function buildWarpSection(agents: AvailableAgent[]): string;
+export declare function buildDelegationTable(agents: AvailableAgent[]): string;
+export declare function buildCategorySkillsDelegationGuide(categories: AvailableCategory[], skills: AvailableSkill[]): string;

package/dist/agents/index.d.ts

@@ -0,0 +1,8 @@
+export { createBuiltinAgents, AGENT_METADATA } from "./builtin-agents";
+export type { CreateBuiltinAgentsOptions } from "./builtin-agents";
+export { buildAgent } from "./agent-builder";
+export type { BuildAgentOptions, ResolveSkillsFn } from "./agent-builder";
+export { resolveAgentModel, AGENT_MODEL_REQUIREMENTS } from "./model-resolution";
+export * from "./dynamic-prompt-builder";
+export type { AgentMode, AgentFactory, AgentSource, AgentCategory, AgentCost, DelegationTrigger, AgentPromptMetadata, WeaveAgentName, } from "./types";
+export { isFactory, isGptModel } from "./types";

package/dist/agents/loom/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const LOOM_DEFAULTS: AgentConfig;

package/dist/agents/loom/index.d.ts

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

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

@@ -0,0 +1,19 @@
+import type { AgentMode, WeaveAgentName } from "./types";
+export type FallbackEntry = {
+    providers: string[];
+    model: string;
+    variant?: string;
+};
+export type AgentModelRequirement = {
+    fallbackChain: FallbackEntry[];
+};
+export declare const AGENT_MODEL_REQUIREMENTS: Record<WeaveAgentName, AgentModelRequirement>;
+export type ResolveAgentModelOptions = {
+    availableModels: Set<string>;
+    agentMode: AgentMode;
+    uiSelectedModel?: string;
+    categoryModel?: string;
+    overrideModel?: string;
+    systemDefaultModel?: string;
+};
+export declare function resolveAgentModel(agentName: WeaveAgentName, options: ResolveAgentModelOptions): string;

package/dist/agents/pattern/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const PATTERN_DEFAULTS: AgentConfig;

package/dist/agents/pattern/index.d.ts

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

package/dist/agents/shuttle/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const SHUTTLE_DEFAULTS: AgentConfig;

package/dist/agents/shuttle/index.d.ts

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

package/dist/agents/spindle/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const SPINDLE_DEFAULTS: AgentConfig;

package/dist/agents/spindle/index.d.ts

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

package/dist/agents/tapestry/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const TAPESTRY_DEFAULTS: AgentConfig;

package/dist/agents/tapestry/index.d.ts

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

package/dist/agents/thread/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const THREAD_DEFAULTS: AgentConfig;

package/dist/agents/thread/index.d.ts

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

package/dist/agents/types.d.ts

@@ -0,0 +1,82 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+/**
+ * Agent mode determines UI model selection behavior:
+ * - "primary": Respects user's UI-selected model (loom, tapestry)
+ * - "subagent": Uses own fallback chain, ignores UI selection (pattern, thread, spindle)
+ * - "all": Available in both contexts (shuttle)
+ */
+export type AgentMode = "primary" | "subagent" | "all";
+/**
+ * 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 source is either a factory (called with model) or a static config (cloned)
+ */
+export type AgentSource = AgentFactory | AgentConfig;
+/**
+ * Agent category for grouping in Loom prompt sections
+ */
+export type AgentCategory = "exploration" | "specialist" | "advisor" | "utility";
+/**
+ * Cost classification for Tool Selection table
+ */
+export type AgentCost = "FREE" | "CHEAP" | "EXPENSIVE";
+/**
+ * Delegation trigger for Loom prompt's Delegation Table
+ */
+export 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 Loom prompt sections dynamically.
+ * Allows adding/removing agents without manually updating the Loom 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) */
+    dedicatedSection?: string;
+    /** Nickname/alias used in prompt (e.g., "Pattern" instead of "pattern") */
+    promptAlias?: string;
+    /** Key trigger that should appear in Phase 0 quick checks */
+    keyTrigger?: string;
+}
+/**
+ * The 8 built-in Weave agent names
+ */
+export type WeaveAgentName = "loom" | "tapestry" | "shuttle" | "pattern" | "thread" | "spindle" | "weft" | "warp";
+/**
+ * Override config for a single agent — all fields optional
+ */
+export type AgentOverrideConfig = Partial<AgentConfig> & {
+    prompt_append?: string;
+    variant?: string;
+    fallback_models?: string | string[];
+};
+/**
+ * Map of agent name to override config
+ */
+export type AgentOverrides = Partial<Record<WeaveAgentName, AgentOverrideConfig>>;
+/**
+ * Returns true if the model string identifies a GPT/OpenAI model.
+ */
+export declare function isGptModel(model: string): boolean;
+/**
+ * Type guard: returns true if source is an AgentFactory (callable with .mode).
+ */
+export declare function isFactory(source: AgentSource): source is AgentFactory;

package/dist/agents/warp/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const WARP_DEFAULTS: AgentConfig;

package/dist/agents/warp/index.d.ts

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

package/dist/agents/weft/default.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare const WEFT_DEFAULTS: AgentConfig;

package/dist/agents/weft/index.d.ts

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

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./schema";
+export { loadWeaveConfig } from "./loader";
+export { mergeConfigs } from "./merge";

package/dist/config/loader.d.ts

@@ -0,0 +1,2 @@
+import { type WeaveConfig } from "./schema";
+export declare function loadWeaveConfig(directory: string, _ctx?: unknown): WeaveConfig;

package/dist/config/merge.d.ts

@@ -0,0 +1,3 @@
+import type { WeaveConfig } from "./schema";
+import type { DeepPartial } from "../shared/types";
+export declare function mergeConfigs(user: DeepPartial<WeaveConfig>, project: DeepPartial<WeaveConfig>): DeepPartial<WeaveConfig>;