oh-my-opencode-kikokikok 2.13.0

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

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export * from "./detector";
+export * from "./constants";
+export * from "./types";
+export declare function createKeywordDetectorHook(ctx: PluginInput): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+    }, output: {
+        message: Record<string, unknown>;
+        parts: Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    }) => Promise<void>;
+};

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

@@ -0,0 +1,4 @@
+export interface KeywordDetectorState {
+    detected: boolean;
+    injected: boolean;
+}

package/dist/hooks/knowledge-monitor/conflict-handler.d.ts

@@ -0,0 +1,19 @@
+import type { KnowledgeCommit } from "../../features/knowledge-repo/types";
+import type { PendingToolCall, ViolationReport, MonitorContext } from "./types";
+export declare class ConflictHandler {
+    private detector;
+    private activeKnowledge;
+    private projectRoot;
+    constructor(projectRoot: string);
+    setActiveKnowledge(knowledge: KnowledgeCommit[]): void;
+    getActiveKnowledge(): KnowledgeCommit[];
+    checkFileWrite(filePath: string, content: string, context: MonitorContext): Promise<ViolationReport | null>;
+    checkFileEdit(filePath: string, oldString: string, newString: string, context: MonitorContext): Promise<ViolationReport | null>;
+    checkBashCommand(command: string, context: MonitorContext): Promise<ViolationReport | null>;
+    checkPendingCall(call: PendingToolCall): Promise<ViolationReport | null>;
+    private createReport;
+    private getHighestSeverity;
+    private getRelatedKnowledge;
+    private formatViolationMessage;
+    private formatSingleViolation;
+}

package/dist/hooks/knowledge-monitor/conflict-handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/knowledge-monitor/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const HOOK_NAME = "knowledge-monitor";
+export declare const MONITORED_TOOLS: readonly ["write", "edit", "multiedit", "bash"];
+export type MonitoredTool = (typeof MONITORED_TOOLS)[number];
+export declare const SEVERITY_PRIORITY: Record<string, number>;
+export declare const VIOLATION_HEADER = "[KNOWLEDGE POLICY VIOLATION DETECTED]\n\nYour action conflicts with established knowledge policies.\nReview the violations below and take appropriate action.\n\n";
+export declare const BLOCK_SUFFIX = "\nBLOCKING: This action cannot proceed until violations are resolved.\nEither fix the issue or request a policy exception from a knowledge curator.\n";
+export declare const WARN_SUFFIX = "\nWARNING: This action may proceed, but please acknowledge the policy concern.\nConsider whether your approach aligns with organizational standards.\n";
+export declare const INFO_SUFFIX = "\nINFO: For your awareness. No action required unless relevant to your task.\n";

package/dist/hooks/knowledge-monitor/index.d.ts

@@ -0,0 +1,28 @@
+import { HOOK_NAME } from "./constants";
+import type { KnowledgeMonitorConfig } from "./types";
+import type { KnowledgeCommit } from "../../features/knowledge-repo/types";
+export interface KnowledgeMonitorHook {
+    setActiveKnowledge: (knowledge: KnowledgeCommit[]) => void;
+    getActiveKnowledge: () => KnowledgeCommit[];
+    hooks: {
+        "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: unknown;
+        }) => Promise<void>;
+    };
+}
+export declare function createKnowledgeMonitorHook(projectRoot: string, config?: KnowledgeMonitorConfig): KnowledgeMonitorHook;
+export { HOOK_NAME };
+export type { KnowledgeMonitorConfig } from "./types";

package/dist/hooks/knowledge-monitor/interruption.d.ts

@@ -0,0 +1,18 @@
+import type { ConstraintViolation } from "../../features/knowledge-repo/types";
+import type { ViolationReport, InterruptionDecision } from "./types";
+export declare function decideInterruption(report: ViolationReport): InterruptionDecision;
+export declare function formatViolationSummary(violations: ConstraintViolation[]): string;
+export declare function shouldSkipTool(toolName: string, config: {
+    ignoredTools?: string[];
+}): boolean;
+export declare function extractFilePath(args: Record<string, unknown>): string | undefined;
+export declare function extractContent(args: Record<string, unknown>): string | undefined;
+export declare function extractEditParams(args: Record<string, unknown>): {
+    oldString?: string;
+    newString?: string;
+};
+export declare function extractEdits(args: Record<string, unknown>): Array<{
+    old_string: string;
+    new_string: string;
+}> | undefined;
+export declare function extractCommand(args: Record<string, unknown>): string | undefined;

package/dist/hooks/knowledge-monitor/types.d.ts

@@ -0,0 +1,41 @@
+import type { ConstraintViolation, KnowledgeCommit, Severity } from "../../features/knowledge-repo/types";
+export interface MonitorContext {
+    projectRoot: string;
+    sessionId: string;
+    toolName: string;
+    callId: string;
+}
+export interface PendingToolCall {
+    context: MonitorContext;
+    filePath?: string;
+    content?: string;
+    oldString?: string;
+    newString?: string;
+    edits?: Array<{
+        old_string: string;
+        new_string: string;
+    }>;
+    command?: string;
+    timestamp: number;
+}
+export interface ViolationReport {
+    violations: ConstraintViolation[];
+    highestSeverity: Severity;
+    message: string;
+    shouldBlock: boolean;
+    relatedKnowledge: KnowledgeCommit[];
+}
+export interface KnowledgeMonitorConfig {
+    enabled?: boolean;
+    repositoryRoot?: string;
+    checkPreTool?: boolean;
+    checkPostTool?: boolean;
+    blockOnViolation?: boolean;
+    ignorePaths?: string[];
+}
+export interface InterruptionDecision {
+    shouldInterrupt: boolean;
+    shouldBlock: boolean;
+    message: string;
+    violations: ConstraintViolation[];
+}

package/dist/hooks/non-interactive-env/constants.d.ts

@@ -0,0 +1,34 @@
+export declare const HOOK_NAME = "non-interactive-env";
+export declare const NON_INTERACTIVE_ENV: Record<string, string>;
+/**
+ * Shell command guidance for non-interactive environments.
+ * These patterns should be followed to avoid hanging on user input.
+ */
+export declare const SHELL_COMMAND_PATTERNS: {
+    readonly npm: {
+        readonly bad: readonly ["npm init", "npm install (prompts)"];
+        readonly good: readonly ["npm init -y", "npm install --yes"];
+    };
+    readonly apt: {
+        readonly bad: readonly ["apt-get install pkg"];
+        readonly good: readonly ["apt-get install -y pkg", "DEBIAN_FRONTEND=noninteractive apt-get install pkg"];
+    };
+    readonly pip: {
+        readonly bad: readonly ["pip install pkg (with prompts)"];
+        readonly good: readonly ["pip install --no-input pkg", "PIP_NO_INPUT=1 pip install pkg"];
+    };
+    readonly git: {
+        readonly bad: readonly ["git commit", "git merge branch", "git add -p", "git rebase -i"];
+        readonly good: readonly ["git commit -m 'msg'", "git merge --no-edit branch", "git add .", "git rebase --no-edit"];
+    };
+    readonly system: {
+        readonly bad: readonly ["rm file (prompts)", "cp a b (prompts)", "ssh host"];
+        readonly good: readonly ["rm -f file", "cp -f a b", "ssh -o BatchMode=yes host", "unzip -o file.zip"];
+    };
+    readonly banned: readonly ["vim", "nano", "vi", "emacs", "less", "more", "man", "python (REPL)", "node (REPL)", "git add -p", "git rebase -i"];
+    readonly workarounds: {
+        readonly yesPipe: "yes | ./script.sh";
+        readonly heredoc: "./script.sh <<EOF\noption1\noption2\nEOF";
+        readonly expectAlternative: "Use environment variables or config files instead of expect";
+    };
+};

package/dist/hooks/non-interactive-env/detector.d.ts

@@ -0,0 +1 @@
+export declare function isNonInteractive(): boolean;

package/dist/hooks/non-interactive-env/index.d.ts

@@ -0,0 +1,14 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export * from "./constants";
+export * from "./detector";
+export * from "./types";
+export declare function createNonInteractiveEnvHook(_ctx: PluginInput): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/non-interactive-env/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/non-interactive-env/types.d.ts

@@ -0,0 +1,3 @@
+export interface NonInteractiveEnvConfig {
+    disabled?: boolean;
+}

package/dist/hooks/preemptive-compaction/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_THRESHOLD = 0.85;
+export declare const MIN_TOKENS_FOR_COMPACTION = 50000;
+export declare const COMPACTION_COOLDOWN_MS = 60000;

package/dist/hooks/preemptive-compaction/index.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+export interface SummarizeContext {
+    sessionID: string;
+    providerID: string;
+    modelID: string;
+    usageRatio: number;
+    directory: string;
+}
+export type BeforeSummarizeCallback = (ctx: SummarizeContext) => Promise<void> | void;
+export type GetModelLimitCallback = (providerID: string, modelID: string) => number | undefined;
+export interface PreemptiveCompactionOptions {
+    experimental?: ExperimentalConfig;
+    onBeforeSummarize?: BeforeSummarizeCallback;
+    getModelLimit?: GetModelLimitCallback;
+}
+export declare function createPreemptiveCompactionHook(ctx: PluginInput, options?: PreemptiveCompactionOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/preemptive-compaction/types.d.ts

@@ -0,0 +1,17 @@
+export interface PreemptiveCompactionState {
+    lastCompactionTime: Map<string, number>;
+    compactionInProgress: Set<string>;
+}
+export interface TokenInfo {
+    input: number;
+    output: number;
+    reasoning: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+export interface ModelLimits {
+    context: number;
+    output: number;
+}

package/dist/hooks/ralph-loop/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HOOK_NAME = "ralph-loop";
+export declare const DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
+export declare const COMPLETION_TAG_PATTERN: RegExp;
+export declare const DEFAULT_MAX_ITERATIONS = 100;
+export declare const DEFAULT_COMPLETION_PROMISE = "DONE";

package/dist/hooks/ralph-loop/index.d.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState, RalphLoopOptions } from "./types";
+export * from "./types";
+export * from "./constants";
+export { readState, writeState, clearState, incrementIteration } from "./storage";
+export interface RalphLoopHook {
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    startLoop: (sessionID: string, prompt: string, options?: {
+        maxIterations?: number;
+        completionPromise?: string;
+    }) => boolean;
+    cancelLoop: (sessionID: string) => boolean;
+    getState: () => RalphLoopState | null;
+}
+export declare function createRalphLoopHook(ctx: PluginInput, options?: RalphLoopOptions): RalphLoopHook;

package/dist/hooks/ralph-loop/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/ralph-loop/storage.d.ts

@@ -0,0 +1,6 @@
+import type { RalphLoopState } from "./types";
+export declare function getStateFilePath(directory: string, customPath?: string): string;
+export declare function readState(directory: string, customPath?: string): RalphLoopState | null;
+export declare function writeState(directory: string, state: RalphLoopState, customPath?: string): boolean;
+export declare function clearState(directory: string, customPath?: string): boolean;
+export declare function incrementIteration(directory: string, customPath?: string): RalphLoopState | null;

package/dist/hooks/ralph-loop/types.d.ts

@@ -0,0 +1,15 @@
+import type { RalphLoopConfig } from "../../config";
+export interface RalphLoopState {
+    active: boolean;
+    iteration: number;
+    max_iterations: number;
+    completion_promise: string;
+    started_at: string;
+    prompt: string;
+    session_id?: string;
+}
+export interface RalphLoopOptions {
+    config?: RalphLoopConfig;
+    getTranscriptPath?: (sessionId: string) => string;
+    apiTimeout?: number;
+}

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

@@ -0,0 +1,8 @@
+export declare const OPENCODE_STORAGE: string;
+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 USER_RULE_DIR = ".claude/rules";
+export declare const RULE_EXTENSIONS: string[];

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

@@ -0,0 +1,33 @@
+import type { RuleFileCandidate } from "./types";
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Find all rule files for a given context.
+ * Searches from currentFile upward to projectRoot for rule directories,
+ * then user-level directory (~/.claude/rules).
+ *
+ * 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 homeDir - User home directory
+ * @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, homeDir: string, currentFile: string): RuleFileCandidate[];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}
+export declare function createRulesInjectorHook(ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import type { RuleMetadata } from "./types";
+export 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;

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

@@ -0,0 +1,18 @@
+import type { RuleMetadata } from "./types";
+export 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"
+ * - Claude Code 'paths' field (alias for globs)
+ */
+export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;

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

@@ -0,0 +1 @@
+export {};

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,54 @@
+/**
+ * Rule file metadata (Claude Code style frontmatter)
+ * Supports both Claude Code format (globs, paths) and GitHub Copilot format (applyTo)
+ * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
+ * @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 information with path context and content
+ */
+export interface RuleInfo {
+    /** Absolute path to the rule file */
+    path: string;
+    /** Path relative to project root */
+    relativePath: string;
+    /** Directory distance from target file (0 = same dir) */
+    distance: number;
+    /** Rule file content (without frontmatter) */
+    content: string;
+    /** SHA-256 hash of content for deduplication */
+    contentHash: string;
+    /** Parsed frontmatter metadata */
+    metadata: RuleMetadata;
+    /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
+    matchReason: string;
+    /** Real path after symlink resolution (for duplicate detection) */
+    realPath: string;
+}
+/**
+ * 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/session-notification-utils.d.ts

@@ -0,0 +1,9 @@
+type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function getNotifySendPath(): Promise<string | null>;
+export declare function getOsascriptPath(): Promise<string | null>;
+export declare function getPowershellPath(): Promise<string | null>;
+export declare function getAfplayPath(): Promise<string | null>;
+export declare function getPaplayPath(): Promise<string | null>;
+export declare function getAplayPath(): Promise<string | null>;
+export declare function startBackgroundCheck(platform: Platform): void;
+export {};

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

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface SessionNotificationConfig {
+    title?: string;
+    message?: string;
+    playSound?: boolean;
+    soundPath?: string;
+    /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
+    idleConfirmationDelay?: number;
+    /** Skip notification if there are incomplete todos (default: true) */
+    skipIfIncompleteTodos?: boolean;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
+}
+export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;
+export declare const THINKING_TYPES: Set<string>;
+export declare const META_TYPES: Set<string>;
+export declare const CONTENT_TYPES: Set<string>;

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

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+export interface SessionRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | null;
+interface MessageInfo {
+    id?: string;
+    role?: string;
+    sessionID?: string;
+    parentID?: string;
+    error?: unknown;
+}
+export declare function detectErrorType(error: unknown): RecoveryErrorType;
+export interface SessionRecoveryHook {
+    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
+    isRecoverableError: (error: unknown) => boolean;
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+}
+export declare function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): SessionRecoveryHook;
+export {};

package/dist/hooks/session-recovery/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+import type { StoredMessageMeta, StoredPart } from "./types";
+export declare function generatePartId(): string;
+export declare function getMessageDir(sessionID: string): string;
+export declare function readMessages(sessionID: string): StoredMessageMeta[];
+export declare function readParts(messageID: string): StoredPart[];
+export declare function hasContent(part: StoredPart): boolean;
+export declare function messageHasContent(messageID: string): boolean;
+export declare function injectTextPart(sessionID: string, messageID: string, text: string): boolean;
+export declare function findEmptyMessages(sessionID: string): string[];
+export declare function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null;
+export declare function findFirstEmptyMessage(sessionID: string): string | null;
+export declare function findMessagesWithThinkingBlocks(sessionID: string): string[];
+export declare function findMessagesWithThinkingOnly(sessionID: string): string[];
+export declare function findMessagesWithOrphanThinking(sessionID: string): string[];
+export declare function prependThinkingPart(sessionID: string, messageID: string): boolean;
+export declare function stripThinkingParts(messageID: string): boolean;
+export declare function replaceEmptyTextParts(messageID: string, replacementText: string): boolean;
+export declare function findMessagesWithEmptyTextParts(sessionID: string): string[];
+export declare function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null;