@fabriccode/weave 0.7.0

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,309 @@
+<p align="center">
+  <img src="assets/fabric_logo.png" alt="Fabric" width="400">
+</p>
+
+# Weave
+
+Weave is a lean Fabric 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)
+- [Documentation](#documentation)
+- [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: Add to fabric.json](#step-1-add-to-fabricjson)
+  - [Step 2: Restart Fabric](#step-2-restart-fabric)
+  - [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)
+- [Acknowledgments](#acknowledgments)
+- [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.
+
+## Documentation
+
+Visit [Fabric Agents](https://agents.fabric.pro) for more information, or head straight to the [documentation](https://fabric.pro/docs/) for detailed guides on setup, configuration, and usage.
+
+## 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 Fabric 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/@fabriccode/weave).
+
+### Prerequisites
+
+- [Fabric](https://fabric.pro)
+
+### Step 1: Add to fabric.json
+
+Add the plugin to your `fabric.json` file:
+
+```json
+{
+  "plugin": ["@fabriccode/weave"]
+}
+```
+
+### Step 2: Restart Fabric
+
+Fabric automatically installs npm plugins at startup — no manual `bun add` or `npm install` required. 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: `@fabriccode/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 fabric.json
+
+Delete the `@fabriccode/weave` entry from the `plugin` array in your `fabric.json`:
+
+```json
+{
+  "plugin": []
+}
+```
+
+### Step 2: 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 .fabric/weave-fabric.jsonc .fabric/weave-fabric.json
+```
+
+### Step 3: Clean up user-level configuration (optional)
+
+If you no longer use Weave in any project, remove the global configuration:
+
+```bash
+rm -f ~/.config/fabric/weave-fabric.jsonc ~/.config/fabric/weave-fabric.json
+```
+
+## Configuration
+
+Weave searches for configuration files in the following locations, merging them in order (user config → project config → defaults):
+
+- **Project**: `.fabric/weave-fabric.jsonc` or `.fabric/weave-fabric.json`
+- **User**: `~/.config/fabric/weave-fabric.jsonc` or `~/.config/fabric/weave-fabric.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 `.fabric/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`
+
+## Acknowledgments
+
+Weave was inspired by [Oh My Fabric](https://github.com/code-yeongyu/oh-my-fabric) by [@code-yeongyu](https://github.com/code-yeongyu) — a pioneering Fabric plugin that proved multi-agent orchestration, discipline agents, and structured plan-execute workflows could radically improve the developer experience. Many of Weave's core ideas — from category-based task dispatch to background agent parallelism — trace their roots to patterns Oh My Fabric established. We're grateful for the trailblazing work and the vibrant community around it.
+
+## License
+
+MIT

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

@@ -0,0 +1,24 @@
+import type { AgentConfig } from "@fabriccode/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;
+    disabledAgents?: Set<string>;
+};
+/**
+ * Register name variants for a custom agent so that
+ * `stripDisabledAgentReferences` can strip its references from prompts.
+ * Does not override existing (builtin) entries.
+ */
+export declare function registerAgentNameVariants(name: string, variants?: string[]): void;
+/**
+ * Remove lines from a prompt that reference disabled agents.
+ * Only strips lines where an agent name appears as a standalone concept
+ * (e.g. "Use thread (codebase explorer)"), not incidental word matches.
+ * Uses word-boundary matching to avoid false positives.
+ */
+export declare function stripDisabledAgentReferences(prompt: string, disabled: Set<string>): string;
+export declare function buildAgent(source: AgentSource, model: string, options?: BuildAgentOptions): AgentConfig;

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

@@ -0,0 +1,32 @@
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { AgentPromptMetadata, WeaveAgentName } from "./types";
+import type { CategoriesConfig, AgentOverrideConfig } from "../config/schema";
+import type { ResolveSkillsFn } from "./agent-builder";
+import type { ProjectFingerprint } from "../features/analytics/types";
+import type { AvailableAgent } from "./dynamic-prompt-builder";
+export interface CreateBuiltinAgentsOptions {
+    disabledAgents?: string[];
+    agentOverrides?: Record<string, AgentOverrideConfig>;
+    categories?: CategoriesConfig;
+    uiSelectedModel?: string;
+    systemDefaultModel?: string;
+    availableModels?: Set<string>;
+    disabledSkills?: Set<string>;
+    resolveSkills?: ResolveSkillsFn;
+    /** Project fingerprint for injecting project context into agent prompts */
+    fingerprint?: ProjectFingerprint | null;
+    /** Custom agent metadata for Loom's dynamic delegation prompt */
+    customAgentMetadata?: AvailableAgent[];
+}
+export declare const AGENT_METADATA: Record<WeaveAgentName, AgentPromptMetadata>;
+/**
+ * Register metadata for a custom agent. Used by create-managers.ts
+ * to integrate custom agents into Loom's dynamic prompt builder.
+ */
+export declare function registerCustomAgentMetadata(name: string, metadata: AgentPromptMetadata): void;
+/**
+ * Get all agent metadata — builtins + registered custom agents.
+ * Returns a new merged record on each call.
+ */
+export declare function getAllAgentMetadata(): Record<string, AgentPromptMetadata>;
+export declare function createBuiltinAgents(options?: CreateBuiltinAgentsOptions): Record<string, AgentConfig>;

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

@@ -0,0 +1,24 @@
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { CustomAgentConfig } from "../config/schema";
+import type { AgentPromptMetadata } from "./types";
+import type { ResolveSkillsFn } from "./agent-builder";
+export interface BuildCustomAgentOptions {
+    resolveSkills?: ResolveSkillsFn;
+    disabledSkills?: Set<string>;
+    availableModels?: Set<string>;
+    systemDefaultModel?: string;
+    uiSelectedModel?: string;
+    /** Base directory for resolving relative prompt_file paths */
+    configDir?: string;
+}
+/**
+ * Build an AgentConfig from a custom agent definition.
+ * Handles prompt resolution (inline, file, or skills), model resolution,
+ * and display name registration.
+ */
+export declare function buildCustomAgent(name: string, config: CustomAgentConfig, options?: BuildCustomAgentOptions): AgentConfig;
+/**
+ * Build AgentPromptMetadata for a custom agent from its config.
+ * Used to integrate custom agents into Loom's delegation table.
+ */
+export declare function buildCustomAgentMetadata(name: string, config: CustomAgentConfig): AgentPromptMetadata;

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

@@ -0,0 +1,35 @@
+import type { AgentPromptMetadata } from "./types";
+import type { ProjectFingerprint } from "../features/analytics/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;
+/**
+ * Build a project context section from a codebase fingerprint.
+ * Returns an empty string if no fingerprint is available.
+ */
+export declare function buildProjectContextSection(fingerprint: ProjectFingerprint | null | undefined): string;

package/dist/agents/index.d.ts

@@ -0,0 +1,12 @@
+export { createBuiltinAgents, AGENT_METADATA, registerCustomAgentMetadata, getAllAgentMetadata } from "./builtin-agents";
+export type { CreateBuiltinAgentsOptions } from "./builtin-agents";
+export { buildAgent, stripDisabledAgentReferences } from "./agent-builder";
+export type { BuildAgentOptions, ResolveSkillsFn } from "./agent-builder";
+export { resolveAgentModel, AGENT_MODEL_REQUIREMENTS } from "./model-resolution";
+export type { FallbackEntry, AgentModelRequirement, ResolveAgentModelOptions } from "./model-resolution";
+export { buildCustomAgent, buildCustomAgentMetadata } from "./custom-agent-factory";
+export type { BuildCustomAgentOptions } from "./custom-agent-factory";
+export { loadPromptFile } from "./prompt-loader";
+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 "@fabriccode/sdk";
+export declare const LOOM_DEFAULTS: AgentConfig;

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

@@ -0,0 +1,11 @@
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { AgentFactory } from "../types";
+import type { AvailableAgent } from "../dynamic-prompt-builder";
+import type { ProjectFingerprint } from "../../features/analytics/types";
+export { composeLoomPrompt } from "./prompt-composer";
+export type { LoomPromptOptions } from "./prompt-composer";
+/**
+ * Create a Loom agent config with optional disabled agents, fingerprint, and custom agents for prompt composition.
+ */
+export declare function createLoomAgentWithOptions(model: string, disabledAgents?: Set<string>, fingerprint?: ProjectFingerprint | null, customAgents?: AvailableAgent[]): AgentConfig;
+export declare const createLoomAgent: AgentFactory;

package/dist/agents/loom/prompt-composer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Loom prompt composer — assembles the Loom system prompt from sections,
+ * conditionally including/excluding content based on enabled agents.
+ *
+ * Default behavior (no disabled agents) produces identical output to the
+ * hardcoded LOOM_DEFAULTS.prompt string.
+ */
+import type { ProjectFingerprint } from "../../features/analytics/types";
+import type { AvailableAgent } from "../dynamic-prompt-builder";
+export interface LoomPromptOptions {
+    /** Set of disabled agent names (lowercase config keys) */
+    disabledAgents?: Set<string>;
+    /** Project fingerprint for injecting project context into the prompt */
+    fingerprint?: ProjectFingerprint | null;
+    /** Custom agent metadata for dynamic delegation sections */
+    customAgents?: AvailableAgent[];
+}
+export declare function buildRoleSection(): string;
+export declare function buildDisciplineSection(): string;
+export declare function buildSidebarTodosSection(): string;
+export declare function buildDelegationSection(disabled: Set<string>): string;
+export declare function buildDelegationNarrationSection(disabled?: Set<string>): string;
+export declare function buildPlanWorkflowSection(disabled: Set<string>): string;
+export declare function buildReviewWorkflowSection(disabled: Set<string>): string;
+export declare function buildStyleSection(): string;
+/**
+ * Build a delegation section for custom agents.
+ * Returns empty string if no enabled custom agents exist.
+ */
+export declare function buildCustomAgentDelegationSection(customAgents: AvailableAgent[], disabled: Set<string>): string;
+/**
+ * Compose the full Loom system prompt from sections.
+ * When no agents are disabled, produces identical output to LOOM_DEFAULTS.prompt.
+ */
+export declare function composeLoomPrompt(options?: LoomPromptOptions): string;

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

@@ -0,0 +1,27 @@
+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;
+    /** Custom fallback chain for agents not in AGENT_MODEL_REQUIREMENTS */
+    customFallbackChain?: FallbackEntry[];
+};
+/**
+ * Resolve the model for an agent. Accepts any string agent name.
+ * Built-in agents use AGENT_MODEL_REQUIREMENTS for fallback chains.
+ * Custom agents use the customFallbackChain option, or fall through
+ * to system default / hardcoded fallback.
+ */
+export declare function resolveAgentModel(agentName: string, options: ResolveAgentModelOptions): string;

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

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@fabriccode/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/prompt-loader.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Load a prompt from a file path. Supports .md and .txt files.
+ * Paths are sandboxed to basePath (or cwd) — traversal outside is rejected.
+ *
+ * @param promptFilePath - Path to the prompt file (relative to basePath; absolute paths are rejected)
+ * @param basePath - Base directory for resolving relative paths (defaults to cwd)
+ * @returns The file contents as a string, or null if the file doesn't exist or path escapes the sandbox
+ */
+export declare function loadPromptFile(promptFilePath: string, basePath?: string): string | null;

package/dist/agents/prompt-utils.d.ts

@@ -0,0 +1,2 @@
+/** Check whether an agent is enabled (not in the disabled set). */
+export declare function isAgentEnabled(name: string, disabled: Set<string>): boolean;

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

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@fabriccode/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 "@fabriccode/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 "@fabriccode/sdk";
+export declare const TAPESTRY_DEFAULTS: AgentConfig;

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

@@ -0,0 +1,9 @@
+import type { AgentConfig } from "@fabriccode/sdk";
+import type { AgentFactory } from "../types";
+export { composeTapestryPrompt } from "./prompt-composer";
+export type { TapestryPromptOptions } from "./prompt-composer";
+/**
+ * Create a Tapestry agent config with optional disabled agents for prompt composition.
+ */
+export declare function createTapestryAgentWithOptions(model: string, disabledAgents?: Set<string>): AgentConfig;
+export declare const createTapestryAgent: AgentFactory;

package/dist/agents/tapestry/prompt-composer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tapestry prompt composer — assembles the Tapestry system prompt from sections,
+ * conditionally including/excluding content based on enabled agents.
+ *
+ * Default behavior (no disabled agents) produces identical output to the
+ * hardcoded TAPESTRY_DEFAULTS.prompt string.
+ */
+export interface TapestryPromptOptions {
+    /** Set of disabled agent names (lowercase config keys) */
+    disabledAgents?: Set<string>;
+}
+export declare function buildTapestryRoleSection(): string;
+export declare function buildTapestryDisciplineSection(): string;
+export declare function buildTapestrySidebarTodosSection(): string;
+export declare function buildTapestryPlanExecutionSection(disabled?: Set<string>): string;
+export declare function buildTapestryVerificationSection(): string;
+export declare function buildTapestryPostExecutionReviewSection(disabled: Set<string>): string;
+export declare function buildTapestryExecutionSection(): string;
+export declare function buildTapestryStyleSection(): string;
+/**
+ * Compose the full Tapestry system prompt from sections.
+ * When no agents are disabled, produces identical output to TAPESTRY_DEFAULTS.prompt.
+ */
+export declare function composeTapestryPrompt(options?: TapestryPromptOptions): string;

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

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@fabriccode/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;