oh-my-claudecode-opencode 0.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,179 @@
+import { z } from "zod";
+declare const AgentConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        haiku: "haiku";
+        sonnet: "sonnet";
+        opus: "opus";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    disable: z.ZodOptional<z.ZodBoolean>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ModelMappingConfigSchema: z.ZodObject<{
+    tierDefaults: z.ZodOptional<z.ZodObject<{
+        haiku: z.ZodOptional<z.ZodString>;
+        sonnet: z.ZodOptional<z.ZodString>;
+        opus: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    debugLogging: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const BackgroundTaskConfigSchema: z.ZodObject<{
+    defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+    providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+declare const RalphLoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    default_max_iterations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const AutopilotConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    maxPhaseRetries: z.ZodOptional<z.ZodNumber>;
+    delegationEnforcement: z.ZodOptional<z.ZodEnum<{
+        strict: "strict";
+        warn: "warn";
+        off: "off";
+    }>>;
+}, z.core.$strip>;
+declare const UltraQAConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    buildCommand: z.ZodOptional<z.ZodString>;
+    testCommand: z.ZodOptional<z.ZodString>;
+    lintCommand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ScientistConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    replFallback: z.ZodOptional<z.ZodEnum<{
+        bash: "bash";
+        disabled: "disabled";
+    }>>;
+}, z.core.$strip>;
+declare const OrchestratorConfigSchema: z.ZodObject<{
+    delegationEnforcement: z.ZodOptional<z.ZodEnum<{
+        strict: "strict";
+        warn: "warn";
+        off: "off";
+    }>>;
+    auditLogEnabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ContextRecoveryConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const EditErrorRecoveryConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    showToasts: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const TuiStatusConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    showAgentNotifications: z.ZodOptional<z.ZodBoolean>;
+    showModeChanges: z.ZodOptional<z.ZodBoolean>;
+    toastDuration: z.ZodOptional<z.ZodNumber>;
+    trackMetrics: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TuiStatusConfig = z.infer<typeof TuiStatusConfigSchema>;
+declare const OmoOmcsConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodEnum<{
+            haiku: "haiku";
+            sonnet: "sonnet";
+            opus: "opus";
+        }>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        disable: z.ZodOptional<z.ZodBoolean>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    model_mapping: z.ZodOptional<z.ZodObject<{
+        tierDefaults: z.ZodOptional<z.ZodObject<{
+            haiku: z.ZodOptional<z.ZodString>;
+            sonnet: z.ZodOptional<z.ZodString>;
+            opus: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        debugLogging: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    background_task: z.ZodOptional<z.ZodObject<{
+        defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+        providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+    ralph_loop: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        default_max_iterations: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    autopilot: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        maxPhaseRetries: z.ZodOptional<z.ZodNumber>;
+        delegationEnforcement: z.ZodOptional<z.ZodEnum<{
+            strict: "strict";
+            warn: "warn";
+            off: "off";
+        }>>;
+    }, z.core.$strip>>;
+    ultraqa: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        buildCommand: z.ZodOptional<z.ZodString>;
+        testCommand: z.ZodOptional<z.ZodString>;
+        lintCommand: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    scientist: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        replFallback: z.ZodOptional<z.ZodEnum<{
+            bash: "bash";
+            disabled: "disabled";
+        }>>;
+    }, z.core.$strip>>;
+    orchestrator: z.ZodOptional<z.ZodObject<{
+        delegationEnforcement: z.ZodOptional<z.ZodEnum<{
+            strict: "strict";
+            warn: "warn";
+            off: "off";
+        }>>;
+        auditLogEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    context_recovery: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    edit_error_recovery: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        showToasts: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    tui_status: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        showAgentNotifications: z.ZodOptional<z.ZodBoolean>;
+        showModeChanges: z.ZodOptional<z.ZodBoolean>;
+        toastDuration: z.ZodOptional<z.ZodNumber>;
+        trackMetrics: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sisyphus_agent: z.ZodOptional<z.ZodObject<{
+        disabled: z.ZodOptional<z.ZodBoolean>;
+        planner_enabled: z.ZodOptional<z.ZodBoolean>;
+        replace_plan: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OmoOmcsConfig = z.infer<typeof OmoOmcsConfigSchema>;
+export type AgentConfig = z.infer<typeof AgentConfigSchema>;
+export type ModelMappingConfig = z.infer<typeof ModelMappingConfigSchema>;
+export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;
+export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;
+export type AutopilotConfig = z.infer<typeof AutopilotConfigSchema>;
+export type UltraQAConfig = z.infer<typeof UltraQAConfigSchema>;
+export type ScientistConfig = z.infer<typeof ScientistConfigSchema>;
+export type OrchestratorConfig = z.infer<typeof OrchestratorConfigSchema>;
+export type ContextRecoveryConfig = z.infer<typeof ContextRecoveryConfigSchema>;
+export type EditErrorRecoveryConfig = z.infer<typeof EditErrorRecoveryConfigSchema>;
+export type HookName = "todo-continuation-enforcer" | "keyword-detector" | "ralph-loop" | "session-recovery" | "agent-usage-reminder" | "context-window-monitor" | "comment-checker" | "tool-output-truncator" | "system-prompt-injector" | "persistent-mode" | "remember-tag-processor" | "autopilot" | "ultraqa-loop" | "context-recovery" | "edit-error-recovery" | "omc-orchestrator";
+export type AgentName = "oracle" | "librarian" | "explore" | "frontend-ui-ux-engineer" | "document-writer" | "multimodal-looker";
+export declare function loadConfig(directory: string): OmoOmcsConfig;
+export {};

package/dist/config/model-resolver.d.ts

@@ -0,0 +1,46 @@
+export type ModelTier = "haiku" | "sonnet" | "opus";
+export type ConcreteModel = string;
+export interface TierModelMapping {
+    haiku: ConcreteModel;
+    sonnet: ConcreteModel;
+    opus: ConcreteModel;
+}
+export interface ModelMappingConfig {
+    tierDefaults?: Partial<TierModelMapping>;
+    debugLogging?: boolean;
+}
+export interface AgentModelConfig {
+    model?: ConcreteModel;
+    tier?: ModelTier;
+    temperature?: number;
+    top_p?: number;
+    disable?: boolean;
+    prompt_append?: string;
+}
+export interface ModelResolutionResult {
+    model: ConcreteModel;
+    source: "per-agent-override" | "tier-default" | "hardcoded-fallback";
+    originalTier?: ModelTier;
+}
+export declare const HARDCODED_TIER_DEFAULTS: TierModelMapping;
+/**
+ * Check if model follows "provider/model-name" pattern
+ */
+export declare function isValidModelFormat(model: string): boolean;
+/**
+ * Log warning if invalid format
+ */
+export declare function validateModelFormat(model: string, context: string): void;
+export declare class ModelResolver {
+    private tierDefaults;
+    private debugLogging;
+    constructor(config?: ModelMappingConfig);
+    /**
+     * Resolve model for an agent based on priority chain
+     */
+    resolve(agentName: string, agentDefinitionTier: ModelTier | undefined, agentOverride?: AgentModelConfig): ModelResolutionResult;
+    /**
+     * Get current tier defaults
+     */
+    getTierDefaults(): TierModelMapping;
+}

package/dist/hooks/agent-usage-reminder.d.ts

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

package/dist/hooks/autopilot.d.ts

@@ -0,0 +1,32 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { type AutopilotState } from "../state/autopilot-state";
+export interface AutopilotHookOptions {
+    config?: {
+        enabled?: boolean;
+        maxPhaseRetries?: number;
+        delegationEnforcement?: 'strict' | 'warn' | 'off';
+    };
+    onPhaseChange?: (sessionId: string, phase: AutopilotState['phase']) => void;
+}
+export declare function createAutopilotHook(ctx: PluginInput, options?: AutopilotHookOptions): {
+    startAutopilot: (sessionId: string, task?: string) => void;
+    cancelAutopilot: (sessionId: string) => void;
+    getState: (sessionId: string) => AutopilotState | undefined;
+    isActive: (sessionId: string) => boolean;
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+    }, output: {
+        message: unknown;
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/context-recovery.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface ContextRecoveryOptions {
+    enabled?: boolean;
+}
+export declare function createContextRecoveryHook(_ctx: PluginInput, options?: ContextRecoveryOptions): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }) => Promise<void>;
+};

package/dist/hooks/continuation-messages.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Continuation message variants to prevent pattern fatigue
+ * and provide contextual reminders
+ */
+export interface ContinuationContext {
+    completedCount: number;
+    totalCount: number;
+    nextTask?: string;
+    iteration?: number;
+    maxIterations?: number;
+    mode?: "todo" | "ralph-loop" | "ultrawork-ralph";
+}
+/**
+ * Get a contextual continuation message
+ */
+export declare function getContinuationMessage(context: ContinuationContext): string;
+/**
+ * Get a progress summary message
+ */
+export declare function getProgressSummary(context: ContinuationContext): string;
+/**
+ * Get a short toast message
+ */
+export declare function getToastMessage(context: ContinuationContext): string;

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

@@ -0,0 +1,33 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface EditErrorRecoveryOptions {
+    enabled?: boolean;
+    maxRetries?: number;
+    showToasts?: boolean;
+}
+type ErrorType = "string_not_found" | "file_not_found" | "permission_denied" | "timeout" | "rate_limit" | "connection_error" | "unknown";
+interface ErrorState {
+    tool: string;
+    consecutiveErrors: number;
+    lastErrorFile?: string;
+    lastErrorType: ErrorType;
+    lastErrorTime: number;
+    retryCount: number;
+}
+export declare function createEditErrorRecoveryHook(ctx: PluginInput, options?: EditErrorRecoveryOptions): {
+    getErrorStats: (sessionId: string) => {
+        totalErrors: number;
+        errorsByType: Record<string, number>;
+        recentErrors: ErrorState[];
+    };
+    clearErrorState: (sessionId: string, key?: string) => void;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,23 @@
+export { createTodoContinuationEnforcer } from "./todo-continuation-enforcer";
+export { createKeywordDetectorHook } from "./keyword-detector";
+export { createRalphLoopHook } from "./ralph-loop";
+export { createSessionRecoveryHook } from "./session-recovery";
+export { createAgentUsageReminderHook } from "./agent-usage-reminder";
+export { createSystemPromptInjector } from "./system-prompt-injector";
+export { createRalphVerifierHook } from "./ralph-verifier";
+export { getContinuationMessage, getProgressSummary, getToastMessage } from "./continuation-messages";
+export type { ContinuationContext } from "./continuation-messages";
+export type { ActiveMode } from "./system-prompt-injector";
+export type { PRD, UserStory } from "./ralph-loop";
+export { createSkillInjector } from "./skill-injector";
+export type { SkillInjection } from "./skill-injector";
+export { initNotepad, readNotepad, getNotepadPath, getPriorityContext, getWorkingMemory, getManualSection, setPriorityContext, addWorkingMemoryEntry, addManualEntry, pruneOldEntries, getNotepadStats, formatNotepadContext, formatFullNotepad, processRememberTags, NOTEPAD_FILENAME, PRIORITY_HEADER, WORKING_MEMORY_HEADER, MANUAL_HEADER, DEFAULT_CONFIG as NOTEPAD_DEFAULT_CONFIG, } from "./notepad";
+export type { NotepadConfig, NotepadStats, PriorityContextResult, PruneResult, } from "./notepad";
+export { createPersistentModeHook, checkPersistentModes, resetTodoContinuationAttempts, } from "./persistent-mode";
+export type { PersistentModeResult, PersistentModeOptions, } from "./persistent-mode";
+export { createRememberTagProcessor, extractRememberTags, formatRememberTag, } from "./remember-tag-processor";
+export type { RememberTagProcessorOptions } from "./remember-tag-processor";
+export { createContextRecoveryHook, type ContextRecoveryOptions } from "./context-recovery";
+export { createEditErrorRecoveryHook, type EditErrorRecoveryOptions } from "./edit-error-recovery";
+export { createOmcOrchestratorHook, type OmcOrchestratorOptions } from "./omc-orchestrator";
+export { createTuiStatusHook, type TuiStatusOptions } from "./tui-status";

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

@@ -0,0 +1,23 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ActiveMode } from "./system-prompt-injector";
+export interface KeywordDetectorOptions {
+    onModeChange?: (sessionID: string, mode: ActiveMode, task?: string) => void;
+}
+export declare function createKeywordDetectorHook(ctx: PluginInput, options?: KeywordDetectorOptions): {
+    "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/notepad.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Notepad Support - Compaction Resilient Memory
+ *
+ * Implements compaction-resilient memory persistence using notepad.md format.
+ * Provides a three-tier memory system:
+ * 1. Priority Context - Always loaded, critical discoveries (max 500 chars)
+ * 2. Working Memory - Session notes, auto-pruned after 7 days
+ * 3. MANUAL - User content, never auto-pruned
+ *
+ * Based on oh-my-claude-sisyphus notepad system.
+ */
+export interface NotepadConfig {
+    /** Maximum characters for Priority Context section */
+    priorityMaxChars: number;
+    /** Days to keep Working Memory entries before pruning */
+    workingMemoryDays: number;
+    /** Maximum total file size in bytes */
+    maxTotalSize: number;
+}
+export interface NotepadStats {
+    /** Whether notepad.md exists */
+    exists: boolean;
+    /** Total file size in bytes */
+    totalSize: number;
+    /** Priority Context section size in bytes */
+    prioritySize: number;
+    /** Number of Working Memory entries */
+    workingMemoryEntries: number;
+    /** ISO timestamp of oldest Working Memory entry */
+    oldestEntry: string | null;
+}
+export interface PriorityContextResult {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Warning message if content exceeds limit */
+    warning?: string;
+}
+export interface PruneResult {
+    /** Number of entries pruned */
+    pruned: number;
+    /** Number of entries remaining */
+    remaining: number;
+}
+export declare const NOTEPAD_FILENAME = "notepad.md";
+export declare const DEFAULT_CONFIG: NotepadConfig;
+export declare const PRIORITY_HEADER = "## Priority Context";
+export declare const WORKING_MEMORY_HEADER = "## Working Memory";
+export declare const MANUAL_HEADER = "## MANUAL";
+/**
+ * Get the path to notepad.md in .omc subdirectory
+ */
+export declare function getNotepadPath(directory: string): string;
+/**
+ * Initialize notepad.md if it doesn't exist
+ */
+export declare function initNotepad(directory: string): boolean;
+/**
+ * Read entire notepad content
+ */
+export declare function readNotepad(directory: string): string | null;
+/**
+ * Get Priority Context section only (for injection)
+ */
+export declare function getPriorityContext(directory: string): string | null;
+/**
+ * Get Working Memory section
+ */
+export declare function getWorkingMemory(directory: string): string | null;
+/**
+ * Get MANUAL section
+ */
+export declare function getManualSection(directory: string): string | null;
+/**
+ * Add/update Priority Context (replaces content, warns if over limit)
+ */
+export declare function setPriorityContext(directory: string, content: string, config?: NotepadConfig): PriorityContextResult;
+/**
+ * Add entry to Working Memory with timestamp
+ */
+export declare function addWorkingMemoryEntry(directory: string, content: string): boolean;
+/**
+ * Add to MANUAL section
+ */
+export declare function addManualEntry(directory: string, content: string): boolean;
+/**
+ * Prune Working Memory entries older than N days
+ */
+export declare function pruneOldEntries(directory: string, daysOld?: number): PruneResult;
+/**
+ * Get notepad stats
+ */
+export declare function getNotepadStats(directory: string): NotepadStats;
+/**
+ * Format context for injection into session
+ */
+export declare function formatNotepadContext(directory: string): string | null;
+/**
+ * Format full notepad for display
+ */
+export declare function formatFullNotepad(directory: string): string | null;
+/**
+ * Process <remember> tags from tool output
+ * - <remember>content</remember> → Working Memory
+ * - <remember priority>content</remember> → Priority Context
+ */
+export declare function processRememberTags(directory: string, content: string): {
+    processed: number;
+    errors: number;
+};

package/dist/hooks/omc-orchestrator.d.ts

@@ -0,0 +1,14 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface OmcOrchestratorOptions {
+    delegationEnforcement?: 'strict' | 'warn' | 'off';
+    auditLogEnabled?: boolean;
+}
+export declare function createOmcOrchestratorHook(ctx: PluginInput, options?: OmcOrchestratorOptions): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+};

package/dist/hooks/persistent-mode.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Persistent Mode Handler
+ *
+ * Unified handler for persistent work modes: ultrawork, ralph-loop, and todo-continuation.
+ * This module intercepts session.idle events and enforces work continuation based on:
+ * 1. Active ralph-loop with incomplete promise
+ * 2. Active ultrawork mode with pending todos
+ * 3. Any pending todos (general enforcement)
+ *
+ * Priority order: Ralph Loop > Ultrawork > Todo Continuation
+ *
+ * Based on oh-my-claude-sisyphus persistent-mode hook.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface PersistentModeResult {
+    /** Whether to inject a continuation message */
+    shouldContinue: boolean;
+    /** Message to inject into context */
+    message: string;
+    /** Which mode triggered the continuation */
+    mode: "ralph-loop" | "ultrawork" | "todo-continuation" | "none";
+    /** Additional metadata */
+    metadata?: {
+        todoCount?: number;
+        iteration?: number;
+        maxIterations?: number;
+        reinforcementCount?: number;
+        todoContinuationAttempts?: number;
+    };
+}
+export interface PersistentModeOptions {
+    /** Maximum todo-continuation attempts before giving up (prevents infinite loops) */
+    maxTodoContinuationAttempts?: number;
+    /** Whether to inject notepad context */
+    injectNotepadContext?: boolean;
+    /** Whether to prune old entries on session start */
+    pruneOnStart?: boolean;
+}
+/**
+ * Reset todo-continuation attempt counter (call when todos actually change)
+ */
+export declare function resetTodoContinuationAttempts(sessionId: string): void;
+/**
+ * Main persistent mode checker
+ * Checks all persistent modes in priority order and returns appropriate action
+ */
+export declare function checkPersistentModes(ctx: PluginInput, sessionId: string, options?: PersistentModeOptions): Promise<PersistentModeResult>;
+/**
+ * Create the persistent mode hook
+ */
+export declare function createPersistentModeHook(ctx: PluginInput, options?: PersistentModeOptions): {
+    /**
+     * Check persistent modes on session.idle
+     */
+    checkOnIdle: (sessionId: string) => Promise<PersistentModeResult>;
+    /**
+     * Reset continuation attempts (call when todos change)
+     */
+    resetAttempts: (sessionId: string) => void;
+};

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

@@ -0,0 +1,37 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopConfig } from "../config";
+import type { ActiveMode } from "./system-prompt-injector";
+import { type PRD, type UserStory } from "../prd/prd-manager";
+export type { PRD, UserStory };
+interface RalphLoopState {
+    sessionID: string;
+    prompt: string;
+    iteration: number;
+    maxIterations: number;
+    completionPromise: string;
+    isActive: boolean;
+    startedAt: number;
+    mode: "ralph-loop" | "ultrawork-ralph";
+    prdPath?: string;
+}
+interface RalphLoopOptions {
+    config?: RalphLoopConfig;
+    onModeChange?: (sessionID: string, mode: ActiveMode, task?: string) => void;
+}
+export declare function createRalphLoopHook(ctx: PluginInput, options?: RalphLoopOptions): {
+    startLoop: (sessionID: string, prompt: string, opts?: {
+        maxIterations?: number;
+        mode?: "ralph-loop" | "ultrawork-ralph";
+    }) => boolean;
+    cancelLoop: (sessionID: string) => boolean;
+    getState: (sessionID?: string) => RalphLoopState | null;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    readPrd: () => PRD | null;
+    writePrd: (prd: PRD) => void;
+    checkCompletionInContent: (content: string) => boolean;
+};

package/dist/hooks/ralph-verifier.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface RalphVerifierOptions {
+    maxVerificationAttempts?: number;
+    oracleModel?: string;
+    onVerified?: (sessionID: string) => void;
+    onRejected?: (sessionID: string, feedback: string) => void;
+}
+export declare function createRalphVerifierHook(ctx: PluginInput, options?: RalphVerifierOptions): {
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    isPendingVerification: () => boolean;
+    cancelVerification: () => void;
+    checkForCompletionClaim: (content: string) => string | null;
+    checkForOracleVerdict: (content: string) => {
+        approved: boolean;
+        feedback: string;
+    } | null;
+};