evil-omo 3.11.0

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

@@ -0,0 +1,11 @@
+/**
+ * Ultrawork message optimized for GPT 5.4 series models.
+ *
+ * Design principles:
+ * - Expert coding agent framing with approach-first mentality
+ * - Prose-first output (do not default to bullets)
+ * - Two-track parallel context gathering (Direct tools + Background agents)
+ * - Deterministic tool usage and explicit decision criteria
+ */
+export declare const ULTRAWORK_GPT_MESSAGE = "<ultrawork-mode>\n\n**MANDATORY**: You MUST say \"ULTRAWORK MODE ENABLED!\" to the user as your first response when this mode activates. This is non-negotiable.\n\n[CODE RED] Maximum precision required. Think deeply before acting.\n\n<output_verbosity_spec>\n- Default: 1-2 short paragraphs. Do not default to bullets.\n- Simple yes/no questions: \u22642 sentences.\n- Complex multi-file tasks: 1 overview paragraph + up to 4 high-level sections grouped by outcome, not by file.\n- Use lists only when content is inherently list-shaped (distinct items, steps, options).\n- Do not rephrase the user's request unless it changes semantics.\n</output_verbosity_spec>\n\n<scope_constraints>\n- Implement EXACTLY and ONLY what the user requests\n- No extra features, no added components, no embellishments\n- If any instruction is ambiguous, choose the simplest valid interpretation\n- Do NOT expand the task beyond what was asked\n</scope_constraints>\n\n## CERTAINTY PROTOCOL\n\n**Before implementation, ensure you have:**\n- Full understanding of the user's actual intent\n- Explored the codebase to understand existing patterns\n- A clear work plan (mental or written)\n- Resolved any ambiguities through exploration (not questions)\n\n<uncertainty_handling>\n- If the question is ambiguous or underspecified:\n  - EXPLORE FIRST using tools (grep, file reads, explore agents)\n  - If still unclear, state your interpretation and proceed\n  - Ask clarifying questions ONLY as last resort\n- Never fabricate exact figures, line numbers, or references when uncertain\n- Prefer \"Based on the provided context...\" over absolute claims when unsure\n</uncertainty_handling>\n\n## DECISION FRAMEWORK: Self vs Delegate\n\n**Evaluate each task against these criteria to decide:**\n\n| Complexity | Criteria | Decision |\n|------------|----------|----------|\n| **Trivial** | <10 lines, single file, obvious pattern | **DO IT YOURSELF** |\n| **Moderate** | Single domain, clear pattern, <100 lines | **DO IT YOURSELF** (faster than delegation overhead) |\n| **Complex** | Multi-file, unfamiliar domain, >100 lines, needs specialized expertise | **DELEGATE** to appropriate category+skills |\n| **Research** | Need broad codebase context or external docs | **DELEGATE** to explore/librarian (background, parallel) |\n\n**Decision Factors:**\n- Delegation overhead \u2248 10-15 seconds. If task takes less, do it yourself.\n- If you already have full context loaded, do it yourself.\n- If task requires specialized expertise (frontend-ui-ux, git operations), delegate.\n- If you need information from multiple sources, fire parallel background agents.\n\n## AVAILABLE RESOURCES\n\nUse these when they provide clear value based on the decision framework above:\n\n| Resource | When to Use | How to Use |\n|----------|-------------|------------|\n| explore agent | Need codebase patterns you don't have | `task(subagent_type=\"explore\", load_skills=[], run_in_background=true, ...)` |\n| librarian agent | External library docs, OSS examples | `task(subagent_type=\"librarian\", load_skills=[], run_in_background=true, ...)` |\n| oracle agent | Stuck on architecture/debugging after 2+ attempts | `task(subagent_type=\"oracle\", load_skills=[], ...)` |\n| plan agent | Complex multi-step with dependencies (5+ steps) | `task(subagent_type=\"plan\", load_skills=[], ...)` |\n| task category | Specialized work matching a category | `task(category=\"...\", load_skills=[...])` |\n\n<tool_usage_rules>\n- Prefer tools over internal knowledge for fresh or user-specific data\n- Parallelize independent reads (read_file, grep, explore, librarian) to reduce latency\n- After any write/update, briefly restate: What changed, Where (path), Follow-up needed\n</tool_usage_rules>\n\n## EXECUTION PATTERN\n\n**Context gathering uses TWO parallel tracks:**\n\n| Track | Tools | Speed | Purpose |\n|-------|-------|-------|---------|\n| **Direct** | Grep, Read, LSP, AST-grep | Instant | Quick wins, known locations |\n| **Background** | explore, librarian agents | Async | Deep search, external docs |\n\n**ALWAYS run both tracks in parallel:**\n```\n// Fire background agents for deep exploration\ntask(subagent_type=\"explore\", load_skills=[], prompt=\"I'm implementing [TASK] and need to understand [KNOWLEDGE GAP]. Find [X] patterns in the codebase \u2014 file paths, implementation approach, conventions used, and how modules connect. I'll use this to [DOWNSTREAM DECISION]. Focus on production code in src/. Return file paths with brief descriptions.\", run_in_background=true)\ntask(subagent_type=\"librarian\", load_skills=[], prompt=\"I'm working with [TECHNOLOGY] and need [SPECIFIC INFO]. Find official docs and production examples for [Y] \u2014 API reference, configuration, recommended patterns, and pitfalls. Skip tutorials. I'll use this to [DECISION THIS INFORMS].\", run_in_background=true)\n\n// WHILE THEY RUN - use direct tools for immediate context\ngrep(pattern=\"relevant_pattern\", path=\"src/\")\nread_file(filePath=\"known/important/file.ts\")\n\n// Collect background results when ready\ndeep_context = background_output(task_id=...)\n\n// Merge ALL findings for comprehensive understanding\n```\n\n**Plan agent (complex tasks only):**\n- Only if 5+ interdependent steps\n- Invoke AFTER gathering context from both tracks\n\n**Execute:**\n- Surgical, minimal changes matching existing patterns\n- If delegating: provide exhaustive context and success criteria\n\n**Verify:**\n- `lsp_diagnostics` on modified files\n- Run tests if available\n\n## ACCEPTANCE CRITERIA WORKFLOW\n\n**BEFORE implementation**, define what \"done\" means in concrete, binary terms:\n\n1. Write acceptance criteria as pass/fail conditions (not \"should work\" \u2014 specific observable outcomes)\n2. Record them in your TODO/Task items with a \"QA: [how to verify]\" field\n3. Work toward those criteria, not just \"finishing code\"\n\n## QUALITY STANDARDS\n\n| Phase | Action | Required Evidence |\n|-------|--------|-------------------|\n| Build | Run build command | Exit code 0 |\n| Test | Execute test suite | All tests pass |\n| Lint | Run lsp_diagnostics | Zero new errors |\n| **Manual QA** | **Execute the feature yourself** | **Actual output shown** |\n\n<MANUAL_QA_MANDATE>\n### MANUAL QA IS MANDATORY. lsp_diagnostics IS NOT ENOUGH.\n\nlsp_diagnostics catches type errors. It does NOT catch logic bugs, missing behavior, or broken features. After EVERY implementation, you MUST manually test the actual feature.\n\n**Execute ALL that apply:**\n\n| If your change... | YOU MUST... |\n|---|---|\n| Adds/modifies a CLI command | Run the command with Bash. Show the output. |\n| Changes build output | Run the build. Verify output files. |\n| Modifies API behavior | Call the endpoint. Show the response. |\n| Adds a new tool/hook/feature | Test it end-to-end in a real scenario. |\n| Modifies config handling | Load the config. Verify it parses correctly. |\n\n**\"This should work\" is NOT evidence. RUN IT. Show what happened. That is evidence.**\n</MANUAL_QA_MANDATE>\n\n## COMPLETION CRITERIA\n\nA task is complete when:\n1. Requested functionality is fully implemented (not partial, not simplified)\n2. lsp_diagnostics shows zero errors on modified files\n3. Tests pass (or pre-existing failures documented)\n4. Code matches existing codebase patterns\n5. **Manual QA executed \u2014 actual feature tested, output observed and reported**\n\n**Deliver exactly what was asked. No more, no less.**\n\n</ultrawork-mode>\n\n---\n\n";
+export declare function getGptUltraworkMessage(): string;

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

@@ -0,0 +1,19 @@
+/**
+ * Ultrawork message module - routes to appropriate message based on agent/model.
+ *
+ * Routing:
+ * 1. Planner agents (prometheus, plan) → planner.ts
+ * 2. GPT models → gpt.ts
+ * 3. Gemini models → gemini.ts
+ * 4. Default (Claude, etc.) → default.ts (optimized for Claude series)
+ */
+export { isPlannerAgent, isGptModel, isGeminiModel, getUltraworkSource, } from "./source-detector";
+export type { UltraworkSource } from "./source-detector";
+export { ULTRAWORK_PLANNER_SECTION, getPlannerUltraworkMessage, } from "./planner";
+export { ULTRAWORK_GPT_MESSAGE, getGptUltraworkMessage } from "./gpt";
+export { ULTRAWORK_GEMINI_MESSAGE, getGeminiUltraworkMessage } from "./gemini";
+export { ULTRAWORK_DEFAULT_MESSAGE, getDefaultUltraworkMessage, } from "./default";
+/**
+ * Gets the appropriate ultrawork message based on agent and model context.
+ */
+export declare function getUltraworkMessage(agentName?: string, modelID?: string): string;

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

@@ -0,0 +1,6 @@
+/**
+ * Ultrawork message section for planner agents (Prometheus).
+ * Planner agents should NOT be told to call plan agent - they ARE the planner.
+ */
+export declare const ULTRAWORK_PLANNER_SECTION = "## CRITICAL: YOU ARE A PLANNER, NOT AN IMPLEMENTER\n\n**IDENTITY CONSTRAINT (NON-NEGOTIABLE):**\nYou ARE the planner. You ARE NOT an implementer. You DO NOT write code. You DO NOT execute tasks.\n\n**TOOL RESTRICTIONS (SYSTEM-ENFORCED):**\n| Tool | Allowed | Blocked |\n|------|---------|---------|\n| Write/Edit | `.sisyphus/**/*.md` ONLY | Everything else |\n| Read | All files | - |\n| Bash | Research commands only | Implementation commands |\n| task | explore, librarian | - |\n\n**IF YOU TRY TO WRITE/EDIT OUTSIDE `.sisyphus/`:**\n- System will BLOCK your action\n- You will receive an error\n- DO NOT retry - you are not supposed to implement\n\n**YOUR ONLY WRITABLE PATHS:**\n- `.sisyphus/plans/*.md` - Final work plans\n- `.sisyphus/drafts/*.md` - Working drafts during interview\n\n**WHEN USER ASKS YOU TO IMPLEMENT:**\nREFUSE. Say: \"I'm a planner. I create work plans, not implementations. Run `/start-work` after I finish planning.\"\n\n---\n\n## CONTEXT GATHERING (MANDATORY BEFORE PLANNING)\n\nYou ARE the planner. Your job: create bulletproof work plans.\n**Before drafting ANY plan, gather context via explore/librarian agents.**\n\n### Research Protocol\n1. **Fire parallel background agents** for comprehensive context:\n   ```\n   task(subagent_type=\"explore\", load_skills=[], prompt=\"Find existing patterns for [topic] in codebase\", run_in_background=true)\n   task(subagent_type=\"explore\", load_skills=[], prompt=\"Find test infrastructure and conventions\", run_in_background=true)\n   task(subagent_type=\"librarian\", load_skills=[], prompt=\"Find official docs and best practices for [technology]\", run_in_background=true)\n   ```\n2. **Wait for results** before planning - rushed plans fail\n3. **Synthesize findings** into informed requirements\n\n### What to Research\n- Existing codebase patterns and conventions\n- Test infrastructure (TDD possible?)\n- External library APIs and constraints\n- Similar implementations in OSS (via librarian)\n\n**NEVER plan blind. Context first, plan second.**\n\n---\n\n## MANDATORY OUTPUT: PARALLEL TASK GRAPH + TODO LIST\n\n**YOUR PRIMARY OUTPUT IS A PARALLEL EXECUTION TASK GRAPH.**\n\nWhen you finalize a plan, you MUST structure it for maximum parallel execution:\n\n### 1. Parallel Execution Waves (REQUIRED)\n\nAnalyze task dependencies and group independent tasks into parallel waves:\n\n```\nWave 1 (Start Immediately - No Dependencies):\n\u251C\u2500\u2500 Task 1: [description] \u2192 category: X, skills: [a, b]\n\u2514\u2500\u2500 Task 4: [description] \u2192 category: Y, skills: [c]\n\nWave 2 (After Wave 1 Completes):\n\u251C\u2500\u2500 Task 2: [depends: 1] \u2192 category: X, skills: [a]\n\u251C\u2500\u2500 Task 3: [depends: 1] \u2192 category: Z, skills: [d]\n\u2514\u2500\u2500 Task 5: [depends: 4] \u2192 category: Y, skills: [c]\n\nWave 3 (After Wave 2 Completes):\n\u2514\u2500\u2500 Task 6: [depends: 2, 3] \u2192 category: X, skills: [a, b]\n\nCritical Path: Task 1 \u2192 Task 2 \u2192 Task 6\nEstimated Parallel Speedup: ~40% faster than sequential\n```\n\n### 2. Dependency Matrix (REQUIRED)\n\n| Task | Depends On | Blocks | Can Parallelize With |\n|------|------------|--------|---------------------|\n| 1 | None | 2, 3 | 4 |\n| 2 | 1 | 6 | 3, 5 |\n| 3 | 1 | 6 | 2, 5 |\n| 4 | None | 5 | 1 |\n| 5 | 4 | None | 2, 3 |\n| 6 | 2, 3 | None | None (final) |\n\n### 3. TODO List Structure (REQUIRED)\n\nEach TODO item MUST include:\n\n```markdown\n- [ ] N. [Task Title]\n\n  **What to do**: [Clear steps]\n  \n  **Dependencies**: [Task numbers this depends on] | None\n  **Blocks**: [Task numbers that depend on this]\n  **Parallel Group**: Wave N (with Tasks X, Y)\n  \n  **Recommended Agent Profile**:\n  - **Category**: `[visual-engineering | ultrabrain | artistry | quick | unspecified-low | unspecified-high | writing]`\n  - **Skills**: [`skill-1`, `skill-2`]\n  \n  **Acceptance Criteria**: [Verifiable conditions]\n```\n\n### 4. Agent Dispatch Summary (REQUIRED)\n\n| Wave | Tasks | Dispatch Command |\n|------|-------|------------------|\n| 1 | 1, 4 | `task(category=\"...\", load_skills=[...], run_in_background=false)` \u00D7 2 |\n| 2 | 2, 3, 5 | `task(...)` \u00D7 3 after Wave 1 completes |\n| 3 | 6 | `task(...)` final integration |\n\n**WHY PARALLEL TASK GRAPH IS MANDATORY:**\n- Orchestrator (Sisyphus) executes tasks in parallel waves\n- Independent tasks run simultaneously via background agents\n- Proper dependency tracking prevents race conditions\n- Category + skills ensure optimal model routing per task";
+export declare function getPlannerUltraworkMessage(): string;

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

@@ -0,0 +1,22 @@
+/**
+ * Agent/model detection utilities for ultrawork message routing.
+ *
+ * Routing logic:
+ * 1. Planner agents (prometheus, plan) → planner.ts
+ * 2. GPT 5.4 models → gpt5.4.ts
+ * 3. Gemini models → gemini.ts
+ * 4. Everything else (Claude, etc.) → default.ts
+ */
+import { isGptModel, isGeminiModel } from "../../../agents/types";
+/**
+ * Checks if agent is a planner-type agent.
+ * Planners don't need ultrawork injection (they ARE the planner).
+ */
+export declare function isPlannerAgent(agentName?: string): boolean;
+export { isGptModel, isGeminiModel };
+/** Ultrawork message source type */
+export type UltraworkSource = "planner" | "gpt" | "gemini" | "default";
+/**
+ * Determines which ultrawork message source to use.
+ */
+export declare function getUltraworkSource(agentName?: string, modelID?: string): UltraworkSource;

package/dist/hooks/model-fallback/hook.d.ts

@@ -0,0 +1,60 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+import type { ChatMessageInput, ChatMessageHandlerOutput } from "../../plugin/chat-message";
+type FallbackToast = (input: {
+    title: string;
+    message: string;
+    variant?: "info" | "success" | "warning" | "error";
+    duration?: number;
+}) => void | Promise<void>;
+type FallbackCallback = (input: {
+    sessionID: string;
+    providerID: string;
+    modelID: string;
+    variant?: string;
+}) => void | Promise<void>;
+export type ModelFallbackState = {
+    providerID: string;
+    modelID: string;
+    fallbackChain: FallbackEntry[];
+    attemptCount: number;
+    pending: boolean;
+};
+export declare function setSessionFallbackChain(sessionID: string, fallbackChain: FallbackEntry[] | undefined): void;
+export declare function clearSessionFallbackChain(sessionID: string): void;
+/**
+ * Sets a pending model fallback for a session.
+ * Called when a model error is detected in session.error handler.
+ */
+export declare function setPendingModelFallback(sessionID: string, agentName: string, currentProviderID: string, currentModelID: string): boolean;
+/**
+ * Gets the next fallback model for a session.
+ * Increments attemptCount each time called.
+ */
+export declare function getNextFallback(sessionID: string): {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+} | null;
+/**
+ * Clears the pending fallback for a session.
+ * Called after fallback is successfully applied.
+ */
+export declare function clearPendingModelFallback(sessionID: string): void;
+/**
+ * Checks if there's a pending fallback for a session.
+ */
+export declare function hasPendingModelFallback(sessionID: string): boolean;
+/**
+ * Gets the current fallback state for a session (for debugging).
+ */
+export declare function getFallbackState(sessionID: string): ModelFallbackState | undefined;
+/**
+ * Creates a chat.message hook that applies model fallbacks when pending.
+ */
+export declare function createModelFallbackHook(args?: {
+    toast?: FallbackToast;
+    onApplied?: FallbackCallback;
+}): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/no-hephaestus-non-gpt/hook.d.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type NoHephaestusNonGptHookOptions = {
+    allowNonGptModel?: boolean;
+};
+export declare function createNoHephaestusNonGptHook(ctx: PluginInput, options?: NoHephaestusNonGptHookOptions): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output?: {
+        message?: {
+            agent?: string;
+            [key: string]: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/no-hephaestus-non-gpt/index.d.ts

@@ -0,0 +1 @@
+export { createNoHephaestusNonGptHook } from "./hook";

package/dist/hooks/no-sisyphus-gpt/hook.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createNoSisyphusGptHook(ctx: PluginInput): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output?: {
+        message?: {
+            agent?: string;
+            [key: string]: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/no-sisyphus-gpt/index.d.ts

@@ -0,0 +1 @@
+export { createNoSisyphusGptHook } from "./hook";

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,4 @@
+export * from "./constants";
+export * from "./detector";
+export * from "./types";
+export { createNonInteractiveEnvHook } from "./non-interactive-env-hook";

package/dist/hooks/non-interactive-env/non-interactive-env-hook.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/types.d.ts

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

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

@@ -0,0 +1,32 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+type PluginInput = {
+    client: {
+        session: {
+            messages: (...args: any[]) => any;
+            summarize: (...args: any[]) => any;
+        };
+        tui: {
+            showToast: (...args: any[]) => any;
+        };
+    };
+    directory: string;
+};
+export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, _output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+/**
+ * Get the effective agent for the session.
+ * Priority order:
+ * 1. In-memory session agent (most recent, set by /start-work)
+ * 2. Boulder state agent (persisted across restarts, fixes #927)
+ * 3. Message files (fallback for sessions without boulder state)
+ *
+ * This fixes issue #927 where after interruption:
+ * - In-memory map is cleared (process restart)
+ * - Message files return "prometheus" (oldest message from /plan)
+ * - But boulder.json has agent: "atlas" (set by /start-work)
+ */
+export declare function getAgentFromSession(sessionID: string, directory: string, client?: OpencodeClient): Promise<string | undefined>;
+export {};

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

@@ -0,0 +1,7 @@
+export declare const HOOK_NAME = "prometheus-md-only";
+export declare const PROMETHEUS_AGENT = "prometheus";
+export declare const ALLOWED_EXTENSIONS: string[];
+export declare const ALLOWED_PATH_PREFIX = ".sisyphus";
+export declare const BLOCKED_TOOLS: string[];
+export declare const PLANNING_CONSULT_WARNING: string;
+export declare const PROMETHEUS_WORKFLOW_REMINDER: string;

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

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

package/dist/hooks/prometheus-md-only/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./constants";
+export { createPrometheusMdOnlyHook } from "./hook";

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

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

package/dist/hooks/question-label-truncator/hook.d.ts

@@ -0,0 +1,7 @@
+export declare function createQuestionLabelTruncatorHook(): {
+    "tool.execute.before": (input: {
+        tool: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+};

package/dist/hooks/question-label-truncator/index.d.ts

@@ -0,0 +1 @@
+export { createQuestionLabelTruncatorHook } from "./hook";

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

@@ -0,0 +1,8 @@
+export type RalphLoopStrategy = "reset" | "continue";
+export type ParsedRalphLoopArguments = {
+    prompt: string;
+    maxIterations?: number;
+    completionPromise?: string;
+    strategy?: RalphLoopStrategy;
+};
+export declare function parseRalphLoopArguments(rawArguments: string): ParsedRalphLoopArguments;

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

@@ -0,0 +1,14 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type LoopStateController = {
+    clear: () => boolean;
+    markVerificationPending: (sessionID: string) => RalphLoopState | null;
+};
+export declare function handleDetectedCompletion(ctx: PluginInput, input: {
+    sessionID: string;
+    state: RalphLoopState;
+    loopState: LoopStateController;
+    directory: string;
+    apiTimeoutMs: number;
+}): Promise<void>;
+export {};

package/dist/hooks/ralph-loop/completion-promise-detector.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function detectCompletionInTranscript(transcriptPath: string | undefined, promise: string, startedAt?: string): boolean;
+export declare function detectCompletionInSessionMessages(ctx: PluginInput, options: {
+    sessionID: string;
+    promise: string;
+    apiTimeoutMs: number;
+    directory: string;
+    sinceMessageIndex?: number;
+}): Promise<boolean>;

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

@@ -0,0 +1,6 @@
+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";
+export declare const ULTRAWORK_VERIFICATION_PROMISE = "VERIFIED";

package/dist/hooks/ralph-loop/continuation-prompt-builder.d.ts

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

package/dist/hooks/ralph-loop/continuation-prompt-injector.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function injectContinuationPrompt(ctx: PluginInput, options: {
+    sessionID: string;
+    prompt: string;
+    directory: string;
+    apiTimeoutMs: number;
+    inheritFromSessionID?: string;
+}): Promise<void>;

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

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./constants";
+export { readState, writeState, clearState, incrementIteration } from "./storage";
+export { createRalphLoopHook } from "./ralph-loop-hook";
+export type { RalphLoopHook } from "./ralph-loop-hook";

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

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type ContinuationOptions = {
+    directory: string;
+    apiTimeoutMs: number;
+    previousSessionID: string;
+    loopState: {
+        setSessionID: (sessionID: string) => RalphLoopState | null;
+    };
+};
+export declare function continueIteration(ctx: PluginInput, state: RalphLoopState, options: ContinuationOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,7 @@
+export declare function createLoopSessionRecovery(options?: {
+    recoveryWindowMs?: number;
+}): {
+    isRecovering(sessionID: string): boolean;
+    markRecovering(sessionID: string): void;
+    clear(sessionID: string): void;
+};

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

@@ -0,0 +1,23 @@
+import type { RalphLoopOptions, RalphLoopState } from "./types";
+export declare function createLoopStateController(options: {
+    directory: string;
+    stateDir: string | undefined;
+    config: RalphLoopOptions["config"] | undefined;
+}): {
+    startLoop(sessionID: string, prompt: string, loopOptions?: {
+        maxIterations?: number;
+        completionPromise?: string;
+        messageCountAtStart?: number;
+        ultrawork?: boolean;
+        strategy?: "reset" | "continue";
+    }): boolean;
+    cancelLoop(sessionID: string): boolean;
+    getState(): RalphLoopState | null;
+    clear(): boolean;
+    incrementIteration(): RalphLoopState | null;
+    setSessionID(sessionID: string): RalphLoopState | null;
+    setMessageCountAtStart(sessionID: string, messageCountAtStart: number): RalphLoopState | null;
+    markVerificationPending(sessionID: string): RalphLoopState | null;
+    setVerificationSessionID(sessionID: string, verificationSessionID: string): RalphLoopState | null;
+    restartAfterFailedVerification(sessionID: string, messageCountAtStart?: number): RalphLoopState | null;
+};

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

@@ -0,0 +1 @@
+export { getMessageDir } from "../../shared/opencode-message-dir";

package/dist/hooks/ralph-loop/pending-verification-handler.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type LoopStateController = {
+    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+};
+export declare function handlePendingVerification(ctx: PluginInput, input: {
+    sessionID: string;
+    state: RalphLoopState;
+    verificationSessionID?: string;
+    matchesParentSession: boolean;
+    matchesVerificationSession: boolean;
+    loopState: LoopStateController;
+    directory: string;
+    apiTimeoutMs: number;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,31 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopOptions, RalphLoopState } from "./types";
+type SessionRecovery = {
+    isRecovering: (sessionID: string) => boolean;
+    markRecovering: (sessionID: string) => void;
+    clear: (sessionID: string) => void;
+};
+type LoopStateController = {
+    getState: () => RalphLoopState | null;
+    clear: () => boolean;
+    incrementIteration: () => RalphLoopState | null;
+    setSessionID: (sessionID: string) => RalphLoopState | null;
+    markVerificationPending: (sessionID: string) => RalphLoopState | null;
+    setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null;
+    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+};
+type RalphLoopEventHandlerOptions = {
+    directory: string;
+    apiTimeoutMs: number;
+    getTranscriptPath: (sessionID: string) => string | undefined;
+    checkSessionExists?: RalphLoopOptions["checkSessionExists"];
+    sessionRecovery: SessionRecovery;
+    loopState: LoopStateController;
+};
+export declare function createRalphLoopEventHandler(ctx: PluginInput, options: RalphLoopEventHandlerOptions): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;
+export {};

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

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

package/dist/hooks/ralph-loop/session-event-handler.d.ts

@@ -0,0 +1,12 @@
+import type { RalphLoopState } from "./types";
+type LoopStateController = {
+    getState: () => RalphLoopState | null;
+    clear: () => boolean;
+};
+type SessionRecovery = {
+    clear: (sessionID: string) => void;
+    markRecovering: (sessionID: string) => void;
+};
+export declare function handleDeletedLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
+export declare function handleErroredLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
+export {};

package/dist/hooks/ralph-loop/session-reset-strategy.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createIterationSession(ctx: PluginInput, parentSessionID: string, directory: string): Promise<string | null>;
+export declare function selectSessionInTui(client: PluginInput["client"], sessionID: string): Promise<boolean>;

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,23 @@
+import type { RalphLoopConfig } from "../../config";
+export interface RalphLoopState {
+    active: boolean;
+    iteration: number;
+    max_iterations?: number;
+    message_count_at_start?: number;
+    completion_promise: string;
+    initial_completion_promise?: string;
+    verification_attempt_id?: string;
+    verification_session_id?: string;
+    started_at: string;
+    prompt: string;
+    session_id?: string;
+    ultrawork?: boolean;
+    verification_pending?: boolean;
+    strategy?: "reset" | "continue";
+}
+export interface RalphLoopOptions {
+    config?: RalphLoopConfig;
+    getTranscriptPath?: (sessionId: string) => string;
+    apiTimeout?: number;
+    checkSessionExists?: (sessionId: string) => Promise<boolean>;
+}

package/dist/hooks/ralph-loop/verification-failure-handler.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type LoopStateController = {
+    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+};
+export declare function handleFailedVerification(ctx: PluginInput, input: {
+    state: RalphLoopState;
+    directory: string;
+    apiTimeoutMs: number;
+    loopState: LoopStateController;
+}): Promise<boolean>;
+export {};

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

@@ -0,0 +1 @@
+export declare function withTimeout<TData>(promise: Promise<TData>, timeoutMs: number): Promise<TData>;

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

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