@zcy2nn/agent-forge 1.0.1

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

@@ -0,0 +1,19 @@
+import type { ApplyPatchRuntimeOptions, MatchHit, PatchChunk, ResolvedChunk } from './types';
+export declare function readFileLines(file: string): Promise<string[]>;
+export declare function resolveChunkStart(lines: string[], chunk: PatchChunk, start: number): number;
+export declare function locateChunk(lines: string[], file: string, chunk: PatchChunk, start: number, cfg: ApplyPatchRuntimeOptions): ResolvedChunk;
+export declare function applyHits(lines: string[], hits: MatchHit[], eol?: '\n' | '\r\n', hasFinalNewline?: boolean): string;
+export declare function resolveUpdateChunks(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<{
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+}>;
+export declare function deriveNewContentFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): string;
+export declare function resolveUpdateChunksFromText(file: string, text: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): {
+    lines: string[];
+    resolved: ResolvedChunk[];
+    eol: '\n' | '\r\n';
+    hasFinalNewline: boolean;
+};
+export declare function deriveNewContent(file: string, chunks: PatchChunk[], cfg: ApplyPatchRuntimeOptions): Promise<string>;

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

@@ -0,0 +1,7 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export type RewritePatchResult = {
+    patchText: string;
+    changed: boolean;
+};
+export declare function rewritePatch(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<RewritePatchResult>;
+export declare function rewritePatchText(root: string, patchText: string, cfg: ApplyPatchRuntimeOptions, worktree?: string): Promise<string>;

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

@@ -0,0 +1,6 @@
+import type { ApplyPatchRuntimeOptions } from './types';
+export declare const DEFAULT_OPTIONS: ApplyPatchRuntimeOptions;
+export declare function createTempDir(prefix?: string): Promise<string>;
+export declare function writeFixture(root: string, relativePath: string, contents: string): Promise<void>;
+export declare function readText(root: string, relativePath: string): Promise<string>;
+export declare function applyPatch(root: string, patchText: string, cfg?: ApplyPatchRuntimeOptions): Promise<void>;

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

@@ -0,0 +1,80 @@
+export type ApplyPatchRuntimeOptions = {
+    prefixSuffix: boolean;
+    lcsRescue: boolean;
+};
+export type ApplyPatchErrorKind = 'blocked' | 'validation' | 'verification' | 'internal';
+export type ApplyPatchErrorCode = 'malformed_patch' | 'outside_workspace' | 'verification_failed' | 'internal_unexpected';
+export type ApplyPatchRescueStrategy = 'prefix/suffix' | 'lcs' | 'anchor';
+export type MatchComparatorName = 'exact' | 'unicode' | 'trim-end' | 'unicode-trim-end' | 'trim' | 'unicode-trim';
+export type PatchChunk = {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+};
+export type AddPatchHunk = {
+    type: 'add';
+    path: string;
+    contents: string;
+};
+export type DeletePatchHunk = {
+    type: 'delete';
+    path: string;
+};
+export type UpdatePatchHunk = {
+    type: 'update';
+    path: string;
+    move_path?: string;
+    chunks: PatchChunk[];
+};
+export type PatchHunk = AddPatchHunk | DeletePatchHunk | UpdatePatchHunk;
+export type ParsedPatch = {
+    hunks: PatchHunk[];
+};
+export type AddPreparedChange = {
+    type: 'add';
+    file: string;
+    text: string;
+};
+export type DeletePreparedChange = {
+    type: 'delete';
+    file: string;
+};
+export type UpdatePreparedChange = {
+    type: 'update';
+    file: string;
+    move?: string;
+    text: string;
+};
+export type PreparedChange = AddPreparedChange | DeletePreparedChange | UpdatePreparedChange;
+export type MatchHit = {
+    start: number;
+    del: number;
+    add: string[];
+};
+export type SeekHit = {
+    index: number;
+    comparator: MatchComparatorName;
+    exact: boolean;
+};
+export type ResolvedChunk = {
+    hit: MatchHit;
+    old_lines: string[];
+    canonical_old_lines: string[];
+    canonical_new_lines: string[];
+    canonical_change_context?: string;
+    resolved_is_end_of_file: boolean;
+    rewritten: boolean;
+    strategy?: ApplyPatchRescueStrategy;
+    matchComparator?: MatchComparatorName;
+};
+export type RescueResult = {
+    kind: 'miss';
+} | {
+    kind: 'ambiguous';
+    phase: 'prefix_suffix' | 'lcs';
+} | {
+    kind: 'match';
+    hit: MatchHit;
+};
+export type LineComparator = (a: string, b: string) => boolean;

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -0,0 +1,11 @@
+interface AutoUpdateInstallContext {
+    installDir: string;
+    packageJsonPath: string;
+}
+export declare function resolveInstallContext(runtimePackageJsonPath?: string | null): AutoUpdateInstallContext | null;
+/**
+ * Prepares the current install root for a clean re-install of the target version.
+ * Returns the install directory to run `bun install` in.
+ */
+export declare function preparePackageUpdate(version: string, packageName?: string, runtimePackageJsonPath?: string | null): string | null;
+export {};

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -0,0 +1,32 @@
+import type { PluginEntryInfo } from './types';
+/**
+ * Extracts the update channel (latest, alpha, beta, etc.) from a version string.
+ * @param version The version or tag to analyze.
+ * @returns The channel name.
+ */
+export declare function extractChannel(version: string | null): string;
+/**
+ * Resolves the version of the plugin when running in local development mode.
+ */
+export declare function getLocalDevVersion(directory: string): string | null;
+/**
+ * Resolves the package.json for the currently running plugin bundle.
+ */
+export declare function getCurrentRuntimePackageJsonPath(currentModuleUrl?: string): string | null;
+/**
+ * Searches across all config locations to find the current installation entry for this plugin.
+ */
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+export declare function getCachedVersion(): string | null;
+/**
+ * Safely updates a pinned version in the configuration file.
+ * It attempts to replace the exact plugin string to preserve comments and formatting.
+ */
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export declare function getLatestVersion(channel?: string): Promise<string | null>;

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const PACKAGE_NAME = "@zcy2nn/agent-forge";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/@zcy2nn/agent-forge/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export declare const CACHE_DIR: string;
+/** Path to this plugin's package.json within the OpenCode cache. */
+export declare const INSTALLED_PACKAGE_JSON: string;
+/** Primary OpenCode configuration file path (standard JSON). */
+export declare const USER_OPENCODE_CONFIG: string;
+/** Alternative OpenCode configuration file path (JSON with Comments). */
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { AutoUpdateCheckerOptions } from './types';
+/**
+ * Creates an OpenCode hook that checks for plugin updates when a new session is created.
+ * @param ctx The plugin input context.
+ * @param options Configuration options for the update checker.
+ * @returns A hook object for the session.created event.
+ */
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};
+export declare function getAutoUpdateInstallDir(): string;
+export type { AutoUpdateCheckerOptions } from './types';

package/dist/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,22 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: unknown[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface AutoUpdateCheckerOptions {
+    autoUpdate?: boolean;
+}
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}

package/dist/hooks/chat-headers.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+interface ChatHeadersInput {
+    sessionID: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+interface ChatHeadersOutput {
+    headers: Record<string, string>;
+}
+export declare function __resetInternalMarkerCacheForTesting(): void;
+export declare function createChatHeadersHook(ctx: PluginInput): {
+    'chat.headers': (input: ChatHeadersInput, output: ChatHeadersOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/delegate-task-retry/guidance.d.ts

@@ -0,0 +1,2 @@
+import { type DetectedError } from './patterns';
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: {
+        tool: string;
+    }, output: {
+        output: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -0,0 +1,4 @@
+export { buildRetryGuidance } from './guidance';
+export { createDelegateTaskRetryHook } from './hook';
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError, } from './patterns';

package/dist/hooks/delegate-task-retry/patterns.d.ts

@@ -0,0 +1,11 @@
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;

package/dist/hooks/filter-available-skills/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Filter available_skills block based on the current agent's permission.skill rules.
+ * OpenCode core injects `<available_skills>` globally, so this hook rewrites that
+ * block before the prompt is sent.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import { type PluginConfig } from '../../config';
+interface MessageInfo {
+    role: string;
+    agent?: string;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+type SkillRule = 'allow' | 'ask' | 'deny';
+declare function filterAvailableSkillsText(text: string, permissionRules: Record<string, SkillRule>): string;
+/**
+ * Creates the experimental.chat.messages.transform hook for filtering available skills.
+ * This hook runs right before sending to API, so it doesn't affect UI display.
+ */
+export declare function createFilterAvailableSkillsHook(_ctx: PluginInput, config: PluginConfig): {
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export { filterAvailableSkillsText };

package/dist/hooks/foreground-fallback/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Runtime model fallback for foreground (interactive) agent sessions.
+ *
+ * When OpenCode fires a session.error, message.updated, or session.status
+ * event containing a rate-limit signal, this manager:
+ *   1. Looks up the next untried model in the agent's configured chain
+ *   2. Aborts the rate-limited prompt via client.session.abort()
+ *   3. Re-queues the last user message via client.session.promptAsync()
+ *      with the new model — promptAsync returns immediately so we never
+ *      block the event handler waiting for a full LLM response.
+ *
+ * This mirrors the same fallback loop used for delegated sessions, but operates
+ * reactively through the event system instead of wrapping prompt() in a
+ * try/catch, which is not possible for interactive (foreground) sessions.
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+type OpencodeClient = PluginInput['client'];
+export declare function isRateLimitError(error: unknown): boolean;
+/**
+ * Manages runtime model fallback for foreground agent sessions.
+ *
+ * Constructed at plugin init with the ordered fallback chains for each agent
+ * (built from _modelArray entries merged with fallback.chains config).
+ */
+export declare class ForegroundFallbackManager {
+    private readonly client;
+    /**
+     * Ordered fallback chains per agent.
+     * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
+     * The first model that hasn't been tried yet is selected on each fallback.
+     */
+    private readonly chains;
+    private readonly enabled;
+    /** sessionID → last observed model string ("providerID/modelID") */
+    private readonly sessionModel;
+    /** sessionID → agent name (populated from message.updated info.agent field) */
+    private readonly sessionAgent;
+    /** sessionID → set of models already attempted this session */
+    private readonly sessionTried;
+    /** Sessions with an active fallback switch in flight */
+    private readonly inProgress;
+    /** sessionID → timestamp of last trigger (for deduplication) */
+    private readonly lastTrigger;
+    constructor(client: OpencodeClient, 
+    /**
+     * Ordered fallback chains per agent.
+     * e.g. { orchestrator: ['anthropic/claude-opus-4-5', 'openai/gpt-4o'] }
+     * The first model that hasn't been tried yet is selected on each fallback.
+     */
+    chains: Record<string, string[]>, enabled: boolean);
+    /**
+     * Process an OpenCode plugin event.
+     * Call this from the plugin's `event` hook for every event received.
+     */
+    handleEvent(rawEvent: unknown): Promise<void>;
+    private tryFallback;
+    /**
+     * Determine the fallback chain to use for a session.
+     *
+     * Priority:
+     * 1. Agent name known AND has a configured chain → return it directly
+     * 2. Agent name known but NO chain configured → return [] (no fallback;
+     *    do NOT bleed into other agents' chains which would re-prompt the
+     *    session with a model belonging to a completely different agent)
+     * 3. Agent name unknown, current model known → search all chains for
+     *    the model to infer which chain to use
+     * 4. Nothing matches → flatten all chains as a last resort (only
+     *    reached when both agent name and current model are unavailable)
+     */
+    private resolveChain;
+}
+export {};

package/dist/hooks/image-hook.d.ts

@@ -0,0 +1,19 @@
+interface MessageWithParts {
+    info: {
+        role: string;
+        agent?: string;
+        sessionID?: string;
+    };
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+export declare function processImageAttachments(args: {
+    messages: MessageWithParts[];
+    workDir: string;
+    disabledAgents: Set<string>;
+    log: (msg: string) => void;
+}): void;
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export { createApplyPatchHook } from './apply-patch';
+export type { AutoUpdateCheckerOptions } from './auto-update-checker';
+export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createChatHeadersHook } from './chat-headers';
+export { createDelegateTaskRetryHook } from './delegate-task-retry';
+export { createFilterAvailableSkillsHook } from './filter-available-skills';
+export { ForegroundFallbackManager, isRateLimitError, } from './foreground-fallback';
+export { processImageAttachments } from './image-hook';
+export { createJsonErrorRecoveryHook } from './json-error-recovery';
+export { createPhaseReminderHook } from './phase-reminder';
+export { createPostFileToolNudgeHook } from './post-file-tool-nudge';
+export { createTaskSessionManagerHook } from './task-session-manager';
+export { createTodoContinuationHook } from './todo-continuation';

package/dist/hooks/json-error-recovery/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "webfetch", "grep_app_searchgithub", "websearch_web_search_exa"];
+export declare const JSON_ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const JSON_ERROR_REMINDER = "\n[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou sent invalid JSON arguments. The system could not parse your tool call.\nSTOP and do this NOW:\n\n1. LOOK at the error message above to see what was expected vs what you sent.\n2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).\n3. RETRY the tool call with valid JSON.\n\nDO NOT repeat the exact same invalid call.\n";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: unknown;
+    metadata: unknown;
+}
+export declare function createJsonErrorRecoveryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/json-error-recovery/index.d.ts

@@ -0,0 +1 @@
+export { createJsonErrorRecoveryHook, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER, JSON_ERROR_TOOL_EXCLUDE_LIST, } from './hook';

package/dist/hooks/phase-reminder/index.d.ts

@@ -0,0 +1,26 @@
+export declare const PHASE_REMINDER = "<internal_reminder>!IMPORTANT! Recall the workflow rules:\nUnderstand \u2192 choose the best parallelized path based on your capabilities and agents delegation rules \u2192 recall session reuse rules \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it !END!</internal_reminder>";
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for phase reminder injection.
+ * This hook runs right before sending to API, so it doesn't affect UI display.
+ * Only injects for the orchestrator agent.
+ */
+export declare function createPhaseReminderHook(): {
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/post-file-tool-nudge/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Post-tool nudge - queues a delegation reminder after file reads/writes.
+ * Catches the "inspect/edit files → implement myself" anti-pattern.
+ */
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID?: string;
+    callID?: string;
+}
+interface ToolExecuteAfterOutput {
+    output?: unknown;
+}
+interface PostFileToolNudgeOptions {
+    shouldInject?: (sessionID: string) => boolean;
+}
+export declare function createPostFileToolNudgeHook(options?: PostFileToolNudgeOptions): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/task-session-manager/index.d.ts

@@ -0,0 +1,52 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ChatMessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface ChatMessage {
+    info: {
+        role: string;
+        agent?: string;
+        sessionID?: string;
+    };
+    parts: ChatMessagePart[];
+}
+export declare function createTaskSessionManagerHook(_ctx: PluginInput, options: {
+    maxSessionsPerAgent: number;
+    readContextMinLines?: number;
+    readContextMaxFiles?: number;
+    shouldManageSession: (sessionID: string) => boolean;
+}): {
+    'tool.execute.before': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        args?: unknown;
+    }) => Promise<void>;
+    'tool.execute.after': (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        output: unknown;
+        metadata?: unknown;
+    }) => Promise<void>;
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages: ChatMessage[];
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: {
+                info?: {
+                    id?: string;
+                    parentID?: string;
+                };
+                sessionID?: string;
+            };
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/todo-continuation/index.d.ts

@@ -0,0 +1,53 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+interface MessagePart {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface ChatTransformMessage {
+    info: {
+        id?: string;
+        role?: string;
+        agent?: string;
+        sessionID?: string;
+    };
+    parts: MessagePart[];
+}
+export declare function createTodoContinuationHook(ctx: PluginInput, config?: {
+    maxContinuations?: number;
+    cooldownMs?: number;
+    autoEnable?: boolean;
+    autoEnableThreshold?: number;
+}): {
+    tool: Record<string, unknown>;
+    handleToolExecuteAfter: (input: {
+        tool: string;
+        sessionID?: string;
+    }, output?: {
+        output?: unknown;
+    }) => Promise<void>;
+    handleMessagesTransform: (output: {
+        messages: ChatTransformMessage[];
+    }) => Promise<void>;
+    handleEvent: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    handleChatMessage: (input: {
+        sessionID: string;
+        agent?: string;
+    }) => void;
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/todo-continuation/todo-hygiene.d.ts

@@ -0,0 +1,35 @@
+export declare const TODO_HYGIENE_REMINDER = "If the active task changed or finished, update the todo list to match the current work state.";
+export declare const TODO_FINAL_ACTIVE_REMINDER = "If you are finishing now, do not leave the active todo in_progress. Mark it completed, or move unfinished work back to pending.";
+interface ToolInput {
+    tool: string;
+    sessionID?: string;
+}
+interface EventInput {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+        };
+        sessionID?: string;
+    };
+}
+interface RequestStartInput {
+    sessionID: string;
+}
+interface Options {
+    getTodoState: (sessionID: string) => Promise<{
+        hasOpenTodos: boolean;
+        openCount: number;
+        inProgressCount: number;
+        pendingCount: number;
+    }>;
+    shouldInject?: (sessionID: string) => boolean;
+    log?: (message: string, meta?: Record<string, unknown>) => void;
+}
+export declare function createTodoHygiene(options: Options): {
+    handleRequestStart(input: RequestStartInput): void;
+    handleToolExecuteAfter(input: ToolInput, _output?: unknown): Promise<void>;
+    getPendingReminder(sessionID: string): string | null;
+    handleEvent(event: EventInput): void;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '@opencode-ai/plugin';
+declare const OhMyOpenCodeLite: Plugin;
+export default OhMyOpenCodeLite;
+export type { AgentName, AgentOverrideConfig, McpName, MultiplexerConfig, MultiplexerLayout, MultiplexerType, PluginConfig, TmuxConfig, TmuxLayout, } from './config';
+export type { RemoteMcpConfig } from './mcp';