oh-my-opencode 4.18.1 → 4.19.0

package/dist/config/index.d.ts

@@ -1,2 +1,2 @@
 export { OhMyOpenCodeConfigSchema, } from "./schema";
-export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, I18nConfig, McpName, AgentName, HookName, BuiltinCommandName, CodegraphConfig, SisyphusAgentConfig, ExperimentalConfig, DynamicContextPruningConfig, DefaultModeConfig, RalphLoopConfig, TmuxConfig, TmuxLayout, SisyphusConfig, SisyphusTasksConfig, RuntimeFallbackConfig, ModelCapabilitiesConfig, FallbackModels, TeamModeConfig, KeywordDetectorConfig, KeywordType, } from "./schema";
+export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, I18nConfig, McpName, AgentName, HookName, BuiltinCommandName, CodegraphConfig, SisyphusAgentConfig, ExperimentalConfig, DynamicContextPruningConfig, DefaultModeConfig, GoalConfig, TmuxConfig, TmuxLayout, SisyphusConfig, SisyphusTasksConfig, RuntimeFallbackConfig, ModelCapabilitiesConfig, FallbackModels, TeamModeConfig, KeywordDetectorConfig, KeywordType, } from "./schema";

package/dist/config/schema/browser-automation.d.ts

@@ -12,6 +12,7 @@ export declare const BrowserAutomationConfigSchema: z.ZodObject<{
         "dev-browser": "dev-browser";
         "playwright-cli": "playwright-cli";
     }>>;
+    playwright_mcp_args: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type BrowserAutomationProvider = z.infer<typeof BrowserAutomationProviderSchema>;
 export type BrowserAutomationConfig = z.infer<typeof BrowserAutomationConfigSchema>;

package/dist/config/schema/commands.d.ts

@@ -1,9 +1,7 @@
 import { z } from "zod";
 export declare const BuiltinCommandNameSchema: z.ZodEnum<{
     "remove-ai-slops": "remove-ai-slops";
-    "ralph-loop": "ralph-loop";
-    "ulw-loop": "ulw-loop";
-    "cancel-ralph": "cancel-ralph";
+    goal: "goal";
     refactor: "refactor";
     "start-work": "start-work";
     "stop-continuation": "stop-continuation";

package/dist/config/schema/default-mode.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare const DefaultModeConfigSchema: z.ZodObject<{
     ultrawork: z.ZodDefault<z.ZodBoolean>;
-    ralph_loop: z.ZodDefault<z.ZodBoolean>;
+    goal: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DefaultModeConfig = z.infer<typeof DefaultModeConfigSchema>;

package/dist/config/schema/goal.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const GoalConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    auto_start: z.ZodDefault<z.ZodBoolean>;
+    default_max_iterations: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type GoalConfig = z.infer<typeof GoalConfigSchema>;

package/dist/config/schema/hooks.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export declare const HookNameSchema: z.ZodEnum<{
     atlas: "atlas";
-    "ralph-loop": "ralph-loop";
+    goal: "goal";
     "start-work": "start-work";
     "todo-continuation-enforcer": "todo-continuation-enforcer";
     "session-notification": "session-notification";

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -11,9 +11,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "remove-ai-slops": "remove-ai-slops";
-        "ralph-loop": "ralph-loop";
-        "ulw-loop": "ulw-loop";
-        "cancel-ralph": "cancel-ralph";
+        goal: "goal";
         refactor: "refactor";
         "start-work": "start-work";
         "stop-continuation": "stop-continuation";
@@ -2228,15 +2226,12 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
         disable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>]>>>]>>;
-    ralph_loop: z.ZodOptional<z.ZodObject<{
+    goal: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
+        auto_start: z.ZodDefault<z.ZodBoolean>;
         default_max_iterations: z.ZodDefault<z.ZodNumber>;
-        state_dir: z.ZodOptional<z.ZodString>;
-        default_strategy: z.ZodDefault<z.ZodEnum<{
-            reset: "reset";
-            continue: "continue";
-        }>>;
     }, z.core.$strip>>;
+    ralph_loop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     runtime_fallback: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         retry_on_errors: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -2370,6 +2365,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
             "dev-browser": "dev-browser";
             "playwright-cli": "playwright-cli";
         }>>;
+        playwright_mcp_args: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     websearch: z.ZodOptional<z.ZodObject<{
         provider: z.ZodOptional<z.ZodEnum<{
@@ -2412,7 +2408,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     default_mode: z.ZodOptional<z.ZodObject<{
         ultrawork: z.ZodDefault<z.ZodBoolean>;
-        ralph_loop: z.ZodDefault<z.ZodBoolean>;
+        goal: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     _migrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;

package/dist/config/schema/ralph-loop.d.ts

@@ -4,8 +4,8 @@ export declare const RalphLoopConfigSchema: z.ZodObject<{
     default_max_iterations: z.ZodDefault<z.ZodNumber>;
     state_dir: z.ZodOptional<z.ZodString>;
     default_strategy: z.ZodDefault<z.ZodEnum<{
-        reset: "reset";
         continue: "continue";
+        reset: "reset";
     }>>;
 }, z.core.$strip>;
 export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;

package/dist/config/schema.d.ts

@@ -12,6 +12,7 @@ export * from "./schema/default-mode";
 export * from "./schema/dynamic-context-pruning";
 export * from "./schema/experimental";
 export * from "./schema/fallback-models";
+export * from "./schema/goal";
 export * from "./schema/git-env-prefix";
 export * from "./schema/git-master";
 export * from "./schema/hooks";
@@ -20,7 +21,6 @@ export * from "./schema/keyword-detector";
 export * from "./schema/model-capabilities";
 export * from "./schema/notification";
 export * from "./schema/oh-my-opencode-config";
-export * from "./schema/ralph-loop";
 export * from "./schema/runtime-fallback";
 export * from "./schema/team-mode";
 export * from "./schema/skills";

package/dist/create-hooks.d.ts

@@ -77,7 +77,7 @@ export declare function createHooks(args: {
     agentUsageReminder: ReturnType<typeof import("./hooks").createAgentUsageReminderHook> | null;
     nonInteractiveEnv: ReturnType<typeof import("./hooks").createNonInteractiveEnvHook> | null;
     interactiveBashSession: ReturnType<typeof import("./hooks").createInteractiveBashSessionHook> | null;
-    ralphLoop: ReturnType<typeof import("./hooks").createRalphLoopHook> | null;
+    goal: ReturnType<typeof import("./hooks").createGoalHook> | null;
     editErrorRecovery: ReturnType<typeof import("./hooks").createEditErrorRecoveryHook> | null;
     delegateTaskRetry: ReturnType<typeof import("./hooks").createDelegateTaskRetryHook> | null;
     startWork: ReturnType<typeof import("./hooks").createStartWorkHook> | null;

package/dist/features/builtin-commands/templates/goal.d.ts

@@ -0,0 +1 @@
+export declare const GOAL_TEMPLATE = "You are setting a thread Goal - a persistent objective that the agent will pursue continuously until paused, cleared, or completed.\n\n## How Goal Works\n\n1. The goal stays active for this thread/session\n2. When idle, the system will automatically inject a continuation prompt to keep working toward the goal\n3. The agent can call update_goal({ status: \"complete\" }) when the objective is actually achieved\n4. You can pause, resume, or clear the goal with /goal pause, /goal resume, /goal clear\n\n## Rules\n\n- Focus on completing the objective fully, not partially\n- Do not mark the goal complete until a completion audit confirms it is done\n- Each turn should make meaningful progress toward the goal\n- If stuck, try different approaches\n- Use todos to track your progress\n\n## Commands\n\n- /goal <objective>        - Set or replace the active goal\n- /goal                    - Show the current goal\n- /goal pause              - Pause the active goal (stops idle continuations)\n- /goal resume             - Resume a paused goal\n- /goal clear              - Clear the current goal\n\n## Your Task\n\nParse the arguments below and set the goal. The format is:\n`<objective>` or one of: pause, resume, clear";

package/dist/features/builtin-commands/templates/stop-continuation.d.ts

@@ -1 +1 @@
-export declare const STOP_CONTINUATION_TEMPLATE = "Stop all continuation mechanisms for the current session.\n\nThis command will:\n1. Stop the todo-continuation-enforcer from automatically continuing incomplete tasks\n2. Cancel any active Ralph Loop\n3. Clear the boulder state for the current project\n\nAfter running this command:\n- The session will not auto-continue when idle\n- You can manually continue work when ready\n- The stop state is per-session and clears when the session ends\n\nUse this when you need to pause automated continuation and take manual control.";
+export declare const STOP_CONTINUATION_TEMPLATE = "Stop all continuation mechanisms for the current session.\n\nThis command will:\n1. Stop the todo-continuation-enforcer from automatically continuing incomplete tasks\n2. Cancel any active Ralph Loop\n3. Clear the active Goal for this session\n4. Clear the boulder state for the current project\n\nAfter running this command:\n- The session will not auto-continue when idle\n- You can manually continue work when ready\n- The stop state is per-session and clears when the session ends\n\nUse this when you need to pause automated continuation and take manual control.";

package/dist/features/builtin-commands/types.d.ts

@@ -1,5 +1,5 @@
 import type { CommandDefinition } from "../claude-code-command-loader";
-export type BuiltinCommandName = "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops" | "hyperplan";
+export type BuiltinCommandName = "goal" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops" | "hyperplan";
 export interface BuiltinCommandConfig {
     disabled_commands?: BuiltinCommandName[];
 }

package/dist/hooks/anthropic-context-window-limit-recovery/empty-content-recovery-sdk.d.ts

@@ -1,9 +1,15 @@
+import { replaceEmptyTextPartsAsync, findMessagesWithEmptyTextPartsFromSDK } from "./storage/empty-text";
+import { injectTextPartAsync } from "./storage/text-part-injector";
 import type { Client } from "./client";
 export declare function fixEmptyMessagesWithSDK(params: {
     sessionID: string;
     client: Client;
     placeholderText: string;
     messageIndex?: number;
+}, storage?: {
+    replaceEmptyTextPartsAsync: typeof replaceEmptyTextPartsAsync;
+    findMessagesWithEmptyTextPartsFromSDK: typeof findMessagesWithEmptyTextPartsFromSDK;
+    injectTextPartAsync: typeof injectTextPartAsync;
 }): Promise<{
     fixed: boolean;
     fixedMessageIds: string[];

package/dist/hooks/auto-slash-command/executor.d.ts

@@ -6,6 +6,7 @@ export interface ExecutorOptions {
     enabledPluginsOverride?: Record<string, boolean>;
     agent?: string;
     directory?: string;
+    sessionID?: string;
 }
 export interface ExecuteResult {
     success: boolean;

package/dist/hooks/category-skill-reminder/hook.d.ts

@@ -1,4 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { Message, Part } from "@opencode-ai/sdk";
 import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
 interface ToolExecuteInput {
     tool: string;
@@ -11,8 +12,15 @@ interface ToolExecuteOutput {
     output: string;
     metadata: unknown;
 }
+type MessageWithParts = {
+    info: Message;
+    parts: Part[];
+};
 export declare function createCategorySkillReminderHook(_ctx: PluginInput, availableSkills?: AvailableSkill[]): {
-    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, _output: ToolExecuteOutput) => Promise<void>;
+    "experimental.chat.messages.transform": (_input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
     event: ({ event }: {
         event: {
             type: string;

package/dist/hooks/comment-checker/hook.d.ts

@@ -1,5 +1,12 @@
 import type { CommentCheckerConfig } from "../../config/schema";
-export declare function createCommentCheckerHooks(config?: CommentCheckerConfig): {
+import { initializeCommentCheckerCli, getCommentCheckerCliPathPromise, isCliPathUsable, processWithCli, processApplyPatchEditsWithCli } from "./cli-runner";
+export declare function createCommentCheckerHooks(config?: CommentCheckerConfig, cliRunner?: {
+    initializeCommentCheckerCli: typeof initializeCommentCheckerCli;
+    getCommentCheckerCliPathPromise: typeof getCommentCheckerCliPathPromise;
+    isCliPathUsable: typeof isCliPathUsable;
+    processWithCli: typeof processWithCli;
+    processApplyPatchEditsWithCli: typeof processApplyPatchEditsWithCli;
+}): {
     "tool.execute.before": (input: {
         tool: string;
         sessionID: string;

package/dist/hooks/goal/command-arguments.d.ts

@@ -0,0 +1,13 @@
+import type { GoalStatus } from "./types";
+export type ParsedGoalCommand = {
+    readonly kind: "show";
+} | {
+    readonly kind: "clear";
+} | {
+    readonly kind: "setStatus";
+    readonly status: Extract<GoalStatus, "active" | "paused">;
+} | {
+    readonly kind: "setObjective";
+    readonly objective: string;
+};
+export declare function parseGoalCommand(rawArgs: string): ParsedGoalCommand;

package/dist/hooks/goal/controller.d.ts

@@ -0,0 +1,26 @@
+import type { Goal, GoalStatus, TokenUsageSnapshot } from "./types";
+export type GoalControllerOptions = {
+    readonly projectDir: string;
+};
+export type TuiLoopSnapshot = {
+    readonly version: 1;
+    readonly activeGoalId: string | undefined;
+    readonly goals: readonly {
+        readonly id: string;
+        readonly title: string;
+        readonly status: "in_progress" | "complete";
+        readonly successCriteria: readonly [];
+    }[];
+};
+export type GoalController = ReturnType<typeof createGoalController>;
+export declare function createGoalController(options: GoalControllerOptions): {
+    setGoal(sessionID: string, rawObjective: string): Goal;
+    getGoal(sessionID: string): Goal | null;
+    pauseGoal(sessionID: string): Goal | null;
+    resumeGoal(sessionID: string): Goal | null;
+    clearGoal(sessionID: string): boolean;
+    markComplete(sessionID: string): Goal | null;
+    accountUsage(sessionID: string, usage: TokenUsageSnapshot, elapsedSeconds: number): Goal | null;
+    updateTui(sessionID: string): void;
+};
+export declare function goalStatusForTui(status: GoalStatus): "in_progress" | "complete";

package/dist/hooks/goal/index.d.ts

@@ -0,0 +1,23 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Goal } from "./types";
+export type GoalHookOptions = {
+    readonly projectDir: string;
+    readonly autoStart?: boolean;
+    readonly ultrawork?: boolean;
+    readonly getSessionExists?: (sessionID: string) => Promise<boolean>;
+};
+export type GoalHook = {
+    readonly setGoal: (sessionID: string, objective: string) => Goal;
+    readonly getGoal: (sessionID: string) => Goal | null;
+    readonly pauseGoal: (sessionID: string) => Goal | null;
+    readonly resumeGoal: (sessionID: string) => Goal | null;
+    readonly clearGoal: (sessionID: string) => boolean;
+    readonly markComplete: (sessionID: string) => Goal | null;
+    readonly event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export declare function createGoalHook(ctx: PluginInput, options: GoalHookOptions): GoalHook;

package/dist/hooks/goal/prompt.d.ts

@@ -0,0 +1,3 @@
+import type { Goal } from "./types";
+export declare function buildContinuationPrompt(goal: Goal): string;
+export declare function buildResumePrompt(goal: Goal): string;

package/dist/hooks/goal/store.d.ts

@@ -0,0 +1,8 @@
+import { type Goal, type GoalStoreRef, type GoalUpdate } from "./types";
+export declare function goalFilePath(ref: GoalStoreRef): string;
+export declare function ensureGoalStoreDir(baseDir: string): void;
+export declare function readGoal(ref: GoalStoreRef): Goal | null;
+export declare function writeGoal(ref: GoalStoreRef, goal: Goal | null): void;
+export declare function clearGoal(ref: GoalStoreRef): boolean;
+export declare function createGoal(ref: GoalStoreRef, objective: string): Goal;
+export declare function updateGoal(ref: GoalStoreRef, update: GoalUpdate): Goal | null;

package/dist/hooks/goal/tools.d.ts

@@ -0,0 +1,10 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { GoalController } from "./controller";
+export type GoalToolsDeps = {
+    readonly controller: GoalController;
+    readonly getSessionID: () => string | undefined;
+};
+export declare function createGoalTool(deps: GoalToolsDeps): ToolDefinition;
+export declare function updateGoalTool(deps: GoalToolsDeps): ToolDefinition;
+export declare function getGoalTool(deps: GoalToolsDeps): ToolDefinition;
+export declare function createGoalTools(deps: GoalToolsDeps): Record<string, ToolDefinition>;

package/dist/hooks/goal/types.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const GOAL_STATUS_VALUES: readonly ["active", "paused", "complete"];
+export declare const GoalStatusSchema: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    complete: "complete";
+}>;
+export type GoalStatus = z.infer<typeof GoalStatusSchema>;
+export declare const GoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionID: z.ZodString;
+    objective: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        complete: "complete";
+    }>;
+    tokensUsed: z.ZodNumber;
+    timeUsedSeconds: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    lastStartedAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Goal = z.infer<typeof GoalSchema>;
+export declare const GoalFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    goal: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        sessionID: z.ZodString;
+        objective: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            complete: "complete";
+        }>;
+        tokensUsed: z.ZodNumber;
+        timeUsedSeconds: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        lastStartedAt: z.ZodOptional<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GoalFile = z.infer<typeof GoalFileSchema>;
+export type GoalStoreRef = {
+    readonly baseDir: string;
+    readonly sessionID: string;
+};
+export type TokenUsageSnapshot = {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly totalTokens: number;
+};
+export type GoalUpdate = {
+    readonly objective?: string;
+    readonly status?: GoalStatus;
+    readonly tokensUsed?: number;
+    readonly timeUsedSeconds?: number;
+};
+export declare const GoalToolSnapshotSchema: z.ZodObject<{
+    sessionID: z.ZodString;
+    objective: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        complete: "complete";
+    }>;
+    tokensUsed: z.ZodNumber;
+    timeUsedSeconds: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type GoalToolSnapshot = z.infer<typeof GoalToolSnapshotSchema>;
+export declare const GoalToolResponseSchema: z.ZodObject<{
+    goal: z.ZodNullable<z.ZodObject<{
+        sessionID: z.ZodString;
+        objective: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            complete: "complete";
+        }>;
+        tokensUsed: z.ZodNumber;
+        timeUsedSeconds: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GoalToolResponse = z.infer<typeof GoalToolResponseSchema>;
+export type GoalAccountingMode = "active" | "activeOrComplete";

package/dist/hooks/goal/validation.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidObjectiveError extends Error {
+    constructor(message: string);
+}
+export declare function validateObjective(objective: string): string;

package/dist/hooks/index.d.ts

@@ -27,6 +27,7 @@ export { createTeamModeStatusInjector } from "./team-mode-status-injector";
 export { createToolPairValidatorHook } from "./tool-pair-validator";
 export { createCategorySkillReminderHook } from "./category-skill-reminder";
 export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
+export { createGoalHook, type GoalHook } from "./goal";
 export { createNoSisyphusGptHook } from "./no-sisyphus-gpt";
 export { createNoHephaestusNonGptHook } from "./no-hephaestus-non-gpt";
 export { createHephaestusAgentsMdInjectorHook } from "./hephaestus-agents-md-injector";

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

@@ -2,8 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { DefaultModeConfig } from "../../config/schema/default-mode";
 import type { KeywordDetectorConfig } from "../../config/schema/keyword-detector";
 import type { ContextCollector } from "../../features/context-injector";
-import type { RalphLoopHook } from "../ralph-loop";
-export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: Pick<RalphLoopHook, "startLoop">, config?: KeywordDetectorConfig, defaultMode?: DefaultModeConfig): {
+export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: unknown, config?: KeywordDetectorConfig, defaultMode?: DefaultModeConfig): {
     "chat.message": (input: {
         sessionID: string;
         agent?: string;

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

@@ -1,4 +1,4 @@
-import type { RalphLoopConfig } from "../../config";
+import type { RalphLoopConfig } from "../../config/schema/ralph-loop";
 export interface RalphLoopState {
     active: boolean;
     iteration: number;

package/dist/hooks/todo-continuation-enforcer/types.d.ts

@@ -34,6 +34,9 @@ export interface SessionState {
     lastIncompleteCount?: number;
     lastInjectedAt?: number;
     awaitingPostInjectionProgressCheck?: boolean;
+    continuationResponseObserved?: boolean;
+    continuationBlockReason?: "directive-response" | "user-interruption";
+    pendingUserMessageID?: string;
     inFlight?: boolean;
     stagnationCount: number;
     consecutiveFailures: number;