@zcy2nn/agent-forge 1.0.1

package/dist/config/schema.d.ts

@@ -0,0 +1,371 @@
+import { z } from 'zod';
+declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "researcher", "reviewer", "implementer"];
+declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "researcher", "reviewer", "implementer"];
+export declare const ProviderModelIdSchema: z.ZodString;
+export declare const ManualAgentPlanSchema: z.ZodObject<{
+    primary: z.ZodString;
+    fallback1: z.ZodString;
+    fallback2: z.ZodString;
+    fallback3: z.ZodString;
+}, z.core.$strip>;
+export declare const ManualPlanSchema: z.ZodObject<{
+    orchestrator: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    researcher: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    reviewer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    implementer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ManualAgentName = (typeof MANUAL_AGENT_NAMES)[number];
+export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
+export type ManualPlan = z.infer<typeof ManualPlanSchema>;
+export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    orchestratorPrompt: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    displayName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MultiplexerTypeSchema: z.ZodEnum<{
+    auto: "auto";
+    tmux: "tmux";
+    zellij: "zellij";
+    none: "none";
+}>;
+export type MultiplexerType = z.infer<typeof MultiplexerTypeSchema>;
+export declare const MultiplexerLayoutSchema: z.ZodEnum<{
+    "main-horizontal": "main-horizontal";
+    "main-vertical": "main-vertical";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export type MultiplexerLayout = z.infer<typeof MultiplexerLayoutSchema>;
+export declare const TmuxLayoutSchema: z.ZodEnum<{
+    "main-horizontal": "main-horizontal";
+    "main-vertical": "main-vertical";
+    tiled: "tiled";
+    "even-horizontal": "even-horizontal";
+    "even-vertical": "even-vertical";
+}>;
+export type TmuxLayout = MultiplexerLayout;
+export declare const MultiplexerConfigSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        tmux: "tmux";
+        zellij: "zellij";
+        none: "none";
+    }>>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type MultiplexerConfig = z.infer<typeof MultiplexerConfigSchema>;
+export declare const TmuxConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        "main-horizontal": "main-horizontal";
+        "main-vertical": "main-vertical";
+        tiled: "tiled";
+        "even-horizontal": "even-horizontal";
+        "even-vertical": "even-vertical";
+    }>>;
+    main_pane_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+/** Normalized model entry with optional per-model variant. */
+export type ModelEntry = {
+    id: string;
+    variant?: string;
+};
+export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    orchestratorPrompt: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    displayName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export type Preset = z.infer<typeof PresetSchema>;
+export declare const WebsearchConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        exa: "exa";
+        tavily: "tavily";
+    }>>;
+}, z.core.$strip>;
+export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>;
+export declare const McpNameSchema: z.ZodEnum<{
+    websearch: "websearch";
+    context7: "context7";
+    grep_app: "grep_app";
+}>;
+export type McpName = z.infer<typeof McpNameSchema>;
+export declare const InterviewConfigSchema: z.ZodObject<{
+    maxQuestions: z.ZodDefault<z.ZodNumber>;
+    outputFolder: z.ZodDefault<z.ZodString>;
+    autoOpenBrowser: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    dashboard: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type InterviewConfig = z.infer<typeof InterviewConfigSchema>;
+export declare const SessionManagerConfigSchema: z.ZodObject<{
+    maxSessionsPerAgent: z.ZodDefault<z.ZodNumber>;
+    readContextMinLines: z.ZodDefault<z.ZodNumber>;
+    readContextMaxFiles: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SessionManagerConfig = z.infer<typeof SessionManagerConfigSchema>;
+export declare const DivoomConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    python: z.ZodDefault<z.ZodString>;
+    script: z.ZodDefault<z.ZodString>;
+    size: z.ZodDefault<z.ZodNumber>;
+    fps: z.ZodDefault<z.ZodNumber>;
+    speed: z.ZodDefault<z.ZodNumber>;
+    maxFrames: z.ZodDefault<z.ZodNumber>;
+    posterizeBits: z.ZodDefault<z.ZodNumber>;
+    gifs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type DivoomConfig = z.infer<typeof DivoomConfigSchema>;
+export declare const TodoContinuationConfigSchema: z.ZodObject<{
+    maxContinuations: z.ZodDefault<z.ZodNumber>;
+    cooldownMs: z.ZodDefault<z.ZodNumber>;
+    autoEnable: z.ZodDefault<z.ZodBoolean>;
+    autoEnableThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TodoContinuationConfig = z.infer<typeof TodoContinuationConfigSchema>;
+export declare const FailoverConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    retryDelayMs: z.ZodDefault<z.ZodNumber>;
+    chains: z.ZodDefault<z.ZodObject<{
+        orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        researcher: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        reviewer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        implementer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+    retry_on_empty: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
+export declare const PluginConfigSchema: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    setDefaultAgent: z.ZodOptional<z.ZodBoolean>;
+    scoringEngineVersion: z.ZodOptional<z.ZodEnum<{
+        v1: "v1";
+        "v2-shadow": "v2-shadow";
+        v2: "v2";
+    }>>;
+    balanceProviderUsage: z.ZodOptional<z.ZodBoolean>;
+    autoUpdate: z.ZodOptional<z.ZodBoolean>;
+    manualPlan: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        researcher: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        reviewer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        implementer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
+    presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prompt: z.ZodOptional<z.ZodString>;
+        orchestratorPrompt: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prompt: z.ZodOptional<z.ZodString>;
+        orchestratorPrompt: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    multiplexer: z.ZodOptional<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            tmux: "tmux";
+            zellij: "zellij";
+            none: "none";
+        }>>;
+        layout: z.ZodDefault<z.ZodEnum<{
+            "main-horizontal": "main-horizontal";
+            "main-vertical": "main-vertical";
+            tiled: "tiled";
+            "even-horizontal": "even-horizontal";
+            "even-vertical": "even-vertical";
+        }>>;
+        main_pane_size: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tmux: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodDefault<z.ZodEnum<{
+            "main-horizontal": "main-horizontal";
+            "main-vertical": "main-vertical";
+            tiled: "tiled";
+            "even-horizontal": "even-horizontal";
+            "even-vertical": "even-vertical";
+        }>>;
+        main_pane_size: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    websearch: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            exa: "exa";
+            tavily: "tavily";
+        }>>;
+    }, z.core.$strip>>;
+    interview: z.ZodOptional<z.ZodObject<{
+        maxQuestions: z.ZodDefault<z.ZodNumber>;
+        outputFolder: z.ZodDefault<z.ZodString>;
+        autoOpenBrowser: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        dashboard: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sessionManager: z.ZodOptional<z.ZodObject<{
+        maxSessionsPerAgent: z.ZodDefault<z.ZodNumber>;
+        readContextMinLines: z.ZodDefault<z.ZodNumber>;
+        readContextMaxFiles: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    divoom: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        python: z.ZodDefault<z.ZodString>;
+        script: z.ZodDefault<z.ZodString>;
+        size: z.ZodDefault<z.ZodNumber>;
+        fps: z.ZodDefault<z.ZodNumber>;
+        speed: z.ZodDefault<z.ZodNumber>;
+        maxFrames: z.ZodDefault<z.ZodNumber>;
+        posterizeBits: z.ZodDefault<z.ZodNumber>;
+        gifs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    todoContinuation: z.ZodOptional<z.ZodObject<{
+        maxContinuations: z.ZodDefault<z.ZodNumber>;
+        cooldownMs: z.ZodDefault<z.ZodNumber>;
+        autoEnable: z.ZodDefault<z.ZodBoolean>;
+        autoEnableThreshold: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        retryDelayMs: z.ZodDefault<z.ZodNumber>;
+        chains: z.ZodDefault<z.ZodObject<{
+            orchestrator: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            researcher: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            reviewer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            implementer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
+        retry_on_empty: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    council: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        presets: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, z.ZodTransform<Record<string, {
+            model: string;
+            variant?: string | undefined;
+            prompt?: string | undefined;
+        }>, Record<string, Record<string, unknown>>>>>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        default_preset: z.ZodDefault<z.ZodString>;
+        councillor_execution_mode: z.ZodDefault<z.ZodEnum<{
+            parallel: "parallel";
+            serial: "serial";
+        }>>;
+        councillor_retries: z.ZodDefault<z.ZodNumber>;
+        master: z.ZodOptional<z.ZodUnknown>;
+        master_timeout: z.ZodOptional<z.ZodUnknown>;
+        master_fallback: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodTransform<{
+        presets: Record<string, Record<string, {
+            model: string;
+            variant?: string | undefined;
+            prompt?: string | undefined;
+        }>>;
+        timeout: number;
+        default_preset: string;
+        councillor_execution_mode: "parallel" | "serial";
+        councillor_retries: number;
+        _deprecated: string[] | undefined;
+        _legacyMasterModel: string | undefined;
+    }, {
+        presets: Record<string, Record<string, {
+            model: string;
+            variant?: string | undefined;
+            prompt?: string | undefined;
+        }>>;
+        timeout: number;
+        default_preset: string;
+        councillor_execution_mode: "parallel" | "serial";
+        councillor_retries: number;
+        master?: unknown;
+        master_timeout?: unknown;
+        master_fallback?: unknown;
+    }>>>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+export type { AgentName } from './constants';

package/dist/config/utils.d.ts

@@ -0,0 +1,15 @@
+import type { AgentOverrideConfig, PluginConfig } from './schema';
+/**
+ * Get agent override config by name.
+ *
+ * @param config - The plugin configuration
+ * @param name - The agent name
+ * @returns The agent-specific override configuration if found
+ */
+export declare function getAgentOverride(config: PluginConfig | undefined, name: string): AgentOverrideConfig | undefined;
+/**
+ * Get custom agent names declared in config.agents.
+ *
+ * Custom agents are unknown keys that are not built-in agent names.
+ */
+export declare function getCustomAgentNames(config: PluginConfig | undefined): string[];

package/dist/council/council-manager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Council Manager
+ *
+ * Orchestrates multi-LLM council sessions: launches councillors in
+ * parallel and collects their results for the council agent to synthesize.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+import type { CouncilResult } from '../config/council-schema';
+import type { SubagentDepthTracker } from '../utils/subagent-depth';
+export declare class CouncilManager {
+    private client;
+    private directory;
+    private config?;
+    private depthTracker?;
+    private tmuxEnabled;
+    private deprecatedFields?;
+    private legacyMasterModel?;
+    constructor(ctx: PluginInput, config?: PluginConfig, depthTracker?: SubagentDepthTracker, tmuxEnabled?: boolean);
+    /** Return deprecated config fields detected during parsing (for tool warnings). */
+    getDeprecatedFields(): string[] | undefined;
+    /** Return the legacy master.model if it was used as fallback. */
+    getLegacyMasterModel(): string | undefined;
+    /**
+     * Run a full council session.
+     *
+     * 1. Look up the preset
+     * 2. Launch all councillors in parallel
+     * 3. Collect results (respecting timeout)
+     * 4. Return formatted councillor results for synthesis
+     */
+    runCouncil(prompt: string, presetName: string | undefined, parentSessionId: string): Promise<CouncilResult>;
+    /**
+     * Inject a start notification into the parent session so the user
+     * sees immediate feedback while councillors are spinning up.
+     */
+    private sendStartNotification;
+    /**
+     * Run a single agent session: create → register → prompt → extract → cleanup.
+     */
+    private runAgentSession;
+    private runCouncillors;
+    /**
+     * Run a single councillor with retry logic for empty responses.
+     * Only retries on "Empty response from provider" errors — timeouts
+     * and other failures are returned immediately.
+     */
+    private runCouncillorWithRetry;
+}

package/dist/council/index.d.ts

@@ -0,0 +1 @@
+export { CouncilManager } from './council-manager';

package/dist/divoom/manager.d.ts

@@ -0,0 +1,57 @@
+import type { DivoomConfig } from '../config';
+export type DivoomSenderCall = {
+    command: string;
+    args: string[];
+};
+export type DivoomSender = (call: DivoomSenderCall) => Promise<void> | void;
+type DivoomManagerOptions = {
+    assetDir?: string | null;
+    sender?: DivoomSender;
+};
+export declare function getDivoomOutDir(homeDir?: string): string;
+export declare class DivoomManager {
+    private sender;
+    private assetDir;
+    private config;
+    private parentStates;
+    private pendingUserInputs;
+    private orchestratorBusy;
+    private latestRequestedGifPath?;
+    private lastGifPath?;
+    private sendQueue;
+    constructor(config?: Partial<DivoomConfig>, sender?: DivoomSender, options?: DivoomManagerOptions);
+    onPluginLoad(): void;
+    onTaskStart(input: {
+        parentSessionId?: string;
+        callId?: string;
+        args?: unknown;
+    }): void;
+    onTaskEnd(input: {
+        parentSessionId?: string;
+        callId?: string;
+    }): void;
+    onUserInputRequired(input: {
+        sessionId?: string;
+        requestId?: string;
+    }): void;
+    onUserInputResolved(input: {
+        sessionId?: string;
+        requestId?: string;
+    }): void;
+    onOrchestratorStatus(input: {
+        sessionId?: string;
+        status?: string;
+        isOrchestrator?: boolean;
+    }): void;
+    onSessionDeleted(input: {
+        sessionId?: string;
+        isOrchestrator?: boolean;
+    }): void;
+    private render;
+    private getParentState;
+    private show;
+    flush(): Promise<void>;
+    private clearLatestIfCurrent;
+}
+export declare function createDivoomManager(config?: Partial<DivoomConfig>): DivoomManager;
+export {};

package/dist/hooks/apply-patch/codec.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedPatch } from './types';
+export declare function normalizeUnicode(text: string): string;
+export declare function stripHeredoc(input: string): string;
+export declare function normalizePatchText(patchText: string): string;
+export declare function parsePatch(patchText: string): ParsedPatch;
+export declare function parsePatchStrict(patchText: string): ParsedPatch;
+export declare function formatPatch(patch: ParsedPatch): string;

package/dist/hooks/apply-patch/errors.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyPatchErrorCode, ApplyPatchErrorKind } from './types';
+export declare class ApplyPatchError extends Error {
+    readonly kind: ApplyPatchErrorKind;
+    readonly code: ApplyPatchErrorCode;
+    readonly cause?: unknown;
+    constructor(kind: ApplyPatchErrorKind, code: ApplyPatchErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function getErrorMessage(error: unknown): string;
+export declare function createApplyPatchBlockedError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchValidationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchVerificationError(message: string, cause?: unknown): ApplyPatchError;
+export declare function createApplyPatchInternalError(message: string, cause?: unknown): ApplyPatchError;
+export declare function isApplyPatchError(error: unknown): error is ApplyPatchError;
+export declare function isApplyPatchBlockedError(error: unknown): boolean;
+export declare function isApplyPatchValidationError(error: unknown): boolean;
+export declare function isApplyPatchVerificationError(error: unknown): boolean;
+export declare function isApplyPatchInternalError(error: unknown): boolean;
+export declare function getApplyPatchErrorDetails(error: unknown): {
+    kind: ApplyPatchErrorKind;
+    code: ApplyPatchErrorCode;
+    message: string;
+} | undefined;
+export declare function ensureApplyPatchError(error: unknown, context: string): ApplyPatchError;

package/dist/hooks/apply-patch/execution-context.d.ts

@@ -0,0 +1,27 @@
+import { resolveUpdateChunksFromText } from './resolution';
+import type { ApplyPatchRuntimeOptions, PatchHunk, UpdatePatchHunk } from './types';
+export type PreparedFileState = {
+    exists: false;
+    derived: boolean;
+} | {
+    exists: true;
+    text: string;
+    mode?: number;
+    derived: boolean;
+};
+export type PatchExecutionContext = {
+    hunks: PatchHunk[];
+    pathsNormalized: boolean;
+    staged: Map<string, PreparedFileState>;
+    getPreparedFileState: (filePath: string, verb: 'update' | 'delete') => Promise<PreparedFileState>;
+    assertPreparedPathMissing: (filePath: string, verb: 'add' | 'move') => Promise<void>;
+};
+export type ResolvedPreparedUpdate = {
+    resolved: Awaited<ReturnType<typeof resolveUpdateChunksFromText>>['resolved'];
+    nextText: string;
+};
+export declare function isMissingPathError(error: unknown): boolean;
+export declare function parseValidatedPatch(patchText: string): PatchHunk[];
+export declare function createPatchExecutionContext(root: string, patchText: string, worktree?: string): Promise<PatchExecutionContext>;
+export declare function resolvePreparedUpdate(filePath: string, currentText: string, hunk: UpdatePatchHunk, cfg: ApplyPatchRuntimeOptions): ResolvedPreparedUpdate;
+export declare function stageAddedText(contents: string): string;

package/dist/hooks/apply-patch/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ToolExecuteBeforeInput {
+    tool: string;
+    directory?: string;
+}
+interface ToolExecuteBeforeOutput {
+    args?: {
+        patchText?: unknown;
+        [key: string]: unknown;
+    };
+}
+export declare function createApplyPatchHook(ctx: PluginInput): {
+    'tool.execute.before': (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/apply-patch/matching.d.ts

@@ -0,0 +1,26 @@
+import type { LineComparator, MatchComparatorName, RescueResult, SeekHit } from './types';
+export type PreparedAutoRescueTarget = {
+    exact: string;
+    unicode: string;
+    trimEnd: string;
+    unicodeTrimEnd: string;
+};
+export declare function equalExact(a: string, b: string): boolean;
+export declare function equalUnicodeExact(a: string, b: string): boolean;
+export declare function equalTrimEnd(a: string, b: string): boolean;
+export declare function equalUnicodeTrimEnd(a: string, b: string): boolean;
+export declare function equalTrim(a: string, b: string): boolean;
+export declare function equalUnicodeTrim(a: string, b: string): boolean;
+export declare const autoRescueComparators: LineComparator[];
+export declare function prepareAutoRescueTarget(target: string): PreparedAutoRescueTarget;
+export declare function matchPreparedAutoRescueComparator(candidate: string, target: PreparedAutoRescueTarget): MatchComparatorName | undefined;
+export declare const permissiveComparators: LineComparator[];
+export declare function seekMatch(lines: string[], pattern: string[], start: number, eof?: boolean): SeekHit | undefined;
+export declare function seek(lines: string[], pattern: string[], start: number, eof?: boolean): number;
+export declare function list(lines: string[], pattern: string[], start: number, same: LineComparator): number[];
+export declare function sameRescueLine(a: string, b: string): boolean;
+export declare function prefix(old_lines: string[], new_lines: string[]): number;
+export declare function suffix(old_lines: string[], new_lines: string[], prefixLength: number): number;
+export declare function rescueByPrefixSuffix(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;
+export declare function score(a: string[], b: string[]): number;
+export declare function rescueByLcs(lines: string[], old_lines: string[], new_lines: string[], start: number): RescueResult;

package/dist/hooks/apply-patch/operations.d.ts

@@ -0,0 +1,3 @@
+export { parseValidatedPatch } from './execution-context';
+export { applyPreparedChanges, preparePatchChanges } from './prepared-changes';
+export { rewritePatch, rewritePatchText } from './rewrite';

package/dist/hooks/apply-patch/patch.d.ts

@@ -0,0 +1,2 @@
+export { parsePatch } from './codec';
+export { preparePatchChanges, rewritePatch, rewritePatchText, } from './operations';

package/dist/hooks/apply-patch/prepared-changes.d.ts

@@ -0,0 +1,17 @@
+import type { ApplyPatchRuntimeOptions, PreparedChange } from './types';
+export declare function preparePatchChanges(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<PreparedChange[]>;
+/**
+ * Internal best-effort helper that applies the output of
+ * `preparePatchChanges()`: it snapshots all touched paths first and uses
+ * temp + rename for writes to regular files. It is not a universal multi-file
+ * transaction and is not perfect against concurrent external interference,
+ * but it avoids leaving silent partial states on normal apply failures.
+ *
+ * Contract: although it is exported for local tests/helpers, its expected
+ * input is the already prepared output of `preparePatchChanges()`. If it
+ * receives manual arrays, it revalidates the basic shape
+ * (types/text/normalized absolute paths) and filesystem invariants: it
+ * rejects updates/deletes/moves whose source does not exist, and add/move
+ * operations whose destination is already occupied.
+ */
+export declare function applyPreparedChanges(changes: PreparedChange[]): Promise<void>;