opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/hooks/nudge-loop-breaker/session-state.d.ts

@@ -0,0 +1,11 @@
+export interface NudgeLoopState {
+    count: number;
+    lastHash: string | null;
+    lastAt: number;
+    lastEmitAt: number;
+    correctiveSent: boolean;
+}
+export declare function createNudgeLoopState(): NudgeLoopState;
+export declare function computeBackoffDelay(count: number, threshold?: number): number;
+export declare function hashText(text: string): string;
+export declare function normalizeNudgeText(text: string): string;

package/dist/hooks/oracle-md-only/agent-matcher.d.ts

@@ -0,0 +1 @@
+export declare function isOracleAgent(agentName: string | undefined): boolean;

package/dist/hooks/oracle-md-only/agent-resolution.d.ts

@@ -0,0 +1,14 @@
+import type { SessionContextCarrier } from "../../shared/session-context-source";
+/**
+ * Get the effective agent for the session.
+ * Priority order:
+ * 1. In-memory session agent (most recent, set by /start-work)
+ * 2. Mission state agent (persisted across restarts, fixes #927)
+ * 3. Message files (fallback for sessions without mission state)
+ *
+ * This fixes issue #927 where after interruption:
+ * - In-memory map is cleared (process restart)
+ * - Message files return "oracle" (oldest message from /plan)
+ * - But mission.json has agent: "niobe" (set by /start-work)
+ */
+export declare function getAgentFromSession(sessionID: string, directory: string, carrier?: SessionContextCarrier): Promise<string | undefined>;

package/dist/hooks/oracle-md-only/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const HOOK_NAME = "oracle-md-only";
+export declare const ORACLE_AGENT = "oracle";
+export declare const ALLOWED_EXTENSIONS: string[];
+export declare const BLOCKED_TOOLS: string[];
+export declare const PLANNING_CONSULT_WARNING: string;
+export declare const ORACLE_WORKFLOW_REMINDER: string;

package/dist/hooks/oracle-md-only/hook.d.ts

@@ -0,0 +1,11 @@
+import type { NativePluginContext } from "../../shared/session-context-source";
+export declare function createOracleMdOnlyHook(ctx: NativePluginContext): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/oracle-md-only/path-policy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cross-platform path validator for Oracle file writes.
+ * Uses path.resolve/relative instead of string matching to handle:
+ * - Windows backslashes (e.g., .matrixx\\plans\\x.md)
+ * - Mixed separators (e.g., .matrixx\\plans/x.md)
+ * - Case-insensitive directory/extension matching
+ * - Workspace confinement (blocks paths outside root or via traversal)
+ * - Nested project paths (e.g., parent/.matrixx/... when ctx.directory is parent)
+ */
+export declare function isAllowedFile(filePath: string, workspaceRoot: string): boolean;

package/dist/hooks/plan-persister/hook.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Plan Persister Hook
+ *
+ * Continuation hook that persists active plan state (todos + metadata)
+ * to the plan file on session.idle, and builds rehydration context
+ * for injection after compaction.
+ */
+import type { PlanPersistenceOptions } from "../../features/mission-state/types";
+import type { MatrixxContext } from "../../plugin/context";
+import type { V2Event } from "../../plugin/context";
+export interface PlanPersister {
+    buildRehydrationContext: (sessionID: string) => string | null;
+    capture: (sessionID: string) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+}
+export declare function createPlanPersister(_ctx: MatrixxContext, options: PlanPersistenceOptions): PlanPersister;

package/dist/hooks/plan-persister/index.d.ts

@@ -0,0 +1,6 @@
+export type { PlanPersister } from "./hook";
+export { createPlanPersister } from "./hook";
+export type { LinkageDecision, LinkageOptions, LinkedTodos } from "./task-link";
+export { collectLinkedTodos, isTaskLinkedToMission, isTerminalTaskStatus } from "./task-link";
+export type { FilteredSyncInput, FilteredSyncResult, MatchedBox, SyncTriggerInput, SyncTriggerResult, } from "./task-sync";
+export { applyFilteredSync, maybeSyncTaskToPlans } from "./task-sync";

package/dist/hooks/plan-persister/task-link.d.ts

@@ -0,0 +1,31 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { MissionState } from "../../features/mission-state/types";
+import type { TaskObject } from "../../tools/task/types";
+export declare function isTerminalTaskStatus(status: string): boolean;
+export interface LinkageOptions {
+    directory: string;
+    sessionScoped: boolean;
+    resolveParent?: (parentID: string) => TaskObject | null;
+}
+export interface LinkageDecision {
+    linked: boolean;
+    reason: string;
+}
+export declare function isTaskLinkedToMission(task: TaskObject, mission: MissionState, opts: LinkageOptions, depth?: number, seen?: ReadonlySet<string>): LinkageDecision;
+export interface LinkedTodos {
+    todos: Array<{
+        content: string;
+        status: string;
+    }>;
+    unknown: number;
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Filtered replacement for the old unfiltered union read: strict-parse every
+ * task file (null = log + count as unknown, never a vote), drop stale files,
+ * and admit only mission-linked tasks.
+ */
+export declare function collectLinkedTodos(directory: string, mission: MissionState, config?: Partial<MatrixxConfig>): LinkedTodos;

package/dist/hooks/plan-persister/task-sync.d.ts

@@ -0,0 +1,39 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { MissionState } from "../../features/mission-state/types";
+import type { TaskObject } from "../../tools/task/types";
+import { collectLinkedTodos } from "./task-link";
+export interface FilteredSyncInput {
+    directory: string;
+    mission: MissionState;
+    planPath: string;
+    todos: Array<{
+        content: string;
+        status: string;
+    }>;
+    actorSessionId: string;
+    matchSubject?: string;
+}
+export interface MatchedBox {
+    line: string;
+    shared: number;
+    score: number;
+}
+export interface FilteredSyncResult {
+    ok: boolean;
+    skippedReason?: string;
+    total: number;
+    completed: number;
+    flaggedVerification: string[];
+    matched?: MatchedBox;
+}
+export declare function applyFilteredSync(input: FilteredSyncInput): Promise<FilteredSyncResult>;
+export interface SyncTriggerInput {
+    directory: string;
+    task: TaskObject;
+    config?: Partial<MatrixxConfig>;
+}
+export interface SyncTriggerResult extends FilteredSyncResult {
+    linked: boolean;
+}
+export declare function maybeSyncTaskToPlans(input: SyncTriggerInput): Promise<SyncTriggerResult>;
+export { collectLinkedTodos };

package/dist/hooks/post-read-injector/block.d.ts

@@ -0,0 +1 @@
+export declare function buildDirectoryContextBlock(sections: string[]): string;

package/dist/hooks/post-read-injector/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_DIRECTORY_CONTEXT_BYTES = 6144;
+export declare const DIRECTORY_CONTEXT_HEADER = "Directory Context";
+export declare const DIRECTORY_CONTEXT_SEPARATOR = "\n---\n";
+export declare function buildTruncationMarker(omittedChars: number): string;

package/dist/hooks/post-read-injector/hook.d.ts

@@ -0,0 +1,24 @@
+import type { MatrixxContext } from "../../plugin/context";
+import type { V2Event } from "../../plugin/context";
+export declare function createPostReadInjectorHook(ctx: MatrixxContext, options?: {
+    trackedTools?: string[];
+    injectorId?: string;
+}): {
+    "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: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+};

package/dist/hooks/post-read-injector/index.d.ts

@@ -0,0 +1,8 @@
+export { buildDirectoryContextBlock } from "./block";
+export { buildTruncationMarker, DIRECTORY_CONTEXT_HEADER, DIRECTORY_CONTEXT_SEPARATOR, MAX_DIRECTORY_CONTEXT_BYTES, } from "./constants";
+export { createPostReadInjectorHook } from "./hook";
+export type { UnifiedTruncator } from "./injector";
+export { createUnifiedPostReadProcessor } from "./injector";
+export type { RulesCache } from "./sections";
+export { readAgentsSection, readRuleSection } from "./sections";
+export { collectAncestorDirs } from "./unified-walk";

package/dist/hooks/post-read-injector/injector.d.ts

@@ -0,0 +1,21 @@
+import type { MatrixxContext } from "../../plugin/context";
+export type UnifiedTruncator = {
+    truncate: (sessionID: string, content: string) => Promise<{
+        result: string;
+        truncated: boolean;
+    }>;
+};
+export declare function createUnifiedPostReadProcessor(deps: {
+    workspaceDirectory: string;
+    truncator: UnifiedTruncator;
+    onVisitDir?: (dir: string) => void;
+    ctx?: MatrixxContext;
+    injectorId?: string;
+}): {
+    processFilePathForInjection: (filePath: string, sessionID: string, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    clearSessionCache: (sessionID: string) => void;
+};

package/dist/hooks/post-read-injector/sections.d.ts

@@ -0,0 +1,7 @@
+import type { UnifiedTruncator } from "./injector";
+export type RulesCache = {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function readAgentsSection(agentsPath: string, sessionID: string, truncator: UnifiedTruncator): Promise<string | null>;
+export declare function readRuleSection(candidate: string, rel: string, reason: string, sessionID: string, truncator: UnifiedTruncator, rulesCache: RulesCache): Promise<string | null>;

package/dist/hooks/post-read-injector/unified-walk.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Single upward walk from the file's directory toward the filesystem root.
+ * Visits each ancestor exactly once (leaf-first) and reports visits via onVisit.
+ * rootDir/projectRoot only document the shared prefix — the walk itself is one loop.
+ */
+export declare function collectAncestorDirs(filePath: string, rootDir?: string | ((dir: string) => void), projectRoot?: string | ((dir: string) => void) | null, onVisit?: (dir: string) => void): string[];

package/dist/hooks/quality-gate/hook.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Quality-gate hook — pure non-blocking check (D2 thin-wrapper state).
+ *
+ * D2 removed the custom format-on-write and lint runners: formatting is
+ * owned by OpenCode's native `formatter` pipeline (see
+ * `formatter-config-handler`), so this hook MUST NOT start child processes
+ * or run timers. Lint/typecheck/test verification remains a *policy*
+ * (see the `quality-gate` built-in skill), not a running task.
+ *
+ * The hook name is kept so existing `disabled_hooks: ["quality-gate"]`
+ * entries keep parsing, and the `tool.execute.before/after` keys stay
+ * registered for future pure checks.
+ */
+export declare function createQualityGateHook(): {
+    "tool.execute.before": (_input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, _output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+    "tool.execute.after": (_input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, _output: {
+        title: string;
+        output: string;
+        metadata: Record<string, unknown>;
+    }) => Promise<void>;
+};

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

@@ -0,0 +1,12 @@
+import type { MatrixxContext } from "../../plugin/context";
+export declare function createReadImageResizerHook(_ctx: MatrixxContext): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/read-image-resizer/image-dimensions.d.ts

@@ -0,0 +1,2 @@
+import type { ImageDimensions } from "./types";
+export declare function parseImageDimensions(base64DataUrl: string, mimeType: string): ImageDimensions | null;

package/dist/hooks/read-image-resizer/image-resizer.d.ts

@@ -0,0 +1,5 @@
+import type { ImageDimensions, ResizeResult } from "./types";
+export declare function calculateTargetDimensions(width: number, height: number, maxLongEdge?: number): ImageDimensions | null;
+export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions, deps?: {
+    loadSharpModule?: () => Promise<unknown | null>;
+}): Promise<ResizeResult | null>;

package/dist/hooks/read-image-resizer/png-fallback-resizer.d.ts

@@ -0,0 +1,2 @@
+import type { ImageDimensions, ResizeResult } from "./types";
+export declare function resizeImageFallback(base64DataUrl: string, mimeType: string, target: ImageDimensions): ResizeResult | null;

package/dist/hooks/read-image-resizer/types.d.ts

@@ -0,0 +1,14 @@
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export interface ImageAttachment {
+    mime: string;
+    url: string;
+    filename?: string;
+}
+export interface ResizeResult {
+    resizedDataUrl: string;
+    original: ImageDimensions;
+    resized: ImageDimensions;
+}

package/dist/hooks/rtk-bash-rewriter/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const RTK_BINARY_NAME = "rtk";
+export declare const DEFAULT_TIMEOUT_MS = 5000;
+export declare const RTK_REWRITE_COMMAND = "rewrite";

package/dist/hooks/rtk-bash-rewriter/hook.d.ts

@@ -0,0 +1,12 @@
+import type { MatrixxConfig } from "../../config";
+import type { MatrixxContext } from "../../plugin/context";
+export declare function createRtkBashRewriterHook(_ctx: MatrixxContext, config: MatrixxConfig): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/rtk-bash-rewriter/types.d.ts

@@ -0,0 +1,11 @@
+export interface RtkRewriteResult {
+    success: boolean;
+    rewrittenCommand?: string;
+    exitCode: number;
+    error?: string;
+}
+export interface RtkBinaryStatus {
+    available: boolean;
+    path: string | null;
+    checkedAt: number;
+}

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

@@ -0,0 +1,8 @@
+export type SessionInjectedRulesCache = {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function createSessionCacheStore(): {
+    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+    clearSessionCache: (sessionID: string) => void;
+};

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

@@ -0,0 +1,6 @@
+export declare const RULES_INJECTOR_STORAGE: string;
+export declare const PROJECT_MARKERS: string[];
+export declare const PROJECT_RULE_SUBDIRS: [string, string][];
+export declare const PROJECT_RULE_FILES: string[];
+export declare const GITHUB_INSTRUCTIONS_PATTERN: RegExp;
+export declare const RULE_EXTENSIONS: string[];

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

@@ -0,0 +1,3 @@
+export { findProjectRoot } from "./project-root-finder";
+export { calculateDistance } from "./rule-distance";
+export { findRuleFiles } from "./rule-file-finder";

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

@@ -0,0 +1,20 @@
+import type { MatrixxContext } from "../../plugin/context";
+export declare function createRulesInjectorHook(ctx: MatrixxContext): {
+    "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: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (event: import("../../plugin/context").V2Event) => Promise<void>;
+};

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

@@ -0,0 +1,21 @@
+import type { SessionInjectedRulesCache } from "./cache";
+type ToolExecuteOutput = {
+    title: string;
+    output: string;
+    metadata: unknown;
+};
+type DynamicTruncator = {
+    truncate: (sessionID: string, content: string) => Promise<{
+        result: string;
+        truncated: boolean;
+    }>;
+};
+export declare function _resetRuleCacheForTesting(): void;
+export declare function createRuleInjectionProcessor(deps: {
+    workspaceDirectory: string;
+    truncator: DynamicTruncator;
+    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+}): {
+    processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import type { RuleMetadata } from "./types";
+interface MatchResult {
+    applies: boolean;
+    reason?: string;
+}
+/**
+ * Check if a rule should apply to the current file based on metadata
+ */
+export declare function shouldApplyRule(metadata: RuleMetadata, currentFilePath: string, projectRoot: string | null): MatchResult;
+/**
+ * Check if realPath already exists in cache (symlink deduplication)
+ */
+export declare function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean;
+/**
+ * Create SHA-256 hash of content, truncated to 16 chars
+ */
+export declare function createContentHash(content: string): string;
+/**
+ * Check if content hash already exists in cache
+ */
+export declare function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean;
+export {};

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

@@ -0,0 +1,6 @@
+interface ToolExecuteOutputShape {
+    title: string;
+    metadata: unknown;
+}
+export declare function getRuleInjectionFilePath(output: ToolExecuteOutputShape): string | null;
+export {};

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

@@ -0,0 +1,18 @@
+import type { RuleMetadata } from "./types";
+interface RuleFrontmatterResult {
+    metadata: RuleMetadata;
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from rule file content
+ * Supports:
+ * - Single string: globs: "**\/*.py"
+ * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
+ * - Multi-line array:
+ *   globs:
+ *     - "**\/*.py"
+ *     - "src/**\/*.ts"
+ * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
+ */
+export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;
+export {};

package/dist/hooks/rules-injector/project-root-finder.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Find project root by walking up from startPath.
+ * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)
+ *
+ * @param startPath - Starting path to search from (file or directory)
+ * @returns Project root path or null if not found
+ */
+export declare function findProjectRoot(startPath: string): string | null;

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

@@ -0,0 +1,10 @@
+/**
+ * Calculate directory distance between a rule file and current file.
+ * Distance is based on common ancestor within project root.
+ *
+ * @param rulePath - Path to the rule file
+ * @param currentFile - Path to the current file being edited
+ * @param projectRoot - Project root for relative path calculation
+ * @returns Distance (0 = same directory, higher = further)
+ */
+export declare function calculateDistance(rulePath: string, currentFile: string, projectRoot: string | null): number;

package/dist/hooks/rules-injector/rule-file-finder.d.ts

@@ -0,0 +1,13 @@
+import type { RuleFileCandidate } from "./types";
+/**
+ * Find all rule files for a given context.
+ * Searches from currentFile upward to projectRoot for rule directories.
+ *
+ * IMPORTANT: This searches EVERY directory from file to project root.
+ * Not just the project root itself.
+ *
+ * @param projectRoot - Project root path (or null if outside any project)
+ * @param currentFile - Current file being edited (for distance calculation)
+ * @returns Array of rule file candidates sorted by distance
+ */
+export declare function findRuleFiles(projectRoot: string | null, currentFile: string): RuleFileCandidate[];

package/dist/hooks/rules-injector/rule-file-scanner.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Recursively find all rule files (*.md, *.mdc) in a directory
+ *
+ * @param dir - Directory to search
+ * @param results - Array to accumulate results
+ */
+export declare function findRuleFilesRecursive(dir: string, results: string[]): void;
+/**
+ * Resolve symlinks safely with fallback to original path
+ *
+ * @param filePath - Path to resolve
+ * @returns Real path or original path if resolution fails
+ */
+export declare function safeRealpathSync(filePath: string): string;

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

@@ -0,0 +1,9 @@
+export declare function loadInjectedRules(sessionID: string): {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function saveInjectedRules(sessionID: string, data: {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+}): void;
+export declare function clearInjectedRules(sessionID: string): void;

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

@@ -0,0 +1,32 @@
+/**
+ * Rule file metadata (frontmatter)
+ * Supports globs format and GitHub Copilot format (applyTo)
+ * @see https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
+ */
+export interface RuleMetadata {
+    description?: string;
+    globs?: string | string[];
+    alwaysApply?: boolean;
+}
+/**
+ * Rule file candidate with discovery context
+ */
+export interface RuleFileCandidate {
+    path: string;
+    realPath: string;
+    isGlobal: boolean;
+    distance: number;
+    /** Single-file rules (e.g., .github/copilot-instructions.md) always apply without frontmatter */
+    isSingleFile?: boolean;
+}
+/**
+ * Session storage for injected rules tracking
+ */
+export interface InjectedRulesData {
+    sessionID: string;
+    /** Content hashes of already injected rules */
+    injectedHashes: string[];
+    /** Real paths of already injected rules (for symlink deduplication) */
+    injectedRealPaths: string[];
+    updatedAt: number;
+}

package/dist/hooks/runtime-fallback/agent-resolver.d.ts

@@ -0,0 +1,4 @@
+export declare const agentPattern: RegExp;
+export declare function normalizeAgentName(agent: string | undefined): string | undefined;
+export declare function resolveAgentForSession(sessionID: string, eventAgent?: string): string | undefined;
+export declare function resolveRegisteredAgentName(agent: string | undefined): string | undefined;

package/dist/hooks/runtime-fallback/auto-retry-signal.d.ts

@@ -0,0 +1,5 @@
+interface AutoRetrySignal {
+    signal: string;
+}
+export declare function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined;
+export {};

package/dist/hooks/runtime-fallback/auto-retry.d.ts

@@ -0,0 +1,10 @@
+import type { HookDeps } from "./types";
+export declare function createAutoRetryHelpers(deps: HookDeps): {
+    abortSessionRequest: (sessionID: string, source: string) => Promise<void>;
+    clearSessionFallbackTimeout: (sessionID: string) => void;
+    scheduleSessionFallbackTimeout: (sessionID: string, resolvedAgent?: string) => void;
+    autoRetryWithFallback: (sessionID: string, newModel: string, resolvedAgent: string | undefined, source: string) => Promise<void>;
+    resolveAgentForSessionFromContext: (sessionID: string, eventAgent?: string) => Promise<string | undefined>;
+    cleanupStaleSessions: () => void;
+};
+export type AutoRetryHelpers = ReturnType<typeof createAutoRetryHelpers>;

package/dist/hooks/runtime-fallback/chat-message-handler.d.ts

@@ -0,0 +1,20 @@
+import type { HookDeps } from "./types";
+export declare function createChatMessageHandler(deps: HookDeps): (input: {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}, output: {
+    message: {
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    };
+    parts?: Array<{
+        type: string;
+        text?: string;
+    }>;
+}) => Promise<void>;

package/dist/hooks/runtime-fallback/constants.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeFallbackConfig } from "../../config";
+export declare const DEFAULT_CONFIG: Required<RuntimeFallbackConfig>;
+export declare const RETRYABLE_ERROR_PATTERNS: RegExp[];
+export declare const HOOK_NAME = "runtime-fallback";

package/dist/hooks/runtime-fallback/error-classifier.d.ts

@@ -0,0 +1,13 @@
+export { extractAutoRetrySignal } from "./auto-retry-signal";
+export declare function getErrorMessage(error: unknown): string;
+export declare function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function classifyErrorType(error: unknown): string | undefined;
+export declare function containsErrorContent(parts: Array<{
+    type?: string;
+    text?: string;
+}> | undefined): {
+    hasError: boolean;
+    errorMessage?: string;
+};
+export declare function isRetryableError(error: unknown, retryOnErrors: number[]): boolean;

package/dist/hooks/runtime-fallback/event-handler.d.ts

@@ -0,0 +1,4 @@
+import type { V2Event } from "../../plugin/context";
+import type { AutoRetryHelpers } from "./auto-retry";
+import type { HookDeps } from "./types";
+export declare function createEventHandler(deps: HookDeps, helpers: AutoRetryHelpers): (event: V2Event) => Promise<void>;