opencode-ultra 0.8.3 → 0.9.0

package/dist/config.d.ts

@@ -76,6 +76,7 @@ declare const PluginConfigSchema: z.ZodObject<{
     evolve_exe: z.ZodOptional<z.ZodObject<{
         maxIterations: z.ZodOptional<z.ZodNumber>;
         iterationTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        totalTimeoutMs: z.ZodOptional<z.ZodNumber>;
         skipReview: z.ZodOptional<z.ZodBoolean>;
         skipTests: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;

package/dist/index.js

@@ -14415,6 +14415,228 @@ class TtlMap {
     this.map.clear();
   }
 }
+// src/shared/concurrency.ts
+function computeExponentialBackoffDelayMs(attempt, opts = {}) {
+  const base = opts.baseDelayMs ?? 200;
+  const max = opts.maxDelayMs ?? 1e4;
+  const jitter = opts.jitter ?? "full";
+  const rng = opts.rng ?? Math.random;
+  const a = Math.max(0, Math.floor(attempt));
+  const cap = Math.min(max, base * 2 ** a);
+  if (jitter === "none")
+    return Math.floor(cap);
+  const r0 = rng();
+  const r = Number.isFinite(r0) ? Math.max(0, Math.min(0.999999, r0)) : 0;
+  return Math.floor(r * cap);
+}
+class CircuitBreaker {
+  state = "closed";
+  consecutiveFailures = 0;
+  openUntil = 0;
+  halfOpenInFlight = false;
+  failureThreshold;
+  cooldownMs;
+  constructor(opts = {}) {
+    this.failureThreshold = Math.max(1, Math.floor(opts.failureThreshold ?? 3));
+    this.cooldownMs = Math.max(0, Math.floor(opts.cooldownMs ?? 1e4));
+  }
+  snapshot(now) {
+    const openForMs = this.state === "open" ? Math.max(0, this.openUntil - now) : 0;
+    return { state: this.state, consecutiveFailures: this.consecutiveFailures, openForMs };
+  }
+  enter(now) {
+    if (this.state === "open") {
+      if (now < this.openUntil) {
+        return { allowed: false, waitMs: this.openUntil - now };
+      }
+      this.state = "half_open";
+      this.halfOpenInFlight = false;
+    }
+    if (this.state === "half_open") {
+      if (this.halfOpenInFlight)
+        return { allowed: false, waitMs: this.cooldownMs };
+      this.halfOpenInFlight = true;
+      return { allowed: true };
+    }
+    return { allowed: true };
+  }
+  onSuccess() {
+    this.consecutiveFailures = 0;
+    this.openUntil = 0;
+    this.halfOpenInFlight = false;
+    this.state = "closed";
+  }
+  onFailure(now) {
+    this.halfOpenInFlight = false;
+    if (this.state === "half_open") {
+      this.state = "open";
+      this.openUntil = now + this.cooldownMs;
+      this.consecutiveFailures = this.failureThreshold;
+      return;
+    }
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= this.failureThreshold) {
+      this.state = "open";
+      this.openUntil = now + this.cooldownMs;
+    }
+  }
+}
+
+class RetryBudgetExceededError extends Error {
+  provider;
+  constructor(provider) {
+    super(`Retry budget exceeded for ${provider}`);
+    this.name = "RetryBudgetExceededError";
+    this.provider = provider;
+  }
+}
+
+class RetryBudget {
+  maxRetries;
+  intervalMs;
+  state;
+  constructor(opts = {}) {
+    this.maxRetries = Math.max(0, Math.floor(opts.maxRetries ?? 20));
+    this.intervalMs = Math.max(1, Math.floor(opts.intervalMs ?? 60000));
+    this.state = new TtlMap({ maxSize: 1000, ttlMs: this.intervalMs });
+  }
+  trySpend(provider, cost = 1) {
+    const c = Math.max(0, Math.floor(cost));
+    if (c === 0)
+      return true;
+    const entry = this.state.get(provider) ?? { used: 0 };
+    if (entry.used + c > this.maxRetries)
+      return false;
+    this.state.set(provider, { used: entry.used + c });
+    return true;
+  }
+}
+function getHeaderValue(headers, name) {
+  if (!headers || typeof headers !== "object")
+    return;
+  const key = Object.keys(headers).find((k) => k.toLowerCase() === name.toLowerCase());
+  if (!key)
+    return;
+  const v = headers[key];
+  return typeof v === "string" ? v : Array.isArray(v) && typeof v[0] === "string" ? v[0] : undefined;
+}
+function parseRetryAfterMs(value, now) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  const asNum = Number(trimmed);
+  if (Number.isFinite(asNum) && asNum >= 0)
+    return Math.floor(asNum * 1000);
+  const asDate = Date.parse(trimmed);
+  if (!Number.isNaN(asDate)) {
+    const ms = asDate - now;
+    return ms > 0 ? ms : 0;
+  }
+  return;
+}
+function classifyRetryableError(err, now = Date.now()) {
+  const anyErr = err;
+  const status = typeof anyErr?.status === "number" ? anyErr.status : typeof anyErr?.statusCode === "number" ? anyErr.statusCode : typeof anyErr?.response?.status === "number" ? anyErr.response.status : typeof anyErr?.response?.statusCode === "number" ? anyErr.response.statusCode : undefined;
+  const headers = anyErr?.headers ?? anyErr?.response?.headers;
+  const retryAfterRaw = getHeaderValue(headers, "retry-after");
+  const retryAfterMs = retryAfterRaw ? parseRetryAfterMs(retryAfterRaw, now) : undefined;
+  if (status === 429)
+    return { retryable: true, status, retryAfterMs };
+  if (typeof status === "number" && status >= 500 && status <= 599)
+    return { retryable: true, status, retryAfterMs };
+  const code = typeof anyErr?.code === "string" ? anyErr.code : undefined;
+  if (code && (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "EAI_AGAIN" || code === "ENOTFOUND")) {
+    return { retryable: true };
+  }
+  return { retryable: false, status, retryAfterMs };
+}
+async function adaptiveRetry(provider, fn, breaker, budget, opts = {}) {
+  const maxAttempts = Math.max(1, Math.floor(opts.maxAttempts ?? 4));
+  const nowFn = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const classify = opts.classify ?? classifyRetryableError;
+  const maxRetryAfterMs = Math.max(0, Math.floor(opts.maxRetryAfterMs ?? 30000));
+  const backoff = opts.backoff ?? {};
+  let attempt = 0;
+  while (true) {
+    const now = nowFn();
+    const gate = breaker.enter(now);
+    if (!gate.allowed) {
+      const waitMs = Math.max(0, Math.floor(gate.waitMs ?? 0));
+      if (waitMs > 0) {
+        const delay = Math.min(waitMs, maxRetryAfterMs);
+        await sleep(delay);
+      }
+    }
+    try {
+      const result = await fn();
+      breaker.onSuccess();
+      return result;
+    } catch (err) {
+      const now2 = nowFn();
+      const decision = classify(err, now2);
+      if (!decision.retryable) {
+        throw err;
+      }
+      breaker.onFailure(now2);
+      attempt++;
+      if (attempt >= maxAttempts)
+        throw err;
+      if (!budget.trySpend(provider, 1)) {
+        throw new RetryBudgetExceededError(provider);
+      }
+      const retryAfterMs = typeof decision.retryAfterMs === "number" ? Math.min(Math.max(0, decision.retryAfterMs), maxRetryAfterMs) : undefined;
+      const delay = retryAfterMs !== undefined ? retryAfterMs : computeExponentialBackoffDelayMs(attempt - 1, {
+        baseDelayMs: backoff.baseDelayMs,
+        maxDelayMs: backoff.maxDelayMs,
+        jitter: backoff.jitter,
+        rng: backoff.rng
+      });
+      if (delay > 0)
+        await sleep(delay);
+    }
+  }
+}
+
+class ProviderResilience {
+  breakers = new Map;
+  budgets = new Map;
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  getBreaker(provider) {
+    const existing = this.breakers.get(provider);
+    if (existing)
+      return existing;
+    const b = new CircuitBreaker(this.opts.breaker);
+    this.breakers.set(provider, b);
+    return b;
+  }
+  getBudget(provider) {
+    const existing = this.budgets.get(provider);
+    if (existing)
+      return existing;
+    const b = new RetryBudget(this.opts.retryBudget);
+    this.budgets.set(provider, b);
+    return b;
+  }
+  async run(provider, fn, retryOverrides = {}) {
+    const breaker = this.getBreaker(provider);
+    const budget = this.getBudget(provider);
+    const baseRetry = this.opts.retry ?? {};
+    const merged = {
+      ...baseRetry,
+      ...retryOverrides,
+      backoff: { ...baseRetry.backoff, ...retryOverrides.backoff }
+    };
+    return adaptiveRetry(provider, fn, breaker, budget, merged);
+  }
+  snapshot(provider, now = Date.now()) {
+    const breaker = this.getBreaker(provider);
+    return { breaker: breaker.snapshot(now) };
+  }
+}
 // src/config.ts
 var AgentOverrideSchema = exports_external.object({
   model: exports_external.string().optional(),
@@ -14476,6 +14698,7 @@ var PluginConfigSchema = exports_external.object({
   evolve_exe: exports_external.object({
     maxIterations: exports_external.number().min(1).max(20).optional(),
     iterationTimeoutMs: exports_external.number().min(1e4).optional(),
+    totalTimeoutMs: exports_external.number().min(60000).optional(),
     skipReview: exports_external.boolean().optional(),
     skipTests: exports_external.boolean().optional()
   }).optional()
@@ -27549,6 +27772,86 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external2;
+// src/concurrency/semaphore.ts
+class Semaphore {
+  max;
+  queue = [];
+  active = 0;
+  constructor(max) {
+    this.max = max;
+  }
+  async acquire() {
+    if (this.active < this.max) {
+      this.active++;
+      return;
+    }
+    return new Promise((resolve2) => {
+      this.queue.push(() => {
+        this.active++;
+        resolve2();
+      });
+    });
+  }
+  release() {
+    if (this.active <= 0)
+      return;
+    this.active--;
+    const next = this.queue.shift();
+    if (next)
+      next();
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get running() {
+    return this.active;
+  }
+}
+// src/concurrency/pool.ts
+function extractProvider(model) {
+  const slash = model.indexOf("/");
+  return slash > 0 ? model.slice(0, slash) : model;
+}
+
+class ConcurrencyPool {
+  global;
+  providers = new Map;
+  models = new Map;
+  config;
+  constructor(config3) {
+    this.config = config3;
+    this.global = new Semaphore(config3.defaultConcurrency ?? Infinity);
+    for (const [provider, limit] of Object.entries(config3.providerConcurrency ?? {})) {
+      this.providers.set(provider, new Semaphore(limit));
+    }
+    for (const [model, limit] of Object.entries(config3.modelConcurrency ?? {})) {
+      this.models.set(model, new Semaphore(limit));
+    }
+  }
+  async run(model, fn) {
+    const provider = extractProvider(model);
+    const semaphores = [];
+    const modelSem = this.models.get(model);
+    if (modelSem) {
+      await modelSem.acquire();
+      semaphores.push(modelSem);
+    }
+    const providerSem = this.providers.get(provider);
+    if (providerSem) {
+      await providerSem.acquire();
+      semaphores.push(providerSem);
+    }
+    await this.global.acquire();
+    semaphores.push(this.global);
+    try {
+      return await fn();
+    } finally {
+      for (let i = semaphores.length - 1;i >= 0; i--) {
+        semaphores[i].release();
+      }
+    }
+  }
+}
 // src/categories/index.ts
 var DEFAULT_CATEGORIES = {
   "visual-engineering": {
@@ -27900,7 +28203,7 @@ async function withTimeout(promise3, ms, label) {
     clearTimeout(timer);
   }
 }
-async function runAgent(ctx, task, toolCtx, internalSessions, deps, progress) {
+async function runAgent(ctx, task, toolCtx, internalSessions, resilience, provider, deps, progress) {
   const { agent, prompt, description } = task;
   const t0 = Date.now();
   const timeoutMs = deps.agentTimeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
@@ -27916,10 +28219,10 @@ async function runAgent(ctx, task, toolCtx, internalSessions, deps, progress) {
   log(`spawn_agent: starting ${agent}`, { description });
   let sessionID;
   try {
-    const sessionResp = await ctx.client.session.create({
+    const sessionResp = await resilience.run(provider, () => ctx.client.session.create({
       body: {},
       query: { directory: ctx.directory }
-    });
+    }), { maxAttempts: 3 });
     sessionID = sessionResp.data?.id;
     if (!sessionID) {
       log(`spawn_agent: ${agent} \u2014 failed to create session`);
@@ -27928,25 +28231,26 @@ async function runAgent(ctx, task, toolCtx, internalSessions, deps, progress) {
 **Agent**: ${agent}
 **Error**: Failed to create session`;
     }
-    internalSessions.add(sessionID);
-    await withTimeout(ctx.client.session.prompt({
-      path: { id: sessionID },
+    const id = sessionID;
+    internalSessions.add(id);
+    await resilience.run(provider, () => withTimeout(ctx.client.session.prompt({
+      path: { id },
       body: {
         parts: [{ type: "text", text: prompt }],
         agent
       },
       query: { directory: ctx.directory }
-    }), timeoutMs, `${agent} (${description})`);
-    const messagesResp = await ctx.client.session.messages({
-      path: { id: sessionID },
+    }), timeoutMs, `${agent} (${description})`), { maxAttempts: 4 });
+    const messagesResp = await resilience.run(provider, () => ctx.client.session.messages({
+      path: { id },
       query: { directory: ctx.directory }
-    });
+    }), { maxAttempts: 3 });
     const messages = messagesResp.data ?? [];
     const lastAssistant = messages.filter((m) => m.info?.role === "assistant").pop();
     const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
 `) ?? "(No response from agent)";
-    internalSessions.delete(sessionID);
-    await ctx.client.session.delete({ path: { id: sessionID }, query: { directory: ctx.directory } }).catch(() => {});
+    internalSessions.delete(id);
+    await ctx.client.session.delete({ path: { id }, query: { directory: ctx.directory } }).catch(() => {});
     const agentTime = ((Date.now() - t0) / 1000).toFixed(1);
     log(`spawn_agent: ${agent} done`, { seconds: agentTime, description });
     const result = sanitizeSpawnResult(rawResult);
@@ -27979,6 +28283,11 @@ ${result}`;
 }
 function createSpawnAgentTool(ctx, internalSessions, deps = {}) {
   const maxTotalSpawned = deps.maxTotalSpawned ?? DEFAULT_MAX_TOTAL_SPAWNED;
+  const resilience = deps.resilience ?? new ProviderResilience({
+    breaker: { failureThreshold: 3, cooldownMs: 1e4 },
+    retryBudget: { maxRetries: 20, intervalMs: 60000 },
+    retry: { maxAttempts: 4, backoff: { baseDelayMs: 200, maxDelayMs: 1e4, jitter: "full" } }
+  });
   return tool({
     description: `Spawn subagents to execute tasks in PARALLEL.
 All agents in the array run concurrently (respecting concurrency limits if configured).
@@ -28043,7 +28352,8 @@ spawn_agent({
         const task = agents[0];
         toolCtx.metadata({ title: `${task.agent}: ${task.description}...` });
         const model = resolveTaskModel(task, deps);
-        const execute = () => runAgent(ctx, task, toolCtx, internalSessions, deps);
+        const provider = model ? extractProvider(model) : "unknown";
+        const execute = () => runAgent(ctx, task, toolCtx, internalSessions, resilience, provider, deps);
         let result;
         if (deps.pool && model) {
           result = await deps.pool.run(model, execute);
@@ -28060,7 +28370,8 @@ spawn_agent({
       });
       const tasks = agents.map(async (task) => {
         const model = resolveTaskModel(task, deps);
-        const execute = () => runAgent(ctx, task, toolCtx, internalSessions, deps, progress);
+        const provider = model ? extractProvider(model) : "unknown";
+        const execute = () => runAgent(ctx, task, toolCtx, internalSessions, resilience, provider, deps, progress);
         let result;
         if (deps.pool && model) {
           result = await deps.pool.run(model, execute);
@@ -28106,6 +28417,14 @@ var COMPLETION_MARKER = "<promise>DONE</promise>";
 var DEFAULT_MAX_ITERATIONS = 10;
 var DEFAULT_ITERATION_TIMEOUT_MS = 180000;
 var activeLoops = new Map;
+function getActiveRalphLoops() {
+  return [...activeLoops.values()].map((s) => ({
+    sessionID: s.sessionID,
+    iteration: s.iteration,
+    maxIterations: s.maxIterations,
+    active: s.active
+  }));
+}
 async function withTimeout2(promise3, ms, label) {
   let timer;
   const timeout = new Promise((_, reject) => {
@@ -29083,8 +29402,15 @@ import { spawnSync as spawnSync2 } from "child_process";
 import * as fs9 from "fs";
 import * as path9 from "path";
 var COMPLETION_MARKER2 = "<promise>DONE</promise>";
-var DEFAULT_MAX_ITERATIONS2 = 10;
-var DEFAULT_ITERATION_TIMEOUT_MS2 = 300000;
+var COMPLETION_PATTERNS = [
+  COMPLETION_MARKER2,
+  "<promise>done</promise>",
+  "IMPLEMENTATION COMPLETE",
+  "Implementation complete"
+];
+var DEFAULT_MAX_ITERATIONS2 = 5;
+var DEFAULT_ITERATION_TIMEOUT_MS2 = 120000;
+var DEFAULT_TOTAL_TIMEOUT_MS = 600000;
 async function withTimeout3(promise3, ms, label) {
   let timer;
   const timeout = new Promise((_, reject) => {
@@ -29170,36 +29496,34 @@ function buildProjectInfo(cwd) {
   }
 }
 var IMPLEMENT_PROMPT = (proposal, projectInfo) => `
-[EVOLVE IMPLEMENTATION \u2014 AUTONOMOUS MODE]
+[EVOLVE \u2014 AUTONOMOUS IMPLEMENTATION]
 
-## Task
-Implement the following improvement proposal for this project:
+You MUST complete this in a SINGLE iteration. Do not wait for follow-up prompts.
 
-**Title**: ${proposal.title}
-**Priority**: ${proposal.priority} | **Effort**: ${proposal.effort}
-**Description**: ${proposal.description}
-${proposal.currentState ? `**Current State**: ${proposal.currentState}` : ""}
-${proposal.files?.length ? `**Target Files**: ${proposal.files.join(", ")}` : ""}
-${proposal.inspiration ? `**Inspiration**: ${proposal.inspiration}` : ""}
+## Proposal
+- **Title**: ${proposal.title}
+- **Priority**: ${proposal.priority} | **Effort**: ${proposal.effort}
+${proposal.description ? `- **What to do**: ${proposal.description}` : ""}
+${proposal.currentState ? `- **Current state**: ${proposal.currentState}` : ""}
+${proposal.files?.length ? `- **Target files**: ${proposal.files.join(", ")}` : ""}
 
-## Project Context
+## Project
 ${projectInfo}
 
-## Requirements
-1. Implement the feature described above
-2. Write unit tests in \`__test__/\` directory (same naming pattern as existing tests)
-3. Ensure all existing tests still pass
-4. Follow existing code patterns and conventions:
-   - Use \`@opencode-ai/plugin\` tool() API for new tools
-   - Pure functions where possible, side effects isolated
-   - TypeScript strict mode compatible
-   - Use zod for schema validation
-   - Export types from the module
-5. Do NOT modify unrelated files
-6. Do NOT add unnecessary dependencies
+## Steps (execute ALL in order)
+1. Read the target files to understand current code
+2. Write the implementation (new files or edits)
+3. Write tests in \`__test__/\` matching existing patterns
+4. Verify your changes compile (no syntax errors)
+
+## Rules
+- Do NOT touch unrelated files
+- Do NOT add dependencies
+- Follow existing code patterns (TypeScript strict, pure functions, zod schemas)
+- Keep changes minimal and focused
 
-## Completion
-When fully implemented and tested, output: ${COMPLETION_MARKER2}
+## When done
+Output exactly: ${COMPLETION_MARKER2}
 `;
 var REVIEW_PROMPT = (proposal, diff, testOutput) => `
 [CODE REVIEW \u2014 EVOLVE IMPLEMENTATION]
@@ -29231,21 +29555,24 @@ Then overall: APPROVE / APPROVE_WITH_WARNINGS / BLOCK
 
 If BLOCK: explain what must be fixed before merging.
 `;
-function buildContinuationPrompt2(original, iteration) {
-  return `[Evolve Exe \u2014 Iteration ${iteration}]
+function buildContinuationPrompt2(_original, iteration, maxIterations) {
+  return `[Evolve Exe \u2014 Iteration ${iteration}/${maxIterations}]
 
-IMPORTANT:
-- Review your progress so far
-- Continue from where you left off
-- When FULLY complete, output exactly: ${COMPLETION_MARKER2}
-- Do not stop until the task is truly done
+Continue from where you left off. This is iteration ${iteration} of ${maxIterations} \u2014 if you do not finish now, the implementation will be rolled back.
 
-Original task:
-${original}`;
+Finish all remaining work and output: ${COMPLETION_MARKER2}`;
+}
+function isCompletionDetected(text) {
+  return COMPLETION_PATTERNS.some((p) => text.includes(p));
+}
+function getFileChanges(cwd) {
+  const result = spawnSync2("git", ["diff", "--stat"], { cwd, encoding: "utf-8", timeout: 1e4 });
+  return (result.stdout ?? "").trim();
 }
 function createEvolveExeTool(ctx, internalSessions, deps = {}) {
   const maxIterations = deps.evolveExeConfig?.maxIterations ?? DEFAULT_MAX_ITERATIONS2;
   const iterationTimeoutMs = deps.evolveExeConfig?.iterationTimeoutMs ?? deps.agentTimeoutMs ?? DEFAULT_ITERATION_TIMEOUT_MS2;
+  const totalTimeoutMs = deps.evolveExeConfig?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
   const configSkipReview = deps.evolveExeConfig?.skipReview ?? false;
   const configSkipTests = deps.evolveExeConfig?.skipTests ?? false;
   return tool({
@@ -29337,6 +29664,7 @@ Failed to determine current git branch. Is this a git repository?`;
           skipReview,
           maxIterations,
           iterationTimeoutMs,
+          totalTimeoutMs,
           progressLabel: `[${i + 1}/${selected.length}]`
         });
         results.push(result);
@@ -29381,6 +29709,7 @@ async function executeProposal(args) {
     skipReview,
     maxIterations,
     iterationTimeoutMs,
+    totalTimeoutMs,
     progressLabel
   } = args;
   const slug = slugify2(proposal.title);
@@ -29408,6 +29737,7 @@ async function executeProposal(args) {
       projectInfo,
       maxIterations,
       iterationTimeoutMs,
+      totalTimeoutMs,
       toolCtx,
       progressLabel
     });
@@ -29477,7 +29807,8 @@ async function rollback(cwd, originalBranch, branchName) {
   log(`evolve_exe: rolled back branch ${branchName}`);
 }
 async function runImplementation(args) {
-  const { ctx, internalSessions, proposal, projectInfo, maxIterations, iterationTimeoutMs, toolCtx, progressLabel } = args;
+  const { ctx, internalSessions, proposal, projectInfo, maxIterations, iterationTimeoutMs, totalTimeoutMs, toolCtx, progressLabel } = args;
+  const pipelineStart = Date.now();
   const sessionResp = await ctx.client.session.create({
     body: {},
     query: { directory: ctx.directory }
@@ -29487,12 +29818,21 @@ async function runImplementation(args) {
     return { ok: false, error: "Failed to create implementation session" };
   internalSessions.add(sessionID);
   const initialPrompt = IMPLEMENT_PROMPT(proposal, projectInfo);
+  let lastDiffStat = getFileChanges(ctx.directory);
+  let staleCount = 0;
   try {
     for (let i = 0;i < maxIterations; i++) {
+      const elapsed = Date.now() - pipelineStart;
+      if (elapsed > totalTimeoutMs) {
+        log(`evolve_exe: total timeout exceeded (${(elapsed / 1000).toFixed(0)}s)`);
+        return { ok: false, error: `Total timeout (${(totalTimeoutMs / 1000).toFixed(0)}s) exceeded at iteration ${i + 1}` };
+      }
+      const remaining = totalTimeoutMs - elapsed;
+      const effectiveTimeout = Math.min(iterationTimeoutMs, remaining);
       toolCtx.metadata({
-        title: `${progressLabel} #${proposal.index}: implementing [${i + 1}/${maxIterations}]`
+        title: `${progressLabel} #${proposal.index}: implementing [${i + 1}/${maxIterations}] (${(elapsed / 1000).toFixed(0)}s)`
       });
-      const prompt = i === 0 ? initialPrompt : buildContinuationPrompt2(initialPrompt, i + 1);
+      const prompt = i === 0 ? initialPrompt : buildContinuationPrompt2(initialPrompt, i + 1, maxIterations);
       try {
         await withTimeout3(ctx.client.session.prompt({
           path: { id: sessionID },
@@ -29501,11 +29841,16 @@ async function runImplementation(args) {
             agent: "hephaestus"
           },
           query: { directory: ctx.directory }
-        }), iterationTimeoutMs, `evolve_exe implementation iteration ${i + 1}`);
+        }), effectiveTimeout, `evolve_exe implementation iteration ${i + 1}`);
       } catch (iterError) {
         const msg = iterError instanceof Error ? iterError.message : String(iterError);
         if (msg.startsWith("Timeout:")) {
-          log(`evolve_exe: implementation iteration ${i + 1} timed out`);
+          const currentDiff2 = getFileChanges(ctx.directory);
+          if (currentDiff2 && currentDiff2 !== lastDiffStat) {
+            log(`evolve_exe: iteration ${i + 1} timed out but has file changes \u2014 treating as complete`);
+            return { ok: true };
+          }
+          log(`evolve_exe: implementation iteration ${i + 1} timed out with no progress`);
           return { ok: false, error: `Implementation timed out at iteration ${i + 1}` };
         }
         throw iterError;
@@ -29518,13 +29863,29 @@ async function runImplementation(args) {
       const lastAssistant = messages.filter((m) => m.info?.role === "assistant").pop();
       const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
 `) ?? "";
-      if (rawResult.includes(COMPLETION_MARKER2)) {
+      if (isCompletionDetected(rawResult)) {
         log(`evolve_exe: implementation completed at iteration ${i + 1}`);
         return { ok: true };
       }
-      log(`evolve_exe: implementation iteration ${i + 1}/${maxIterations} \u2014 no completion marker`);
+      const currentDiff = getFileChanges(ctx.directory);
+      if (currentDiff === lastDiffStat) {
+        staleCount++;
+        log(`evolve_exe: no file changes after iteration ${i + 1} (stale=${staleCount})`);
+        if (staleCount >= 2) {
+          return { ok: false, error: `No progress after ${staleCount} consecutive iterations \u2014 aborting` };
+        }
+      } else {
+        staleCount = 0;
+        lastDiffStat = currentDiff;
+      }
+      log(`evolve_exe: implementation iteration ${i + 1}/${maxIterations} \u2014 continuing`);
+    }
+    const finalDiff = getFileChanges(ctx.directory);
+    if (finalDiff) {
+      log(`evolve_exe: max iterations reached but files changed \u2014 treating as complete`);
+      return { ok: true };
     }
-    return { ok: false, error: `Max iterations (${maxIterations}) reached without completion` };
+    return { ok: false, error: `Max iterations (${maxIterations}) reached without completion or file changes` };
   } finally {
     internalSessions.delete(sessionID);
     await ctx.client.session.delete({ path: { id: sessionID }, query: { directory: ctx.directory } }).catch(() => {});
@@ -29677,6 +30038,300 @@ Git working directory is not clean. Commit or stash changes before publishing.
   });
 }
 
+// src/tools/health-check.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import * as fs11 from "fs";
+import * as path11 from "path";
+
+// src/mcp/servers.ts
+var BUILTIN_MCPS = {
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp@latest"]
+  }
+};
+
+// src/mcp/index.ts
+async function registerMcps(ctx, disabled, apiKeys) {
+  const disabledSet = new Set(disabled);
+  const keys = apiKeys ?? {};
+  for (const [name, config3] of Object.entries(BUILTIN_MCPS)) {
+    if (disabledSet.has(name)) {
+      log(`MCP ${name} disabled by config`);
+      continue;
+    }
+    try {
+      const args = [...config3.args];
+      const envKey = `${name.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+      const apiKey = keys[name] ?? process.env[envKey];
+      if (apiKey) {
+        args.push("--api-key", apiKey);
+      }
+      const body = {
+        name,
+        command: config3.command,
+        args
+      };
+      if (config3.env) {
+        body.env = config3.env;
+      }
+      const client = ctx.client;
+      await client.mcp?.add?.({ body });
+      log(`MCP ${name} registered${apiKey ? " (with API key)" : ""}`);
+    } catch (err) {
+      log(`MCP ${name} registration failed: ${err}`);
+    }
+  }
+}
+
+// src/tools/health-check.ts
+var BUILTIN_HOOK_IDS = [
+  "keyword-detector",
+  "rules-injector",
+  "context-injector",
+  "fragment-injector",
+  "prompt-renderer",
+  "todo-enforcer",
+  "comment-checker",
+  "token-truncation",
+  "session-compaction"
+];
+var BUILTIN_TOOL_IDS = [
+  "spawn_agent",
+  "ralph_loop",
+  "cancel_ralph",
+  "batch_read",
+  "ledger_save",
+  "ledger_load",
+  "ast_search",
+  "evolve_apply",
+  "evolve_scan",
+  "evolve_score",
+  "evolve_exe",
+  "evolve_publish",
+  "health_check"
+];
+var BinaryStatusSchema = exports_external.object({
+  found: exports_external.boolean(),
+  path: exports_external.string().optional(),
+  version: exports_external.string().optional(),
+  error: exports_external.string().optional()
+});
+var HealthCheckResultSchema = exports_external.object({
+  ok: exports_external.boolean(),
+  generatedAt: exports_external.string(),
+  registry: exports_external.object({
+    tools: exports_external.object({
+      enabled: exports_external.array(exports_external.string()),
+      disabled: exports_external.array(exports_external.string()),
+      unknownDisabled: exports_external.array(exports_external.string())
+    }),
+    hooks: exports_external.object({
+      enabled: exports_external.array(exports_external.string()),
+      disabled: exports_external.array(exports_external.string()),
+      unknownDisabled: exports_external.array(exports_external.string())
+    }),
+    mcps: exports_external.object({
+      enabled: exports_external.array(exports_external.string()),
+      disabled: exports_external.array(exports_external.string()),
+      unknownDisabled: exports_external.array(exports_external.string())
+    })
+  }),
+  loops: exports_external.object({
+    ralph: exports_external.object({
+      activeCount: exports_external.number(),
+      active: exports_external.array(exports_external.object({
+        sessionID: exports_external.string(),
+        iteration: exports_external.number(),
+        maxIterations: exports_external.number(),
+        active: exports_external.boolean()
+      }))
+    })
+  }),
+  sessions: exports_external.object({
+    internalSessionCount: exports_external.number()
+  }),
+  config: exports_external.object({
+    astSearch: exports_external.object({
+      enabled: exports_external.boolean(),
+      binaryFound: exports_external.boolean(),
+      binaryPath: exports_external.string().optional()
+    }),
+    mcp: exports_external.object({
+      context7: exports_external.object({
+        enabled: exports_external.boolean(),
+        npxFound: exports_external.boolean(),
+        npxPath: exports_external.string().optional()
+      })
+    })
+  }),
+  binaries: exports_external.record(exports_external.string(), BinaryStatusSchema),
+  warnings: exports_external.array(exports_external.string())
+});
+function splitPathEnv() {
+  const raw = process.env.PATH ?? "";
+  const sep = path11.delimiter;
+  return raw.split(sep).filter(Boolean);
+}
+function isExecutable(p) {
+  try {
+    const stat = fs11.statSync(p);
+    if (!stat.isFile())
+      return false;
+    fs11.accessSync(p, fs11.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function candidateNames(base) {
+  if (process.platform !== "win32")
+    return [base];
+  return [base, `${base}.exe`, `${base}.cmd`, `${base}.bat`];
+}
+function findBinaryInPath(name) {
+  const dirs = splitPathEnv();
+  const candidates = candidateNames(name);
+  for (const dir of dirs) {
+    for (const c of candidates) {
+      const full = path11.join(dir, c);
+      if (isExecutable(full))
+        return full;
+    }
+  }
+  return null;
+}
+function getVersion(exePath, args) {
+  try {
+    const out = spawnSync4(exePath, args, { encoding: "utf-8" });
+    const stdout = (out.stdout ?? "").toString().trim();
+    const stderr = (out.stderr ?? "").toString().trim();
+    if (out.status === 0) {
+      const firstLine = (stdout || stderr).split(/\r?\n/)[0]?.trim();
+      return firstLine ? { version: firstLine } : {};
+    }
+    const msg = stderr || stdout;
+    return msg ? { error: msg.split(/\r?\n/)[0].trim() } : { error: `Exit code ${out.status ?? "unknown"}` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { error: msg };
+  }
+}
+function checkBinary(name, versionArgs = ["--version"], includeVersion = true) {
+  const p = findBinaryInPath(name);
+  if (!p)
+    return { found: false };
+  if (!includeVersion)
+    return { found: true, path: p };
+  const v = getVersion(p, versionArgs);
+  return { found: true, path: p, version: v.version, error: v.error };
+}
+function uniqSorted(xs) {
+  return [...new Set(xs)].sort((a, b) => a.localeCompare(b));
+}
+function computeUnknownDisabled(disabled, known) {
+  const set3 = new Set(known);
+  return uniqSorted(disabled.filter((x) => !set3.has(x)));
+}
+function enabledFromDisabled(known, disabled) {
+  const dis = new Set(disabled);
+  return uniqSorted(known.filter((x) => !dis.has(x)));
+}
+function createHealthCheckTool(ctx, deps) {
+  return tool({
+    description: "Collect plugin health diagnostics: registered hooks/tools, active loops, config consistency, and dependency binaries.",
+    args: {
+      includeVersions: tool.schema.boolean().optional().describe("If true, run each binary with --version (default: false)")
+    },
+    execute: async (args) => {
+      const includeVersions = args.includeVersions ?? false;
+      const disabledTools = deps.disabledTools ?? [];
+      const disabledHooks = deps.disabledHooks ?? [];
+      const disabledMcps = deps.disabledMcps ?? [];
+      const knownTools = [...BUILTIN_TOOL_IDS];
+      const knownHooks = [...BUILTIN_HOOK_IDS];
+      const knownMcps = Object.keys(BUILTIN_MCPS);
+      const enabledTools = uniqSorted(deps.toolNames);
+      const enabledHooks = enabledFromDisabled(knownHooks, disabledHooks);
+      const enabledMcps = enabledFromDisabled(knownMcps, disabledMcps);
+      const unknownDisabledTools = computeUnknownDisabled(disabledTools, knownTools);
+      const unknownDisabledHooks = computeUnknownDisabled(disabledHooks, knownHooks);
+      const unknownDisabledMcps = computeUnknownDisabled(disabledMcps, knownMcps);
+      const astPath = deps.astGrepBinary !== undefined ? deps.astGrepBinary : findAstGrepBinary();
+      const astEnabled = !disabledTools.includes("ast_search");
+      const astFound = Boolean(astPath);
+      const binaries = {};
+      binaries.node = checkBinary("node", ["--version"], includeVersions);
+      binaries.bun = checkBinary("bun", ["--version"], includeVersions);
+      binaries.npx = checkBinary("npx", ["--version"], includeVersions);
+      binaries.git = checkBinary("git", ["--version"], includeVersions);
+      binaries.gh = checkBinary("gh", ["--version"], includeVersions);
+      binaries.rg = checkBinary("rg", ["--version"], includeVersions);
+      if (astPath) {
+        const v = includeVersions ? getVersion(astPath, ["--version"]) : {};
+        binaries["ast-grep"] = { found: true, path: astPath, version: v.version, error: v.error };
+      } else {
+        const ast = checkBinary("sg", ["--version"], includeVersions);
+        binaries["ast-grep"] = ast.found ? ast : { found: false };
+      }
+      const context7Enabled = enabledMcps.includes("context7");
+      const npxFound = binaries.npx.found;
+      const warnings = [];
+      if (unknownDisabledTools.length > 0)
+        warnings.push(`Unknown disabled tool id(s): ${unknownDisabledTools.join(", ")}`);
+      if (unknownDisabledHooks.length > 0)
+        warnings.push(`Unknown disabled hook id(s): ${unknownDisabledHooks.join(", ")}`);
+      if (unknownDisabledMcps.length > 0)
+        warnings.push(`Unknown disabled mcp id(s): ${unknownDisabledMcps.join(", ")}`);
+      if (astEnabled && !astFound)
+        warnings.push("ast_search is enabled but ast-grep binary was not found in PATH");
+      if (context7Enabled && !npxFound)
+        warnings.push("MCP 'context7' is enabled but 'npx' was not found in PATH");
+      const active = getActiveRalphLoops();
+      const result = {
+        ok: warnings.length === 0,
+        generatedAt: new Date().toISOString(),
+        registry: {
+          tools: { enabled: enabledTools, disabled: uniqSorted(disabledTools), unknownDisabled: unknownDisabledTools },
+          hooks: { enabled: enabledHooks, disabled: uniqSorted(disabledHooks), unknownDisabled: unknownDisabledHooks },
+          mcps: { enabled: enabledMcps, disabled: uniqSorted(disabledMcps), unknownDisabled: unknownDisabledMcps }
+        },
+        loops: {
+          ralph: { activeCount: active.length, active }
+        },
+        sessions: {
+          internalSessionCount: deps.internalSessions?.size ?? 0
+        },
+        config: {
+          astSearch: {
+            enabled: astEnabled,
+            binaryFound: astFound,
+            binaryPath: astPath ?? undefined
+          },
+          mcp: {
+            context7: {
+              enabled: context7Enabled,
+              npxFound,
+              npxPath: binaries.npx.path
+            }
+          }
+        },
+        binaries,
+        warnings
+      };
+      const parsed = HealthCheckResultSchema.safeParse(result);
+      if (!parsed.success) {
+        return {
+          ok: false,
+          generatedAt: result.generatedAt,
+          error: parsed.error.issues.map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join("; ")
+        };
+      }
+      return result;
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -29759,7 +30414,7 @@ ${unfinished.map((t) => `- [ ] ${t.text}`).join(`
 }
 
 // src/hooks/comment-checker.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 var AI_SLOP_PATTERNS = [
   /\/\/ .{80,}/,
   /\/\/ (This|The|We|Here|Note:)/i,
@@ -29838,7 +30493,7 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
     if (!filePath || !isCodeFile(filePath))
       return;
     try {
-      const content = fs11.readFileSync(filePath, "utf-8");
+      const content = fs12.readFileSync(filePath, "utf-8");
       const result = checkComments(content, filePath, maxRatio, slopThreshold);
       if (result.shouldWarn) {
         output.output += `
@@ -29997,127 +30652,6 @@ function createSessionCompactionHook(ctx, internalSessions) {
   };
 }
 
-// src/concurrency/semaphore.ts
-class Semaphore {
-  max;
-  queue = [];
-  active = 0;
-  constructor(max) {
-    this.max = max;
-  }
-  async acquire() {
-    if (this.active < this.max) {
-      this.active++;
-      return;
-    }
-    return new Promise((resolve2) => {
-      this.queue.push(() => {
-        this.active++;
-        resolve2();
-      });
-    });
-  }
-  release() {
-    if (this.active <= 0)
-      return;
-    this.active--;
-    const next = this.queue.shift();
-    if (next)
-      next();
-  }
-  get pending() {
-    return this.queue.length;
-  }
-  get running() {
-    return this.active;
-  }
-}
-// src/concurrency/pool.ts
-function extractProvider(model) {
-  const slash = model.indexOf("/");
-  return slash > 0 ? model.slice(0, slash) : model;
-}
-
-class ConcurrencyPool {
-  global;
-  providers = new Map;
-  models = new Map;
-  config;
-  constructor(config3) {
-    this.config = config3;
-    this.global = new Semaphore(config3.defaultConcurrency ?? Infinity);
-    for (const [provider, limit] of Object.entries(config3.providerConcurrency ?? {})) {
-      this.providers.set(provider, new Semaphore(limit));
-    }
-    for (const [model, limit] of Object.entries(config3.modelConcurrency ?? {})) {
-      this.models.set(model, new Semaphore(limit));
-    }
-  }
-  async run(model, fn) {
-    const provider = extractProvider(model);
-    const semaphores = [];
-    const modelSem = this.models.get(model);
-    if (modelSem) {
-      await modelSem.acquire();
-      semaphores.push(modelSem);
-    }
-    const providerSem = this.providers.get(provider);
-    if (providerSem) {
-      await providerSem.acquire();
-      semaphores.push(providerSem);
-    }
-    await this.global.acquire();
-    semaphores.push(this.global);
-    try {
-      return await fn();
-    } finally {
-      for (let i = semaphores.length - 1;i >= 0; i--) {
-        semaphores[i].release();
-      }
-    }
-  }
-}
-// src/mcp/servers.ts
-var BUILTIN_MCPS = {
-  context7: {
-    command: "npx",
-    args: ["-y", "@upstash/context7-mcp@latest"]
-  }
-};
-
-// src/mcp/index.ts
-async function registerMcps(ctx, disabled, apiKeys) {
-  const disabledSet = new Set(disabled);
-  const keys = apiKeys ?? {};
-  for (const [name, config3] of Object.entries(BUILTIN_MCPS)) {
-    if (disabledSet.has(name)) {
-      log(`MCP ${name} disabled by config`);
-      continue;
-    }
-    try {
-      const args = [...config3.args];
-      const envKey = `${name.toUpperCase().replace(/-/g, "_")}_API_KEY`;
-      const apiKey = keys[name] ?? process.env[envKey];
-      if (apiKey) {
-        args.push("--api-key", apiKey);
-      }
-      const body = {
-        name,
-        command: config3.command,
-        args
-      };
-      if (config3.env) {
-        body.env = config3.env;
-      }
-      const client = ctx.client;
-      await client.mcp?.add?.({ body });
-      log(`MCP ${name} registered${apiKey ? " (with API key)" : ""}`);
-    } catch (err) {
-      log(`MCP ${name} registration failed: ${err}`);
-    }
-  }
-}
-
 // src/index.ts
 var OpenCodeUltra = async (ctx) => {
   log("ENTRY \u2014 plugin loading", { directory: ctx.directory });
@@ -30227,6 +30761,16 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("evolve_publish")) {
     toolRegistry.evolve_publish = createEvolvePublishTool();
   }
+  if (!disabledTools.has("health_check")) {
+    toolRegistry.health_check = createHealthCheckTool(ctx, {
+      toolNames: Object.keys(toolRegistry),
+      disabledTools: [...disabledTools],
+      disabledHooks: [...pluginConfig.disabled_hooks ?? []],
+      disabledMcps: [...pluginConfig.disabled_mcps ?? []],
+      internalSessions,
+      astGrepBinary: findAstGrepBinary()
+    });
+  }
   return {
     tool: toolRegistry,
     config: async (config3) => {

package/dist/shared/concurrency.d.ts

@@ -0,0 +1,109 @@
+export interface BackoffOptions {
+    /** Base delay in ms (default: 200) */
+    baseDelayMs?: number;
+    /** Max delay in ms (default: 10_000) */
+    maxDelayMs?: number;
+}
+export type BackoffJitterMode = "full" | "none";
+export interface ExponentialBackoffOptions extends BackoffOptions {
+    /** Jitter strategy (default: full) */
+    jitter?: BackoffJitterMode;
+    /** Random generator in [0, 1) (default: Math.random) */
+    rng?: () => number;
+}
+export declare function computeExponentialBackoffDelayMs(attempt: number, opts?: ExponentialBackoffOptions): number;
+export interface CircuitBreakerOptions {
+    /** Open circuit after this many consecutive retryable failures (default: 3) */
+    failureThreshold?: number;
+    /** How long the circuit stays open before allowing a single trial (default: 10_000) */
+    cooldownMs?: number;
+}
+type CircuitState = "closed" | "open" | "half_open";
+export declare class CircuitBreakerOpenError extends Error {
+    readonly provider: string;
+    readonly waitMs: number;
+    constructor(provider: string, waitMs: number);
+}
+export declare class CircuitBreaker {
+    private state;
+    private consecutiveFailures;
+    private openUntil;
+    private halfOpenInFlight;
+    private failureThreshold;
+    private cooldownMs;
+    constructor(opts?: CircuitBreakerOptions);
+    snapshot(now: number): {
+        state: CircuitState;
+        consecutiveFailures: number;
+        openForMs: number;
+    };
+    /**
+     * Gate a request. If open, returns not allowed with waitMs.
+     * If half-open, only allows a single in-flight probe.
+     */
+    enter(now: number): {
+        allowed: boolean;
+        waitMs?: number;
+    };
+    onSuccess(): void;
+    onFailure(now: number): void;
+}
+export interface RetryBudgetOptions {
+    /** Max retries per provider per interval (default: 20) */
+    maxRetries?: number;
+    /** Interval for budget reset (default: 60_000) */
+    intervalMs?: number;
+}
+export declare class RetryBudgetExceededError extends Error {
+    readonly provider: string;
+    constructor(provider: string);
+}
+export declare class RetryBudget {
+    private maxRetries;
+    private intervalMs;
+    private state;
+    constructor(opts?: RetryBudgetOptions);
+    trySpend(provider: string, cost?: number): boolean;
+}
+export interface RetryDecision {
+    retryable: boolean;
+    /** HTTP status code when available */
+    status?: number;
+    /** Retry-After when available */
+    retryAfterMs?: number;
+}
+export declare function parseRetryAfterMs(value: string, now: number): number | undefined;
+export declare function classifyRetryableError(err: unknown, now?: number): RetryDecision;
+export interface AdaptiveRetryOptions {
+    /** Max total attempts including the first attempt (default: 4) */
+    maxAttempts?: number;
+    /** Backoff options (default: base 200, max 10_000) */
+    backoff?: ExponentialBackoffOptions;
+    /** Cap any retry-after delays to this max (default: 30_000) */
+    maxRetryAfterMs?: number;
+    /** Treat this classifier result as authoritative (default: classifyRetryableError) */
+    classify?: (err: unknown, now: number) => RetryDecision;
+    /** Sleep function used for delays (default: setTimeout) */
+    sleep?: (ms: number) => Promise<void>;
+    /** Time source (default: Date.now) */
+    now?: () => number;
+}
+export declare function adaptiveRetry<T>(provider: string, fn: () => Promise<T>, breaker: CircuitBreaker, budget: RetryBudget, opts?: AdaptiveRetryOptions): Promise<T>;
+export interface ProviderResilienceOptions {
+    breaker?: CircuitBreakerOptions;
+    retryBudget?: RetryBudgetOptions;
+    retry?: AdaptiveRetryOptions;
+}
+export declare class ProviderResilience {
+    private breakers;
+    private budgets;
+    private opts;
+    constructor(opts?: ProviderResilienceOptions);
+    private getBreaker;
+    private getBudget;
+    run<T>(provider: string, fn: () => Promise<T>, retryOverrides?: AdaptiveRetryOptions): Promise<T>;
+    snapshot(provider: string, now?: number): {
+        breaker: ReturnType<CircuitBreaker["snapshot"]>;
+    };
+}
+export {};

package/dist/shared/index.d.ts

@@ -3,3 +3,5 @@ export { parseJsonc } from "./jsonc";
 export { log } from "./log";
 export type { ExtendedClient, ModelRef, ToastOptions, SystemTransformInput } from "./types";
 export { TtlMap } from "./ttl-map";
+export { CircuitBreaker, CircuitBreakerOpenError, ProviderResilience, RetryBudget, RetryBudgetExceededError, adaptiveRetry, classifyRetryableError, computeExponentialBackoffDelayMs, parseRetryAfterMs, } from "./concurrency";
+export type { AdaptiveRetryOptions, BackoffJitterMode, BackoffOptions, CircuitBreakerOptions, ExponentialBackoffOptions, ProviderResilienceOptions, RetryBudgetOptions, RetryDecision, } from "./concurrency";

package/dist/tools/health-check.d.ts

@@ -0,0 +1,73 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { type ActiveRalphLoopInfo } from "./ralph-loop";
+export declare const BUILTIN_HOOK_IDS: readonly ["keyword-detector", "rules-injector", "context-injector", "fragment-injector", "prompt-renderer", "todo-enforcer", "comment-checker", "token-truncation", "session-compaction"];
+export declare const BUILTIN_TOOL_IDS: readonly ["spawn_agent", "ralph_loop", "cancel_ralph", "batch_read", "ledger_save", "ledger_load", "ast_search", "evolve_apply", "evolve_scan", "evolve_score", "evolve_exe", "evolve_publish", "health_check"];
+export type BuiltinHookId = (typeof BUILTIN_HOOK_IDS)[number];
+export type BuiltinToolId = (typeof BUILTIN_TOOL_IDS)[number];
+export interface BinaryStatus {
+    found: boolean;
+    path?: string;
+    version?: string;
+    error?: string;
+}
+export interface HealthCheckResult {
+    ok: boolean;
+    generatedAt: string;
+    registry: {
+        tools: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+        hooks: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+        mcps: {
+            enabled: string[];
+            disabled: string[];
+            unknownDisabled: string[];
+        };
+    };
+    loops: {
+        ralph: {
+            activeCount: number;
+            active: ActiveRalphLoopInfo[];
+        };
+    };
+    sessions: {
+        internalSessionCount: number;
+    };
+    config: {
+        astSearch: {
+            enabled: boolean;
+            binaryFound: boolean;
+            binaryPath?: string;
+        };
+        mcp: {
+            context7: {
+                enabled: boolean;
+                npxFound: boolean;
+                npxPath?: string;
+            };
+        };
+    };
+    binaries: Record<string, BinaryStatus>;
+    warnings: string[];
+}
+export declare const BinaryStatusSchema: z.ZodType<BinaryStatus>;
+export declare const HealthCheckResultSchema: z.ZodType<HealthCheckResult>;
+export interface HealthCheckDeps {
+    toolNames: string[];
+    disabledTools?: string[];
+    disabledHooks?: string[];
+    disabledMcps?: string[];
+    internalSessions?: Set<string>;
+    astGrepBinary?: string | null;
+}
+export declare function findBinaryInPath(name: string): string | null;
+export declare function checkBinary(name: string, versionArgs?: string[], includeVersion?: boolean): BinaryStatus;
+export declare function createHealthCheckTool(ctx: PluginInput, deps: HealthCheckDeps): ReturnType<typeof tool>;

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

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface ActiveRalphLoopInfo {
+    sessionID: string;
+    iteration: number;
+    maxIterations: number;
+    active: boolean;
+}
+export declare function getActiveRalphLoops(): ActiveRalphLoopInfo[];
+export interface RalphLoopDeps {
+    /** Per-iteration timeout in ms (default: 180000 = 3min) */
+    iterationTimeoutMs?: number;
+}
+export declare function createRalphLoopTools(ctx: PluginInput, internalSessions: Set<string>, deps?: RalphLoopDeps): {
+    ralph_loop: any;
+    cancel_ralph: any;
+};

package/dist/tools/spawn-agent.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { ProviderResilience } from "../shared";
+import { type ConcurrencyPool } from "../concurrency";
+import type { CategoryConfig } from "../categories";
+export interface SpawnAgentDeps {
+    pool?: ConcurrencyPool;
+    categories?: Record<string, CategoryConfig>;
+    resolveAgentModel?: (agent: string) => string | undefined;
+    /** Provider-level retry/backoff + circuit breaker */
+    resilience?: ProviderResilience;
+    /** Max total concurrent spawned sessions (default: 15) */
+    maxTotalSpawned?: number;
+    /** Per-agent timeout in ms (default: 180000 = 3min) */
+    agentTimeoutMs?: number;
+    /** Reference to internalSessions for spawn limit check */
+    internalSessions?: Set<string>;
+}
+export declare function createSpawnAgentTool(ctx: PluginInput, internalSessions: Set<string>, deps?: SpawnAgentDeps): ReturnType<typeof tool>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",