oh-my-opencode 4.7.4 → 4.8.0

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

@@ -0,0 +1 @@
+export declare function encodePng(pixels: Buffer, width: number, height: number, bitDepth: number, colorType: number, bytesPerPixel: number): Buffer;

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

@@ -0,0 +1 @@
+export declare function unfilterRow(filterType: number, currentRow: Buffer, previousRow: Buffer | null, bytesPerPixel: number): Buffer | null;

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

@@ -0,0 +1,11 @@
+export interface PngIhdr {
+    readonly width: number;
+    readonly height: number;
+    readonly bitDepth: number;
+    readonly colorType: number;
+    readonly compressionMethod: number;
+    readonly filterMethod: number;
+    readonly interlaceMethod: number;
+}
+export declare function parseIhdr(data: Buffer): PngIhdr | null;
+export declare function getBytesPerPixel(colorType: number, bitDepth: number): number | null;

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

@@ -0,0 +1 @@
+export declare function nearestNeighborResize(sourcePixels: Buffer, srcWidth: number, srcHeight: number, dstWidth: number, dstHeight: number, bytesPerPixel: number): Buffer;

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

@@ -0,0 +1,2 @@
+import type { DynamicTruncator, RuleToInject, ToolExecuteOutput } from "./injection-types";
+export declare function appendInjectedRulesToOutput(output: ToolExecuteOutput, rules: RuleToInject[], sessionID: string, truncator: DynamicTruncator): Promise<void>;

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

@@ -0,0 +1,22 @@
+import { homedir } from "node:os";
+import type { RuleFileReader, RuleInjectionProcessorDeps, RuleStatReader, ToolExecuteOutput, TranscriptHydrationHook } from "./injection-types";
+import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
+import type { FindRuleFilesOptions } from "./rule-file-finder";
+import type { RuleScanCache } from "./rule-scan-cache";
+import { saveInjectedRules } from "./storage";
+export type CreateRuleInjectionProcessorDeps = RuleInjectionProcessorDeps & {
+    getSessionRuleScanCache?: (sessionID: string) => RuleScanCache;
+    ruleFinderOptions?: FindRuleFilesOptions;
+    readFileSync?: RuleFileReader;
+    statSync?: RuleStatReader;
+    homedir?: typeof homedir;
+    shouldApplyRule?: typeof shouldApplyRule;
+    isDuplicateByRealPath?: typeof isDuplicateByRealPath;
+    createContentHash?: typeof createContentHash;
+    isDuplicateByContentHash?: typeof isDuplicateByContentHash;
+    saveInjectedRules?: typeof saveInjectedRules;
+    transcriptHydration?: TranscriptHydrationHook;
+};
+export declare function createRuleInjectionProcessor(deps: CreateRuleInjectionProcessorDeps): {
+    processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
+};

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

@@ -0,0 +1,43 @@
+import type { SessionInjectedRulesCache } from "./cache";
+import type { RuleMetadata } from "./types";
+export type ToolExecuteOutput = {
+    title: string;
+    output: string;
+    metadata: unknown;
+};
+export type RuleToInject = {
+    relativePath: string;
+    matchReason: string;
+    content: string;
+    distance: number;
+};
+export type DynamicTruncator = {
+    truncate: (sessionID: string, content: string) => Promise<{
+        result: string;
+        truncated: boolean;
+    }>;
+};
+export type RuleFileReader = (path: string, encoding: "utf-8") => string;
+export type RuleStatReader = (path: string) => {
+    readonly mtimeMs: number;
+    readonly size: number;
+};
+export interface ParsedRuleEntry {
+    mtimeMs: number;
+    size: number;
+    metadata: RuleMetadata;
+    body: string;
+}
+export type ParsedRule = {
+    metadata: RuleMetadata;
+    body: string;
+    statFingerprint: string | null;
+};
+export interface TranscriptHydrationHook {
+    hydrateSession(sessionID: string): Promise<ReadonlySet<string>>;
+}
+export type RuleInjectionProcessorDeps = {
+    workspaceDirectory: string;
+    truncator: DynamicTruncator;
+    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+};

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

@@ -1,47 +1,3 @@
-import { statSync } from "node:fs";
-import { homedir } from "node:os";
-import type { SessionInjectedRulesCache } from "./cache";
-import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
-import type { FindRuleFilesOptions } from "./rule-file-finder";
-import type { RuleScanCache } from "./rule-scan-cache";
-import { saveInjectedRules } from "./storage";
-type ToolExecuteOutput = {
-    title: string;
-    output: string;
-    metadata: unknown;
-};
-type DynamicTruncator = {
-    truncate: (sessionID: string, content: string) => Promise<{
-        result: string;
-        truncated: boolean;
-    }>;
-};
-type RuleFileReader = (path: string, encoding: "utf-8") => string;
-export interface ParsedRuleCacheStats {
-    entries: number;
-    bodyBytes: number;
-}
-export declare function clearParsedRuleCache(): void;
-export declare function getParsedRuleCacheStats(): ParsedRuleCacheStats;
-export interface TranscriptHydrationHook {
-    hydrateSession(sessionID: string): Promise<ReadonlySet<string>>;
-}
-export declare function createRuleInjectionProcessor(deps: {
-    workspaceDirectory: string;
-    truncator: DynamicTruncator;
-    getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
-    getSessionRuleScanCache?: (sessionID: string) => RuleScanCache;
-    ruleFinderOptions?: FindRuleFilesOptions;
-    readFileSync?: RuleFileReader;
-    statSync?: typeof statSync;
-    homedir?: typeof homedir;
-    shouldApplyRule?: typeof shouldApplyRule;
-    isDuplicateByRealPath?: typeof isDuplicateByRealPath;
-    createContentHash?: typeof createContentHash;
-    isDuplicateByContentHash?: typeof isDuplicateByContentHash;
-    saveInjectedRules?: typeof saveInjectedRules;
-    transcriptHydration?: TranscriptHydrationHook;
-}): {
-    processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
-};
-export {};
+export { createRuleInjectionProcessor, type CreateRuleInjectionProcessorDeps, } from "./injection-processor";
+export type { DynamicTruncator, RuleFileReader, RuleInjectionProcessorDeps, RuleToInject, ToolExecuteOutput, TranscriptHydrationHook, } from "./injection-types";
+export { clearParsedRuleCache, getParsedRuleCacheStats, type ParsedRuleCacheStats, } from "./parsed-rule-cache";

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

@@ -0,0 +1,4 @@
+export type MatchDecisionCache = Map<string, string | null>;
+export declare function createMatchDecisionCache(): MatchDecisionCache;
+export declare function getCachedMatchReason(cache: MatchDecisionCache, projectRoot: string | null, resolvedFilePath: string, realPath: string, statFingerprint: string | null): string | null | undefined;
+export declare function setCachedMatchReason(cache: MatchDecisionCache, projectRoot: string | null, resolvedFilePath: string, realPath: string, statFingerprint: string | null, matchReason: string | null): void;

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

@@ -0,0 +1,11 @@
+import type { ParsedRule, RuleFileReader, RuleStatReader } from "./injection-types";
+export interface ParsedRuleCacheStats {
+    entries: number;
+    bodyBytes: number;
+}
+export declare function clearParsedRuleCache(): void;
+export declare function getParsedRuleCacheStats(): ParsedRuleCacheStats;
+export declare function createParsedRuleReader(options?: {
+    readFileSync?: RuleFileReader;
+    statSync?: RuleStatReader;
+}): (filePath: string, realPath: string) => ParsedRule;

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

@@ -0,0 +1 @@
+export declare function resolveFilePath(workspaceDirectory: string, path: string): string | null;

package/dist/hooks/rules-injector/rule-match-reason.d.ts

@@ -0,0 +1,12 @@
+import { shouldApplyRule } from "./matcher";
+import { type MatchDecisionCache } from "./match-decision-cache";
+export declare function getRuleMatchReason(input: {
+    matchDecisionCache: MatchDecisionCache;
+    isSingleFile: boolean | undefined;
+    projectRoot: string | null;
+    resolved: string;
+    realPath: string;
+    statFingerprint: string | null;
+    metadata: Parameters<typeof shouldApplyRule>[0];
+    shouldApplyRuleImpl: typeof shouldApplyRule;
+}): string | null;

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

@@ -1,12 +1,22 @@
-import type { PluginInput } from "@opencode-ai/plugin";
 export interface TranscriptHydrationDeps {
-    readonly client: PluginInput["client"];
+    readonly client: TranscriptHydrationClient;
 }
 export interface TranscriptHydrationStore {
     hydrateSession(sessionID: string): Promise<ReadonlySet<string>>;
     getHydratedRelativePaths(sessionID: string): ReadonlySet<string>;
     clearSession(sessionID: string): void;
 }
+interface TranscriptHydrationClient {
+    readonly session: {
+        readonly messages: (args: {
+            readonly path: {
+                readonly id: string;
+            };
+        }) => Promise<{
+            readonly data?: unknown;
+        }>;
+    };
+}
 /**
  * Builds an in-memory store keyed by sessionID that lazily scans the session
  * transcript for `[Rule: <relativePath>]` markers and exposes the set of
@@ -16,3 +26,4 @@ export interface TranscriptHydrationStore {
  * does not re-inject duplicates.
  */
 export declare function createTranscriptHydrationStore(deps: TranscriptHydrationDeps): TranscriptHydrationStore;
+export {};

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

@@ -0,0 +1,2 @@
+import type { HookDeps } from "./types";
+export declare function createAbortSessionRequest(deps: HookDeps): (sessionID: string, source: string) => Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { HookDeps } from "./types";
+export declare function createAgentContextResolver(deps: HookDeps): (sessionID: string, eventAgent?: string) => Promise<string | undefined>;

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

@@ -0,0 +1,2 @@
+import type { HookDeps } from "./types";
+export declare function createStaleSessionCleanup(deps: HookDeps, clearSessionFallbackTimeout: (sessionID: string) => void): () => void;

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

@@ -0,0 +1,2 @@
+import type { HookDeps } from "./types";
+export declare function createAutoRetryDispatcher(deps: HookDeps, scheduleSessionFallbackTimeout: (sessionID: string, resolvedAgent?: string) => void, clearSessionFallbackTimeout: (sessionID: string) => void): (sessionID: string, newModel: string, resolvedAgent: string | undefined, source: string) => Promise<void>;

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

@@ -0,0 +1,9 @@
+export type RetryPromptPart = {
+    type: "text";
+    text: string;
+    id?: string;
+};
+export declare function resolveOriginalUserRetryMetadata(messagesResponse: unknown): {
+    messageID?: string;
+    parts: RetryPromptPart[];
+};

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

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

package/dist/hooks/runtime-fallback/fallback-bootstrap-model.d.ts

@@ -2,7 +2,7 @@ import type { OhMyOpenCodeConfig } from "../../config";
 type ResolveFallbackBootstrapModelOptions = {
     sessionID: string;
     source: string;
-    eventModel?: string;
+    eventModel?: unknown;
     resolvedAgent?: string;
     pluginConfig?: OhMyOpenCodeConfig;
 };

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

@@ -1,6 +1,9 @@
 import type { FallbackState, FallbackResult } from "./types";
 import type { RuntimeFallbackConfig } from "../../config";
-export declare function createFallbackState(originalModel: string): FallbackState;
+export declare function stringifyRuntimeModel(model: unknown): string | undefined;
+export declare function stringifyRuntimeModelWithVariant(model: unknown, variant: unknown): string | undefined;
+export declare function areRuntimeModelsEquivalent(candidate: string | undefined, current: string | undefined): boolean;
+export declare function createFallbackState(originalModel: unknown): FallbackState;
 export declare function isModelInCooldown(model: string, state: FallbackState, cooldownSeconds: number): boolean;
 export declare function findNextAvailableFallback(state: FallbackState, fallbackModels: string[], cooldownSeconds: number): string | undefined;
 export declare function prepareFallback(sessionID: string, state: FallbackState, fallbackModels: string[], config: Required<RuntimeFallbackConfig>): FallbackResult;

package/dist/hooks/runtime-fallback/normalize-model.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Normalize a session model value into a canonical "<providerID>/<id>" string.
+ *
+ * Since opencode 1.15.x the `session.created` event payload exposes
+ * `info.model` as an object (`{ id, providerID, variant }`) rather than a
+ * plain string. Downstream fallback state treats the model as a string and
+ * calls `.toLowerCase()` on it, so an object value crashes the hook. This
+ * helper collapses both the legacy string form and the object form to a
+ * single canonical string at the hook boundary. Returns undefined when no
+ * usable provider/model pair can be derived.
+ */
+export declare function normalizeModelToCanonicalString(model: unknown): string | undefined;

package/dist/hooks/session-notification-linux.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function sendLinuxSessionNotification(ctx: PluginInput, title: string, message: string): Promise<void>;
+export declare function playLinuxSessionNotificationSound(ctx: PluginInput, soundPath: string): Promise<void>;

package/dist/hooks/session-notification-log.d.ts

@@ -0,0 +1,2 @@
+export declare function logCommandFailure(commandName: string, error: Error | string): void;
+export declare function logOperationFailure(operation: string, error: Error | string): void;

package/dist/hooks/session-notification-macos.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function sendMacosSessionNotification(ctx: PluginInput, title: string, message: string): Promise<void>;
+export declare function playMacosSessionNotificationSound(ctx: PluginInput, soundPath: string): Promise<void>;

package/dist/hooks/session-notification-platform.d.ts

@@ -0,0 +1,3 @@
+export type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function detectPlatform(): Platform;
+export declare function getDefaultSoundPath(platform: Platform): string;

package/dist/hooks/session-notification-runner.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type ShellCommand = Promise<unknown> & {
+    quiet?: () => Promise<unknown>;
+    nothrow?: () => ShellCommand;
+};
+type ShellRunner = NonNullable<PluginInput["$"]>;
+type ShellFailureMode = "throw" | "nothrow";
+export declare function runNotificationCommand(ctx: PluginInput, commandPath: string, args: readonly string[], shellCommand: (shell: ShellRunner) => ShellCommand, shellFailureMode?: ShellFailureMode): Promise<void>;
+export {};

package/dist/hooks/session-notification-send.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Platform } from "./session-notification-platform";
+export declare function sendSessionNotification(ctx: PluginInput, platform: Platform, title: string, message: string): Promise<void>;

package/dist/hooks/session-notification-sender.d.ts

@@ -1,6 +1,5 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export type Platform = "darwin" | "linux" | "win32" | "unsupported";
-export declare function detectPlatform(): Platform;
-export declare function getDefaultSoundPath(platform: Platform): string;
-export declare function sendSessionNotification(ctx: PluginInput, platform: Platform, title: string, message: string): Promise<void>;
-export declare function playSessionNotificationSound(ctx: PluginInput, platform: Platform, soundPath: string): Promise<void>;
+import { type Platform, detectPlatform, getDefaultSoundPath } from "./session-notification-platform";
+import { playSessionNotificationSound } from "./session-notification-sound";
+import { sendSessionNotification } from "./session-notification-send";
+export { type Platform, detectPlatform, getDefaultSoundPath };
+export { sendSessionNotification, playSessionNotificationSound };

package/dist/hooks/session-notification-sound.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Platform } from "./session-notification-platform";
+export declare function playSessionNotificationSound(ctx: PluginInput, platform: Platform, soundPath: string): Promise<void>;

package/dist/hooks/session-notification-windows.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function sendWindowsSessionNotification(ctx: PluginInput, title: string, message: string): Promise<void>;
+export declare function playWindowsSessionNotificationSound(ctx: PluginInput, soundPath: string): Promise<void>;

package/dist/hooks/session-recovery/error-recovery.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+import type { MessageInfo, SessionRecoveryCallbacks } from "./hook-types";
+export declare function createSessionErrorRecoveryHandler(ctx: PluginInput, callbacks: SessionRecoveryCallbacks, experimental?: ExperimentalConfig): (info: MessageInfo) => Promise<boolean>;

package/dist/hooks/session-recovery/hook-types.d.ts

@@ -0,0 +1,22 @@
+import type { ExperimentalConfig } from "../../config";
+export interface MessageInfo {
+    id?: string;
+    role?: string;
+    sessionID?: string;
+    parentID?: string;
+    error?: unknown;
+}
+export interface SessionRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+export interface SessionRecoveryHook {
+    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
+    handleInterruptedToolResultsOnIdle: (sessionID: string) => Promise<boolean>;
+    isRecoverableError: (error: unknown) => boolean;
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+}
+export interface SessionRecoveryCallbacks {
+    onAbortCallback: ((sessionID: string) => void) | null;
+    onRecoveryCompleteCallback: ((sessionID: string) => void) | null;
+}

package/dist/hooks/session-recovery/hook.d.ts

@@ -1,21 +1,4 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { ExperimentalConfig } from "../../config";
-interface MessageInfo {
-    id?: string;
-    role?: string;
-    sessionID?: string;
-    parentID?: string;
-    error?: unknown;
-}
-export interface SessionRecoveryOptions {
-    experimental?: ExperimentalConfig;
-}
-export interface SessionRecoveryHook {
-    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
-    handleInterruptedToolResultsOnIdle: (sessionID: string) => Promise<boolean>;
-    isRecoverableError: (error: unknown) => boolean;
-    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
-    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
-}
+import type { SessionRecoveryHook, SessionRecoveryOptions } from "./hook-types";
+export type { MessageInfo, SessionRecoveryHook, SessionRecoveryOptions } from "./hook-types";
 export declare function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): SessionRecoveryHook;
-export {};

package/dist/hooks/session-recovery/interrupted-tool-results.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { SessionRecoveryCallbacks } from "./hook-types";
+export declare function createInterruptedToolResultsHandler(ctx: PluginInput, callbacks: SessionRecoveryCallbacks): (sessionID: string) => Promise<boolean>;

package/dist/hooks/session-recovery/message-state.d.ts

@@ -0,0 +1,4 @@
+import type { MessageData } from "./types";
+export declare function assistantMessageIsFinished(message: MessageData): boolean;
+export declare function messageHasInterruptedToolResults(message: MessageData): boolean;
+export declare function findLatestAssistantMessage(messages: MessageData[]): MessageData | undefined;

package/dist/hooks/session-recovery/storage/thinking-strip.d.ts

@@ -1,5 +1,11 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { log, isSqliteBackend } from "../../../shared";
 type OpencodeClient = PluginInput["client"];
-export declare function stripThinkingParts(messageID: string): boolean;
+type StripThinkingPartsDeps = {
+    readonly isSqliteBackend: typeof isSqliteBackend;
+    readonly log: typeof log;
+    readonly partStorage: string;
+};
+export declare function stripThinkingParts(messageID: string, deps?: StripThinkingPartsDeps): boolean;
 export declare function stripThinkingPartsAsync(client: OpencodeClient, sessionID: string, messageID: string): Promise<boolean>;
 export {};

package/dist/hooks/start-work/context-info-builder.d.ts

@@ -1,13 +1,13 @@
 import { readBoulderState } from "../../features/boulder-state";
 import type { PluginInput } from "@opencode-ai/plugin";
 export declare function buildStartWorkContextInfo(params: {
-    ctx: PluginInput;
-    explicitPlanName: string | null;
-    existingState: ReturnType<typeof readBoulderState>;
-    sessionId: string;
-    timestamp: string;
-    activeAgent: string;
-    worktreePath: string | undefined;
-    worktreeBlock: string;
-    preferredPlanPath?: string | null;
+    readonly ctx: PluginInput;
+    readonly explicitPlanName: string | null;
+    readonly existingState: ReturnType<typeof readBoulderState>;
+    readonly sessionId: string;
+    readonly timestamp: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+    readonly worktreeBlock: string;
+    readonly preferredPlanPath?: string | null;
 }): string;

package/dist/hooks/start-work/context-info-formatters.d.ts

@@ -0,0 +1,21 @@
+import type { BoulderState, BoulderWorkResumeOption } from "../../features/boulder-state";
+export declare function buildAutoSelectedPlanContextInfoOnly(params: {
+    readonly planPath: string;
+    readonly sessionId: string;
+    readonly timestamp: string;
+    readonly worktreeBlock: string;
+    readonly reason?: string;
+}): string;
+export declare function buildMultipleActiveWorksContext(params: {
+    readonly resumeOptions: readonly BoulderWorkResumeOption[];
+    readonly sessionId: string;
+    readonly timestamp: string;
+}): string;
+export declare function buildExistingSessionContext(params: {
+    readonly existingState: BoulderState;
+    readonly sessionId: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+    readonly worktreeBlock: string;
+    readonly directory: string;
+}): string;

package/dist/hooks/start-work/explicit-plan-context.d.ts

@@ -0,0 +1,9 @@
+export declare function buildExplicitPlanContext(params: {
+    readonly explicitPlanName: string;
+    readonly sessionId: string;
+    readonly timestamp: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+    readonly worktreeBlock: string;
+    readonly directory: string;
+}): string;

package/dist/hooks/start-work/plan-discovery-context.d.ts

@@ -0,0 +1,25 @@
+import type { BoulderState, BoulderWorkResumeOption } from "../../features/boulder-state";
+export declare function shouldResumeExistingState(input: {
+    readonly existingState: BoulderState | null;
+    readonly preferredPlanPath: string | null;
+}): boolean;
+export declare function shouldDiscoverPlans(input: {
+    readonly existingState: BoulderState | null;
+    readonly explicitPlanName: string | null;
+    readonly preferredPlanPath: string | null;
+}): boolean;
+export declare function shouldResumeSingleWorkOption(input: {
+    readonly directory: string;
+    readonly option: BoulderWorkResumeOption;
+    readonly preferredPlanPath: string | null;
+}): boolean;
+export declare function buildPlanDiscoveryContext(params: {
+    readonly contextInfo: string;
+    readonly sessionId: string;
+    readonly timestamp: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+    readonly worktreeBlock: string;
+    readonly directory: string;
+    readonly preferredPlanPath: string | null;
+}): string;

package/dist/hooks/start-work/plan-selection.d.ts

@@ -0,0 +1,4 @@
+export declare function findPlanByName(plans: readonly string[], requestedName: string): string | null;
+export declare function pickPreferredIncompletePlan(incompletePlans: readonly string[], preferredPlanPath: string | null): string | null;
+export declare function formatIncompletePlanList(plans: readonly string[], includeModifiedTime: boolean): string;
+export declare function buildMissingPlanContext(explicitPlanName: string, allPlans: readonly string[]): string;

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

@@ -0,0 +1,17 @@
+export declare function createNewWorkOrInitialize(params: {
+    readonly directory: string;
+    readonly planPath: string;
+    readonly sessionId: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+}): void;
+export declare function buildAutoSelectedPlanContextWithStateInit(params: {
+    readonly planPath: string;
+    readonly sessionId: string;
+    readonly timestamp: string;
+    readonly activeAgent: string;
+    readonly worktreePath: string | undefined;
+    readonly worktreeBlock: string;
+    readonly directory: string;
+    readonly reason?: string;
+}): string;

package/dist/hooks/tool-pair-validator/hook.d.ts

@@ -1,38 +1,2 @@
-import type { Message, Part } from "@opencode-ai/sdk";
-type ToolUsePart = {
-    type: "tool_use";
-    id: string;
-    [key: string]: unknown;
-};
-type ToolResultPart = {
-    type: "tool_result";
-    toolUseId: string;
-    tool_use_id?: string;
-    isError?: boolean;
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    [key: string]: unknown;
-};
-type TextPart = {
-    type: "text";
-    text: string;
-    synthetic: true;
-};
-type TransformPart = Part | ToolUsePart | ToolResultPart | TextPart;
-type TransformMessageInfo = Message | {
-    role: "user";
-    sessionID?: string;
-};
-interface MessageWithParts {
-    info: TransformMessageInfo;
-    parts: TransformPart[];
-}
-type MessagesTransformHook = {
-    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
-        messages: MessageWithParts[];
-    }) => Promise<void>;
-};
+import type { MessagesTransformHook } from "./types";
 export declare function createToolPairValidatorHook(): MessagesTransformHook;
-export {};

package/dist/hooks/tool-pair-validator/message-transform.d.ts

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

package/dist/hooks/tool-pair-validator/tool-part-ids.d.ts

@@ -0,0 +1,6 @@
+import type { TransformPart } from "./types";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function getToolUseID(part: TransformPart): string | null;
+export declare function getToolResultID(part: TransformPart): string | null;
+export declare function extractUniqueToolUseIDs(parts: TransformPart[]): string[];
+export declare function extractToolResultIDs(parts: TransformPart[]): Set<string>;

package/dist/hooks/tool-pair-validator/tool-result-repair.d.ts

@@ -0,0 +1,4 @@
+import type { MessageWithParts, TransformMessageInfo } from "./types";
+export declare function getMessageSessionID(message: TransformMessageInfo): string | undefined;
+export declare function repairSubAgentMissingToolResults(messages: MessageWithParts[], assistantIndex: number, sessionID: string): void;
+export declare function repairMissingToolResults(messages: MessageWithParts[], assistantIndex: number): void;

package/dist/hooks/tool-pair-validator/types.d.ts

@@ -0,0 +1,36 @@
+import type { Message, Part } from "@opencode-ai/sdk";
+export type ToolUsePart = {
+    type: "tool_use";
+    id: string;
+    [key: string]: unknown;
+};
+export type ToolResultPart = {
+    type: "tool_result";
+    toolUseId: string;
+    tool_use_id?: string;
+    isError?: boolean;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    [key: string]: unknown;
+};
+export type TextPart = {
+    type: "text";
+    text: string;
+    synthetic: true;
+};
+export type TransformPart = Part | ToolUsePart | ToolResultPart | TextPart;
+export type TransformMessageInfo = Message | {
+    role: "user";
+    sessionID?: string;
+};
+export interface MessageWithParts {
+    info: TransformMessageInfo;
+    parts: TransformPart[];
+}
+export type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};