@opencode_weave/weave 0.3.2

package/dist/config/schema.d.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    prompt: z.ZodOptional<z.ZodString>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const AgentOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    prompt: z.ZodOptional<z.ZodString>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const CategoryConfigSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const CategoriesConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const BackgroundConfigSchema: z.ZodObject<{
+    defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+    providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    layout: z.ZodOptional<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const SkillsConfigSchema: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ExperimentalConfigSchema: z.ZodObject<{
+    plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
+    context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WeaveConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        prompt: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            subagent: "subagent";
+            primary: "primary";
+            all: "all";
+        }>>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    background: z.ZodOptional<z.ZodObject<{
+        defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+        providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tmux: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        layout: z.ZodOptional<z.ZodEnum<{
+            "main-horizontal": "main-horizontal";
+            "main-vertical": "main-vertical";
+            tiled: "tiled";
+            "even-horizontal": "even-horizontal";
+            "even-vertical": "even-vertical";
+        }>>;
+        main_pane_size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    experimental: z.ZodOptional<z.ZodObject<{
+        plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
+        context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
+export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
+export type WeaveConfig = z.infer<typeof WeaveConfigSchema>;

package/dist/create-managers.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { WeaveConfig } from "./config/schema";
+import type { ResolveSkillsFn } from "./agents/agent-builder";
+import { ConfigHandler } from "./managers/config-handler";
+import { BackgroundManager } from "./managers/background-manager";
+import { SkillMcpManager } from "./managers/skill-mcp-manager";
+export interface WeaveManagers {
+    configHandler: ConfigHandler;
+    backgroundManager: BackgroundManager;
+    skillMcpManager: SkillMcpManager;
+    agents: Record<string, AgentConfig>;
+}
+export declare function createManagers(options: {
+    ctx: PluginInput;
+    pluginConfig: WeaveConfig;
+    resolveSkills?: ResolveSkillsFn;
+}): WeaveManagers;

package/dist/create-tools.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { WeaveConfig } from "./config/schema";
+import type { WeaveManagers } from "./create-managers";
+import type { ToolsRecord } from "./plugin/types";
+import type { LoadedSkill } from "./features/skill-loader/types";
+import type { ResolveSkillsFn } from "./agents/agent-builder";
+export interface ToolsResult {
+    tools: ToolsRecord;
+    availableSkills: LoadedSkill[];
+    resolveSkillsFn: ResolveSkillsFn;
+}
+export declare function createTools(options: {
+    ctx: PluginInput;
+    pluginConfig: WeaveConfig;
+    managers?: WeaveManagers;
+}): Promise<ToolsResult>;

package/dist/features/builtin-commands/commands.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinCommand, BuiltinCommandName } from "./types";
+export declare const BUILTIN_COMMANDS: Record<BuiltinCommandName, BuiltinCommand>;

package/dist/features/builtin-commands/index.d.ts

@@ -0,0 +1,2 @@
+export { BUILTIN_COMMANDS } from "./commands";
+export type { BuiltinCommand, BuiltinCommandName } from "./types";

package/dist/features/builtin-commands/templates/start-work.d.ts

@@ -0,0 +1 @@
+export declare const START_WORK_TEMPLATE = "You are being activated by the /start-work command to execute a Weave plan.\n\n## Your Mission\nRead and execute the work plan, completing each task systematically.\n\n## Startup Procedure\n\n1. **Check for active work state**: Read `.weave/state.json` to see if there's a plan already in progress.\n2. **If resuming**: The system has injected context below with the active plan path and progress. Read the plan file, find the first unchecked `- [ ]` task, and continue from there.\n3. **If starting fresh**: The system has selected a plan and created work state. Read the plan file and begin from the first task.\n\n## Execution Loop\n\nFor each unchecked `- [ ]` task in the plan:\n\n1. **Read** the task description, acceptance criteria, and any references\n2. **Execute** the task \u2014 write code, run commands, create files as needed\n3. **Verify** the work \u2014 run tests, check for errors, validate acceptance criteria\n4. **Mark complete** \u2014 use the Edit tool to change `- [ ]` to `- [x]` in the plan file\n5. **Move on** \u2014 find the next unchecked task and repeat\n\n## Rules\n\n- Work through tasks **top to bottom** unless dependencies require a different order\n- **Verify every task** before marking it complete\n- If blocked on a task, document the reason as a comment in the plan and move to the next unblocked task\n- Report progress after each task: \"Completed task N/M: [title]\"\n- Do NOT stop until all checkboxes are checked or you are explicitly told to stop\n- After all tasks are complete, report a final summary";

package/dist/features/builtin-commands/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A built-in command that can be invoked via /command-name in the chat.
+ */
+export interface BuiltinCommand {
+    /** Command name matching the key in BUILTIN_COMMANDS (e.g., "start-work") */
+    name: string;
+    /** Human-readable description shown in command list */
+    description: string;
+    /** Agent to switch to when this command is executed */
+    agent: string;
+    /** Prompt template with $SESSION_ID, $TIMESTAMP, $ARGUMENTS placeholders */
+    template: string;
+    /** Hint shown for the argument (e.g., "[plan-name]") */
+    argumentHint?: string;
+}
+export type BuiltinCommandName = "start-work";

package/dist/features/skill-loader/builtin-skills.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from "./types";
+export declare function createBuiltinSkills(): LoadedSkill[];

package/dist/features/skill-loader/discovery.d.ts

@@ -0,0 +1,12 @@
+import type { LoadedSkill, SkillMetadata, SkillScope } from "./types";
+interface ParsedFrontmatter {
+    metadata: SkillMetadata;
+    content: string;
+}
+export declare function parseFrontmatter(text: string): ParsedFrontmatter;
+export interface ScanDirectoryOptions {
+    directory: string;
+    scope: SkillScope;
+}
+export declare function scanDirectory(options: ScanDirectoryOptions): LoadedSkill[];
+export {};

package/dist/features/skill-loader/index.d.ts

@@ -0,0 +1,7 @@
+export { loadSkills } from "./loader";
+export type { LoadSkillsOptions } from "./loader";
+export { createResolveSkillsFn, createSkillResolver, resolveMultipleSkills, resolveSkill } from "./resolver";
+export { scanDirectory, parseFrontmatter } from "./discovery";
+export { mergeSkills } from "./merger";
+export { createBuiltinSkills } from "./builtin-skills";
+export type { SkillScope, SkillMetadata, LoadedSkill, SkillDiscoveryResult } from "./types";

package/dist/features/skill-loader/loader.d.ts

@@ -0,0 +1,6 @@
+import type { SkillDiscoveryResult } from './types';
+export interface LoadSkillsOptions {
+    directory?: string;
+    disabledSkills?: string[];
+}
+export declare function loadSkills(options?: LoadSkillsOptions): SkillDiscoveryResult;

package/dist/features/skill-loader/merger.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from './types';
+export declare function mergeSkills(skills: LoadedSkill[]): LoadedSkill[];

package/dist/features/skill-loader/resolver.d.ts

@@ -0,0 +1,6 @@
+import type { SkillDiscoveryResult } from "./types";
+export declare function resolveSkill(name: string, result: SkillDiscoveryResult): string;
+export declare function resolveMultipleSkills(skillNames: string[], disabledSkills?: Set<string>, discovered?: SkillDiscoveryResult): string;
+export declare function createSkillResolver(discovered: SkillDiscoveryResult): (skillNames: string[], disabledSkills?: Set<string>) => string;
+/** @deprecated Use createSkillResolver instead */
+export declare const createResolveSkillsFn: typeof createSkillResolver;

package/dist/features/skill-loader/types.d.ts

@@ -0,0 +1,25 @@
+export type SkillScope = "builtin" | "user" | "project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    tools?: string | string[];
+    mcp?: {
+        name: string;
+        type: "stdio" | "http";
+        command?: string;
+        args?: string[];
+        url?: string;
+    };
+}
+export interface LoadedSkill {
+    name: string;
+    description: string;
+    content: string;
+    scope: SkillScope;
+    path?: string;
+    model?: string;
+}
+export interface SkillDiscoveryResult {
+    skills: LoadedSkill[];
+}

package/dist/features/work-state/constants.d.ts

@@ -0,0 +1,8 @@
+/** Root directory for Weave state and plans */
+export declare const WEAVE_DIR = ".weave";
+/** Work state file name */
+export declare const WORK_STATE_FILE = "state.json";
+/** Full relative path to work state */
+export declare const WORK_STATE_PATH = ".weave/state.json";
+/** Directory where plan files are stored */
+export declare const PLANS_DIR = ".weave/plans";

package/dist/features/work-state/index.d.ts

@@ -0,0 +1,3 @@
+export type { WorkState, PlanProgress } from "./types";
+export { WEAVE_DIR, WORK_STATE_FILE, WORK_STATE_PATH, PLANS_DIR } from "./constants";
+export { readWorkState, writeWorkState, clearWorkState, appendSessionId, createWorkState, findPlans, getPlanProgress, getPlanName, } from "./storage";

package/dist/features/work-state/storage.d.ts

@@ -0,0 +1,38 @@
+import type { WorkState, PlanProgress } from "./types";
+/**
+ * Read work state from .weave/state.json.
+ * Returns null if file is missing, unparseable, or invalid.
+ */
+export declare function readWorkState(directory: string): WorkState | null;
+/**
+ * Write work state to .weave/state.json.
+ * Creates .weave/ directory if needed.
+ */
+export declare function writeWorkState(directory: string, state: WorkState): boolean;
+/**
+ * Clear work state by deleting .weave/state.json.
+ */
+export declare function clearWorkState(directory: string): boolean;
+/**
+ * Append a session ID to the work state (if not already present).
+ * Returns the updated state, or null if no state exists.
+ */
+export declare function appendSessionId(directory: string, sessionId: string): WorkState | null;
+/**
+ * Create a fresh WorkState for a plan file.
+ */
+export declare function createWorkState(planPath: string, sessionId: string, agent?: string): WorkState;
+/**
+ * Find all plan files in .weave/plans/, sorted by modification time (newest first).
+ * Returns absolute paths.
+ */
+export declare function findPlans(directory: string): string[];
+/**
+ * Count checked and unchecked markdown checkboxes in a plan file.
+ * Returns isComplete: true if file is missing, has 0 checkboxes, or all are checked.
+ */
+export declare function getPlanProgress(planPath: string): PlanProgress;
+/**
+ * Extract plan name from file path (basename minus .md extension).
+ */
+export declare function getPlanName(planPath: string): string;

package/dist/features/work-state/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tracks the active plan being executed via /start-work.
+ * Stored at .weave/state.json in the project root.
+ */
+export interface WorkState {
+    /** Absolute path to the active plan file */
+    active_plan: string;
+    /** ISO timestamp when work started */
+    started_at: string;
+    /** Session IDs that have worked on this plan */
+    session_ids: string[];
+    /** Plan name derived from filename (without .md) */
+    plan_name: string;
+    /** Agent type to use when resuming (e.g., "tapestry") */
+    agent?: string;
+}
+/**
+ * Progress snapshot from counting checkboxes in a plan file.
+ */
+export interface PlanProgress {
+    /** Total number of checkboxes (checked + unchecked) */
+    total: number;
+    /** Number of completed checkboxes */
+    completed: number;
+    /** Whether all tasks are done (total === 0 or completed === total) */
+    isComplete: boolean;
+}

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,19 @@
+export interface ContextWindowState {
+    usedTokens: number;
+    maxTokens: number;
+    sessionId: string;
+}
+export interface ContextWindowThresholds {
+    warningPct: number;
+    criticalPct: number;
+}
+export type ContextWindowAction = "none" | "warn" | "recover";
+export interface ContextWindowCheckResult {
+    action: ContextWindowAction;
+    usagePct: number;
+    message?: string;
+}
+export declare function checkContextWindow(state: ContextWindowState, thresholds?: ContextWindowThresholds): ContextWindowCheckResult;
+export declare function createContextWindowMonitor(thresholds?: ContextWindowThresholds): {
+    check: (state: ContextWindowState) => ContextWindowCheckResult;
+};

package/dist/hooks/create-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { WeaveConfig } from "../config/schema";
+import { checkContextWindow } from "./context-window-monitor";
+import { getRulesForFile, shouldInjectRules } from "./rules-injector";
+import { shouldApplyVariant, markApplied, markSessionCreated, clearSession } from "./first-message-variant";
+import { processMessageForKeywords } from "./keyword-detector";
+import { checkPatternWrite } from "./pattern-md-only";
+import { buildVerificationReminder } from "./verification-reminder";
+export type CreatedHooks = ReturnType<typeof createHooks>;
+export declare function createHooks(args: {
+    pluginConfig: WeaveConfig;
+    isHookEnabled: (hookName: string) => boolean;
+    directory: string;
+}): {
+    checkContextWindow: ((state: Parameters<typeof checkContextWindow>[0]) => import("./context-window-monitor").ContextWindowCheckResult) | null;
+    writeGuard: {
+        trackRead: (filePath: string) => void;
+        checkWrite: (filePath: string) => import("./write-existing-file-guard").WriteGuardCheckResult;
+    } | null;
+    shouldInjectRules: typeof shouldInjectRules | null;
+    getRulesForFile: typeof getRulesForFile | null;
+    firstMessageVariant: {
+        shouldApplyVariant: typeof shouldApplyVariant;
+        markApplied: typeof markApplied;
+        markSessionCreated: typeof markSessionCreated;
+        clearSession: typeof clearSession;
+    } | null;
+    processMessageForKeywords: typeof processMessageForKeywords | null;
+    patternMdOnly: typeof checkPatternWrite | null;
+    startWork: ((promptText: string, sessionId: string) => import("./start-work-hook").StartWorkResult) | null;
+    workContinuation: ((sessionId: string) => import("./work-continuation").ContinuationResult) | null;
+    verificationReminder: typeof buildVerificationReminder | null;
+};

package/dist/hooks/first-message-variant.d.ts

@@ -0,0 +1,5 @@
+export declare function markSessionCreated(sessionId: string): void;
+export declare function markApplied(sessionId: string): void;
+export declare function shouldApplyVariant(sessionId: string): boolean;
+export declare function clearSession(sessionId: string): void;
+export declare function clearAll(): void;

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export { createHooks } from "./create-hooks";
+export type { CreatedHooks } from "./create-hooks";
+export { checkContextWindow, createContextWindowMonitor } from "./context-window-monitor";
+export type { ContextWindowState, ContextWindowThresholds, ContextWindowCheckResult, ContextWindowAction, } from "./context-window-monitor";
+export { createWriteGuard, createWriteGuardState, trackFileRead, checkWriteAllowed, } from "./write-existing-file-guard";
+export type { WriteGuardState, WriteGuardCheckResult } from "./write-existing-file-guard";
+export { shouldInjectRules, getRulesForFile, buildRulesInjection, getDirectoryFromFilePath, findRulesFile, loadRulesForDirectory, } from "./rules-injector";
+export { shouldApplyVariant, markApplied, markSessionCreated, clearSession, clearAll, } from "./first-message-variant";
+export { detectKeywords, buildKeywordInjection, processMessageForKeywords, DEFAULT_KEYWORD_ACTIONS, } from "./keyword-detector";
+export type { KeywordAction } from "./keyword-detector";
+export { buildVerificationReminder } from "./verification-reminder";
+export type { VerificationInput, VerificationResult } from "./verification-reminder";

package/dist/hooks/keyword-detector.d.ts

@@ -0,0 +1,8 @@
+export interface KeywordAction {
+    keyword: string;
+    injection: string;
+}
+export declare const DEFAULT_KEYWORD_ACTIONS: KeywordAction[];
+export declare function detectKeywords(message: string, actions?: KeywordAction[]): KeywordAction[];
+export declare function buildKeywordInjection(detected: KeywordAction[]): string | undefined;
+export declare function processMessageForKeywords(message: string, sessionId: string, actions?: KeywordAction[]): string | undefined;

package/dist/hooks/pattern-md-only.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Guard hook that prevents Pattern agent from writing non-.md files
+ * or writing outside the .weave/ directory.
+ */
+export interface PatternWriteCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Check whether a write/edit operation should be allowed for the given agent.
+ * Only blocks writes from the "pattern" agent to non-.md files or files outside .weave/.
+ */
+export declare function checkPatternWrite(agentName: string, toolName: string, filePath: string): PatternWriteCheckResult;

package/dist/hooks/rules-injector.d.ts

@@ -0,0 +1,6 @@
+export declare function findRulesFile(directory: string): string | undefined;
+export declare function loadRulesForDirectory(directory: string): string | undefined;
+export declare function shouldInjectRules(toolName: string): boolean;
+export declare function getDirectoryFromFilePath(filePath: string): string;
+export declare function buildRulesInjection(rulesContent: string, directory: string): string;
+export declare function getRulesForFile(filePath: string): string | undefined;

package/dist/hooks/start-work-hook.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Start-work hook: detects the /start-work command, resolves the target plan,
+ * creates/updates work state, and returns context for injection into the prompt.
+ */
+export interface StartWorkInput {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+}
+export interface StartWorkResult {
+    /** Context to inject into the prompt (plan path, progress, instructions) */
+    contextInjection: string | null;
+    /** Agent to switch to (always "tapestry" when command is detected) */
+    switchAgent: string | null;
+}
+/**
+ * Handle the /start-work command.
+ * Returns null contextInjection if this message is not a /start-work command.
+ */
+export declare function handleStartWork(input: StartWorkInput): StartWorkResult;

package/dist/hooks/verification-reminder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Verification reminder hook: builds a prompt that reminds the orchestrator
+ * to verify completed work, optionally delegating to Weft for review.
+ */
+export interface VerificationInput {
+    /** Name of the plan being executed, if any */
+    planName?: string;
+    /** Progress of the current plan */
+    progress?: {
+        total: number;
+        completed: number;
+    };
+}
+export interface VerificationResult {
+    /** Verification prompt to inject, or null if not applicable */
+    verificationPrompt: string | null;
+}
+/**
+ * Build a verification reminder prompt to inject after task completion.
+ * Returns a structured reminder for the orchestrator to verify work.
+ */
+export declare function buildVerificationReminder(input: VerificationInput): VerificationResult;

package/dist/hooks/work-continuation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Work continuation hook: checks if there's an active plan with remaining tasks
+ * and returns a continuation prompt to keep the executor going.
+ */
+export interface ContinuationInput {
+    sessionId: string;
+    directory: string;
+}
+export interface ContinuationResult {
+    /** Continuation prompt to inject, or null if no active work / plan complete */
+    continuationPrompt: string | null;
+}
+/**
+ * Check if there's active work that should continue.
+ * Returns a continuation prompt if the plan has remaining tasks, null otherwise.
+ */
+export declare function checkContinuation(input: ContinuationInput): ContinuationResult;

package/dist/hooks/write-existing-file-guard.d.ts

@@ -0,0 +1,14 @@
+export interface WriteGuardState {
+    readFiles: Set<string>;
+}
+export declare function createWriteGuardState(): WriteGuardState;
+export declare function trackFileRead(state: WriteGuardState, filePath: string): void;
+export interface WriteGuardCheckResult {
+    allowed: boolean;
+    warning?: string;
+}
+export declare function checkWriteAllowed(state: WriteGuardState, filePath: string): WriteGuardCheckResult;
+export declare function createWriteGuard(state: WriteGuardState): {
+    trackRead: (filePath: string) => void;
+    checkWrite: (filePath: string) => WriteGuardCheckResult;
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const WeavePlugin: Plugin;
+export default WeavePlugin;
+export type { WeaveConfig } from "./config/schema";
+export type { WeaveAgentName } from "./agents/types";