opencode-reviewer 0.4.1 → 0.4.2

package/dist/tui.js

@@ -768,10 +768,10 @@ var FileScope = class {
 var fileAccess = new FileAccess();
 
 // src/context.ts
-async function loadInvocation(request, reader, signal) {
+async function loadInvocation(request, reader2, signal) {
   signal.throwIfAborted();
   if (!request.tool) throw new Error("Pending tool linkage unavailable");
-  const message = await reader.message(request.sessionID, request.tool.messageID, signal);
+  const message = await reader2.message(request.sessionID, request.tool.messageID, signal);
   signal.throwIfAborted();
   if (!message || message.info.role !== "assistant" || message.info.sessionID !== request.sessionID || message.info.id !== request.tool.messageID) {
     throw new Error("Pending tool message unavailable or mismatched");
@@ -787,6 +787,7 @@ async function loadInvocation(request, reader, signal) {
     info: message.info,
     tool: part.tool,
     input: part.state.input,
+    linkage: { sessionID: request.sessionID, messageID: request.tool.messageID, callID: request.tool.callID },
     location: {
       instanceDirectory: typeof invocation?.cwd === "string" && path2.isAbsolute(invocation.cwd) ? invocation.cwd : null,
       instanceWorktree: typeof invocation?.root === "string" && path2.isAbsolute(invocation.root) ? invocation.root : null
@@ -824,27 +825,33 @@ function findUserPrompt(messages, sessionID) {
 function latestUserPrompt(messages, sessionID) {
   return findUserPrompt(messages, sessionID)?.text ?? null;
 }
-async function loadContext(request, reader, signal, scope = fileAccess.scope(signal)) {
+async function nativeInvocation(request, reader2, signal, kind) {
+  try {
+    return await loadInvocation(request, reader2, signal);
+  } catch (error) {
+    signal.throwIfAborted();
+    throw new Error(`Pending native ${kind} message unavailable or arguments mismatched`, { cause: error });
+  }
+}
+function invocationFor(request, verified) {
+  if (verified.linkage.sessionID !== request.sessionID || verified.linkage.messageID !== request.tool?.messageID || verified.linkage.callID !== request.tool?.callID) throw new Error("Verified invocation linkage mismatched");
+  return verified;
+}
+async function loadContext(request, reader2, signal, scope = fileAccess.scope(signal), verified) {
+  signal.throwIfAborted();
   if (request.permission !== "bash" && request.permission !== "external_directory") return null;
   if (!request.tool) {
     if (request.permission === "external_directory") return null;
     throw new Error("Native shell tool context unavailable");
   }
-  const message = await reader.message(request.sessionID, request.tool.messageID, signal);
-  if (!message || message.info.sessionID !== request.sessionID || message.info.id !== request.tool.messageID) {
-    throw new Error("Pending native shell message unavailable");
-  }
-  const part = message?.parts.find((p) => p.type === "tool" && p.callID === request.tool.callID);
-  if (part?.type === "tool" && part.tool !== "bash" && request.permission === "external_directory") return null;
-  if (!part || part.type !== "tool" || part.sessionID !== request.sessionID || part.messageID !== request.tool.messageID || part.tool !== "bash" || part.state.status !== "running") {
-    throw new Error("Pending native shell arguments unavailable");
-  }
-  const { command, workdir } = part.state.input;
+  const invocation = verified ? invocationFor(request, verified) : await nativeInvocation(request, reader2, signal, "shell");
+  if (invocation.tool !== "bash" && request.permission === "external_directory") return null;
+  if (invocation.tool !== "bash") throw new Error("Pending native shell arguments unavailable");
+  const { command, workdir } = invocation.input;
+  if (typeof command === "string" && command.length > 16 * 1024 * 1024) throw new Error("Shell command exceeds the 16 MiB preprocessing limit");
   if (typeof command !== "string" || !command.trim()) throw new Error("Shell command unavailable");
   const limitations = [];
-  const invocation = message.info.role === "assistant" ? message.info.path : void 0;
-  const instanceDirectory = typeof invocation?.cwd === "string" && path2.isAbsolute(invocation.cwd) ? invocation.cwd : null;
-  const instanceWorktree = typeof invocation?.root === "string" && path2.isAbsolute(invocation.root) ? invocation.root : null;
+  const { instanceDirectory, instanceWorktree } = invocation.location;
   const invalidWorkdir = workdir !== void 0 && typeof workdir !== "string";
   const requestedWorkdir = typeof workdir === "string" && workdir ? workdir : null;
   const cwd = invalidWorkdir ? null : requestedWorkdir && path2.isAbsolute(requestedWorkdir) ? requestedWorkdir : instanceDirectory ? path2.resolve(instanceDirectory, requestedWorkdir ?? ".") : null;
@@ -859,7 +866,7 @@ async function loadContext(request, reader, signal, scope = fileAccess.scope(sig
     cwdSource: invalidWorkdir ? "unavailable" : requestedWorkdir && path2.isAbsolute(requestedWorkdir) ? "absolute tool.workdir" : instanceDirectory ? requestedWorkdir ? "tool.workdir relative to assistant.path.cwd" : "assistant.path.cwd" : "unavailable",
     canonicalCwd: null
   };
-  const conversation = await loadConversationContext(request, reader, signal);
+  const conversation = await loadConversationContext(request, reader2, signal);
   if (cwd) {
     const canonical = await scope.canonical(cwd);
     execution.canonicalCwd = canonical.path;
@@ -885,28 +892,20 @@ function permissionContext(request, clone = true) {
     tool: request.tool ? { ...request.tool } : null
   };
 }
-async function loadEditContext(request, reader, signal) {
+async function loadEditContext(request, reader2, signal, verified) {
   signal.throwIfAborted();
   if (request.permission !== "edit" || !request.tool) throw new Error("Native edit tool context unavailable");
-  const message = await reader.message(request.sessionID, request.tool.messageID, signal);
-  if (!message || message.info.sessionID !== request.sessionID || message.info.id !== request.tool.messageID) {
-    throw new Error("Pending native edit message unavailable");
-  }
-  const part = message.parts.find((p) => p.type === "tool" && p.callID === request.tool.callID);
-  if (!part || part.type !== "tool" || part.sessionID !== request.sessionID || part.messageID !== request.tool.messageID || part.state.status !== "running" || part.tool !== "edit" && part.tool !== "write" && part.tool !== "apply_patch") {
+  const invocation = verified ? invocationFor(request, verified) : await nativeInvocation(request, reader2, signal, "edit");
+  if (invocation.tool !== "edit" && invocation.tool !== "write" && invocation.tool !== "apply_patch") {
     throw new Error("Pending native edit arguments unavailable or unsupported tool");
   }
-  const invocation = message.info.role === "assistant" ? message.info.path : void 0;
-  const location = {
-    instanceDirectory: typeof invocation?.cwd === "string" && path2.isAbsolute(invocation.cwd) ? invocation.cwd : null,
-    instanceWorktree: typeof invocation?.root === "string" && path2.isAbsolute(invocation.root) ? invocation.root : null
-  };
-  const conversation = await loadConversationContext(request, reader, signal);
+  const location = invocation.location;
+  const conversation = await loadConversationContext(request, reader2, signal);
   if (!location.instanceDirectory) conversation.limitations.push("Edit invocation directory unavailable; session origin is not substituted.");
   if (!location.instanceWorktree) conversation.limitations.push("Edit invocation worktree unavailable.");
-  return { ...conversation, kind: "edit", tool: part.tool, location, permission: permissionContext(request) };
+  return { ...conversation, kind: "edit", tool: invocation.tool, location, permission: permissionContext(request, false) };
 }
-async function loadConversationContext(request, reader, signal) {
+async function loadConversationContext(request, reader2, signal) {
   signal.throwIfAborted();
   const limitations = [];
   let current;
@@ -915,7 +914,7 @@ async function loadConversationContext(request, reader, signal) {
   const contextEnd = performance.now() + Math.min(5e3, remainingTime(signal) / 3);
   const contextMs = () => Math.max(0, contextEnd - performance.now());
   const ancestry = async (contextSignal) => {
-    const loaded = await reader.session(request.sessionID, contextSignal);
+    const loaded = await reader2.session(request.sessionID, contextSignal);
     contextSignal.throwIfAborted();
     if (loaded?.id !== request.sessionID) throw new Error("Session mismatch");
     current = loaded;
@@ -926,13 +925,13 @@ async function loadConversationContext(request, reader, signal) {
       if (seen.has(ancestor.id) || seen.size >= 16) throw new Error("Parent chain incomplete");
       seen.add(ancestor.id);
       const expected = ancestor.parentID;
-      const parent = await reader.session(expected, contextSignal);
+      const parent = await reader2.session(expected, contextSignal);
       contextSignal.throwIfAborted();
       if (parent?.id !== expected) throw new Error("Parent session unavailable");
       ancestor = parent;
     }
     root = ancestor;
-    const messages = await reader.messages(root.id, contextSignal);
+    const messages = await reader2.messages(root.id, contextSignal);
     contextSignal.throwIfAborted();
     prompt2 = latestUserPrompt(messages, root.id);
   };
@@ -945,7 +944,7 @@ async function loadConversationContext(request, reader, signal) {
   let projects = [];
   if (current || root) {
     try {
-      projects = await withDeadline(signal, contextMs(), (contextSignal) => reader.projects(contextSignal), "Project context lookup");
+      projects = await withDeadline(signal, contextMs(), (contextSignal) => reader2.projects(contextSignal), "Project context lookup");
     } catch (error) {
       signal.throwIfAborted();
       limitations.push(error instanceof DeadlineError ? error.message : "OpenCode project metadata unavailable.");
@@ -1122,7 +1121,9 @@ function estimatedUsage(body, requestedModel, pricing) {
   const result = { input: usage.prompt_tokens, output: usage.completion_tokens };
   const prices = pricing?.(typeof body.model === "string" ? body.model : requestedModel);
   if (!prices) return result;
-  const details = record(usage.prompt_tokens_details);
+  const rawDetails = usage.prompt_tokens_details;
+  if (rawDetails !== void 0 && (!rawDetails || typeof rawDetails !== "object" || Array.isArray(rawDetails))) return result;
+  const details = record(rawDetails);
   const cached = details.cached_tokens === void 0 ? 0 : details.cached_tokens;
   const written = details.cache_write_tokens === void 0 ? 0 : details.cache_write_tokens;
   if (!count(cached) || !count(written) || cached + written > result.input || usage.cache_creation_input_tokens || usage.cache_read_input_tokens) return result;
@@ -1149,7 +1150,8 @@ function usageAttempt(baseURL, requestedModel, pricing, onUsage) {
         finalized = true;
         if (usage) {
           try {
-            onUsage?.({ ...usage });
+            void Promise.resolve(onUsage?.({ ...usage })).catch(() => {
+            });
           } catch {
           }
         }
@@ -1174,7 +1176,7 @@ function sumUsage(previous, next) {
 }
 function usageText(usage) {
   return [
-    ...count(usage.input) && count(usage.output) ? [`tokens in/out: ${usage.input}/${usage.output}`] : [],
+    ...count(usage.input) && count(usage.output) ? [`token: ${usage.input} in ${usage.output} out`] : [],
     ...usage.cost === void 0 ? [] : [`cost: $${usage.cost.toFixed(4)}`]
   ].join("\n");
 }
@@ -1523,13 +1525,13 @@ function cancelBody(response) {
 }
 async function readBody(response, signal, consume) {
   if (!response.body) throw new Error("Reviewer returned an empty HTTP response");
-  const reader = response.body.getReader();
+  const reader2 = response.body.getReader();
   try {
     while (true) {
       reviewStage(signal, "Reviewer response body");
       let part;
       try {
-        part = await abortable(reader.read(), signal);
+        part = await abortable(reader2.read(), signal);
       } catch {
         signal.throwIfAborted();
         throw new Error("Reviewer response read failed");
@@ -1540,10 +1542,10 @@ async function readBody(response, signal, consume) {
     }
   } finally {
     try {
-      void reader.cancel().catch(() => {
+      void reader2.cancel().catch(() => {
       });
     } finally {
-      reader.releaseLock();
+      reader2.releaseLock();
     }
   }
 }
@@ -1644,7 +1646,8 @@ async function review(evidence, config, signal, fetcher = fetch, environment = p
     const progress = (phase, preview) => {
       if (signal.aborted) return;
       try {
-        onProgress?.({ attempt, phase, ...preview ? { preview: { ...preview } } : {} });
+        void Promise.resolve(onProgress?.({ attempt, phase, ...preview ? { preview: { ...preview } } : {} })).catch(() => {
+        });
       } catch {
       }
     };
@@ -1697,7 +1700,7 @@ async function review(evidence, config, signal, fetcher = fetch, environment = p
         const choices = object(envelope) ? envelope.choices : void 0;
         if (!Array.isArray(choices) || choices.length !== 1) throw new Error("Reviewer API must return one completion");
         const choice = choices[0], message = choice?.message;
-        if (!object(message) || typeof message.content !== "string" || !textMetadata(message) || object(envelope) && envelope.error != null || choice.index !== void 0 && choice.index !== 0 || choice.finish_reason !== void 0 && choice.finish_reason !== "stop") {
+        if (!object(choice) || !object(message) || typeof message.content !== "string" || !textMetadata(message) || object(envelope) && envelope.error != null || choice.error != null || choice.index !== void 0 && choice.index !== 0 || choice.finish_reason !== void 0 && choice.finish_reason !== "stop") {
           throw new Error("Reviewer API did not return a text assessment");
         }
         if (message.content) diagnose?.("first-content");
@@ -1896,7 +1899,7 @@ var Controller = class {
     for (const entry of this.entries.values()) if (entry.root === root) this.suspend(entry);
     this.publish();
   }
-  suspend(entry) {
+  suspend(entry, reason = "mode") {
     const id = entry.view.request.id;
     const state = entry.view.autoApproval?.status;
     if (state) this.manual.set(id, state === "failed" || state === "allowing" ? "failed" : "cancelled");
@@ -1904,6 +1907,7 @@ var Controller = class {
     this.clearProgress(entry);
     entry.approvalAbort?.abort();
     entry.abort.abort();
+    entry.suspension = reason;
     entry.view = { request: entry.view.request, status: "suspended" };
   }
   /** Called only after the assessment has actually been rendered, or to hide it. */
@@ -2106,7 +2110,7 @@ var Controller = class {
           }
         } catch {
           if (active()) {
-            this.suspend(entry);
+            this.suspend(entry, "unavailable");
             this.publish();
           }
           return null;
@@ -2157,7 +2161,7 @@ var Controller = class {
     for (const request of requests) {
       const entry = this.entries.get(request.id);
       if (entry && !entry.root) entry.gateRevision = this.version;
-      if (entry?.view.status === "suspended" && (!entry.root || this.modes?.enabled(entry.root))) {
+      if (entry?.view.status === "suspended" && (entry.suspension === "unavailable" || !entry.root || this.modes?.enabled(entry.root))) {
         this.entries.delete(request.id);
       }
       this.asked(request);
@@ -2199,8 +2203,7 @@ init_define_REVIEW_PROMPTS();
 
 // src/evidence.ts
 init_define_REVIEW_PROMPTS();
-var import_shell_quote = __toESM(require_shell_quote(), 1);
-import path5 from "node:path";
+import path6 from "node:path";
 import { constants as constants2 } from "node:fs";
 
 // src/files.ts
@@ -2244,47 +2247,199 @@ var FileLimit = class {
 function omittedFile(filename) {
   return `[!] File ${JSON.stringify(filename)} not included in context.`;
 }
-function diffDelta(diff, signal) {
+var DiffBudget = class {
+  constructor(limits = { bytes: 16 * 1024 * 1024, lines: 65536, ms: 250 }, now = () => performance.now()) {
+    this.now = now;
+    this.bytes = limits.bytes;
+    this.lines = limits.lines;
+    this.ms = limits.ms;
+  }
+  now;
+  bytes;
+  lines;
+  ms;
+  exhausted = false;
+  check(signal, end) {
+    reviewStage(signal, "Evidence collection");
+    if (this.now() >= end) {
+      this.exhausted = true;
+      return false;
+    }
+    return true;
+  }
+};
+function diffDelta(diff, signal, budget = new DiffBudget()) {
+  reviewStage(signal, "Evidence collection");
   if (typeof diff !== "string") return;
-  let old = 0, next = 0, added = 0, removed = 0, hunks = 0;
-  for (let start = 0; start < diff.length; ) {
-    signal.throwIfAborted();
-    const end = diff.indexOf("\n", start);
-    const line = diff.slice(start, end < 0 ? diff.length : end).replace(/\r$/, "");
-    start = end < 0 ? diff.length : end + 1;
-    const header = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@(?:.*)$/.exec(line);
-    if (header) {
-      if (old || next) return;
-      old = Number(header[1] ?? 1);
-      next = Number(header[2] ?? 1);
-      if (!Number.isSafeInteger(old) || !Number.isSafeInteger(next)) return;
-      hunks++;
-    } else if (line === "\") continue;
-    else if (old || next) {
-      if (line.startsWith("+")) {
-        next--;
-        added++;
-      } else if (line.startsWith("-")) {
-        old--;
-        removed++;
-      } else if (line.startsWith(" ")) {
-        old--;
-        next--;
-      } else return;
-      if (old < 0 || next < 0) return;
-    } else if (hunks && line) return;
-  }
-  if (hunks && !old && !next) return { added, removed };
+  if (diff.length > budget.bytes || budget.ms <= 0) {
+    budget.exhausted = true;
+    return;
+  }
+  const startTime = budget.now(), endTime = startTime + budget.ms;
+  try {
+    const bytes = Buffer.byteLength(diff);
+    const available = budget.bytes;
+    budget.bytes = Math.max(0, available - bytes);
+    if (bytes > available) {
+      budget.exhausted = true;
+      return;
+    }
+    let old = 0, next = 0, added = 0, removed = 0, hunks = 0;
+    for (let start = 0; start < diff.length; ) {
+      if (!budget.check(signal, endTime)) return;
+      if (budget.lines <= 0) {
+        budget.exhausted = true;
+        return;
+      }
+      budget.lines--;
+      const end = diff.indexOf("\n", start);
+      const line = diff.slice(start, end < 0 ? diff.length : end).replace(/\r$/, "");
+      start = end < 0 ? diff.length : end + 1;
+      const header = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@(?:.*)$/.exec(line);
+      if (header) {
+        if (old || next) return;
+        old = Number(header[1] ?? 1);
+        next = Number(header[2] ?? 1);
+        if (!Number.isSafeInteger(old) || !Number.isSafeInteger(next)) return;
+        hunks++;
+      } else if (line === "\") continue;
+      else if (old || next) {
+        if (line.startsWith("+")) {
+          next--;
+          added++;
+        } else if (line.startsWith("-")) {
+          old--;
+          removed++;
+        } else if (line.startsWith(" ")) {
+          old--;
+          next--;
+        } else return;
+        if (old < 0 || next < 0) return;
+      } else if (hunks && line) return;
+    }
+    if (budget.check(signal, endTime) && hunks && !old && !next) return { added, removed };
+  } finally {
+    budget.ms = Math.max(0, budget.ms - (budget.now() - startTime));
+  }
 }
 
-// src/evidence.ts
+// src/shell-discovery.ts
+init_define_REVIEW_PROMPTS();
+var import_shell_quote = __toESM(require_shell_quote(), 1);
+import path5 from "node:path";
 var VARIABLE = "\0UNRESOLVED_VARIABLE\0";
 var python = /^python(?:[23](?:\.\d+)*)?$/;
 var shell = /^(?:ba|da|k|z)?sh$/;
 var assignment = /^[A-Za-z_][A-Za-z_0-9]*=/;
-function balancedQuotes(command) {
+function literal(word) {
+  return !word.includes(VARIABLE) && !word.startsWith("~");
+}
+function unsupportedWhitespace(char) {
+  return /\s/.test(char) && char !== " " && char !== "	";
+}
+var DiscoveryLimit = class extends Error {
+};
+var DiscoveryBudget = class {
+  constructor(signal) {
+    this.signal = signal;
+  }
+  signal;
+  bytes = 16 * 1024 * 1024;
+  tokens = 65536;
+  references = 16384;
+  expansions = 16384;
+  steps = 262144;
+  notices = /* @__PURE__ */ new Set();
+  end = performance.now() + 500;
+  step() {
+    if (this.signal) reviewStage(this.signal, "Evidence collection");
+    if (--this.steps < 0 || performance.now() >= this.end) throw new DiscoveryLimit();
+  }
+  admit(command) {
+    this.step();
+    if (command.length > this.bytes) throw new DiscoveryLimit();
+    this.bytes -= Buffer.byteLength(command);
+    if (this.bytes < 0) throw new DiscoveryLimit();
+    let quote = "", word = false, units = 0;
+    for (let i = 0; i < command.length; i++) {
+      if (!(i % 4096)) this.step();
+      const char = command[i];
+      if (char === "\\" && quote !== "'") {
+        i++;
+        if (!word) {
+          word = true;
+          units++;
+        }
+      } else if (quote) {
+        if (char === quote) quote = "";
+        else if (quote === '"' && char === "$" && --this.expansions < 0) throw new DiscoveryLimit();
+      } else if (char === "'" || char === '"') {
+        quote = char;
+        if (!word) {
+          word = true;
+          units++;
+        }
+      } else if (char === "#" && !word) break;
+      else if (/\s/.test(char)) word = false;
+      else if (/[;&|()<>]/.test(char)) {
+        word = false;
+        units++;
+      } else {
+        if (char === "$" && --this.expansions < 0) throw new DiscoveryLimit();
+        if (!word) {
+          word = true;
+          units++;
+        }
+      }
+      if (units > this.tokens) throw new DiscoveryLimit();
+    }
+  }
+  parsed(count3) {
+    this.step();
+    this.tokens -= count3;
+    if (this.tokens < 0) throw new DiscoveryLimit();
+  }
+  reference() {
+    this.step();
+    if (--this.references < 0) throw new DiscoveryLimit();
+  }
+  notice(text) {
+    if (this.notices.has(text)) return;
+    if (this.notices.size >= 256) throw new DiscoveryLimit();
+    this.notices.add(text);
+  }
+};
+var Words = class {
+  constructor(words, budget) {
+    this.words = words;
+    this.budget = budget;
+  }
+  words;
+  budget;
+  index = 0;
+  get length() {
+    return this.words.length - this.index;
+  }
+  peek() {
+    this.budget.step();
+    return this.words[this.index];
+  }
+  take() {
+    const word = this.peek();
+    if (this.length) this.index++;
+    return word;
+  }
+  *values() {
+    for (let i = this.index; i < this.words.length; i++) {
+      this.budget.step();
+      yield this.words[i];
+    }
+  }
+};
+function balancedQuotes(command, budget) {
   let quote = "";
   for (let i = 0; i < command.length; i++) {
+    if (!(i % 4096)) budget.step();
     const char = command[i];
     if (char === "\\" && quote !== "'") {
       if (++i === command.length) return false;
@@ -2293,12 +2448,15 @@ function balancedQuotes(command) {
   }
   return !quote;
 }
-function unsupportedShellSyntax(command) {
+function unsupportedShellSyntax(command, budget) {
   let quote = "";
   let inWord = false;
+  const whitespace2 = "Unsupported unquoted shell whitespace is outside reliable tokenization; script targets were not resolved.";
   for (let i = 0; i < command.length; i++) {
+    if (!(i % 4096)) budget.step();
     const char = command[i];
     if (char === "\\" && quote !== "'") {
+      if (!quote && unsupportedWhitespace(command[i + 1] ?? "")) return whitespace2;
       i++;
       inWord = true;
     } else if (quote) {
@@ -2306,276 +2464,356 @@ function unsupportedShellSyntax(command) {
     } else if (char === "'" || char === '"') {
       quote = char;
       inWord = true;
-    } else if (char === "#") {
+    } else if (unsupportedWhitespace(char)) return whitespace2;
+    else if (char === "#") {
       if (!inWord) return;
       return "Unquoted # within a shell word is outside reliable tokenization; script targets were not resolved.";
     } else if (char === "[" || char === "{" || char === "}") {
       return "Unquoted bracket glob or brace syntax is outside literal discovery; script targets were not resolved.";
-    } else inWord = !/[\s;&|()<>]/.test(char);
+    } else inWord = !/[ \t;&|()<>]/.test(char);
   }
 }
-function discover(command, cwd, depth = 0) {
-  const references = [];
-  const limitations = [];
-  const note = (text) => {
-    if (!limitations.includes(text)) limitations.push(text);
-  };
-  if (depth > 4 || command.includes("\0") || /[\r\n`]/.test(command)) {
-    note("Script discovery unavailable for multiline commands, backticks, NULs, or deeply nested shell strings; inspect command text directly.");
-    return { references, limitations };
+function programIdentity(executable) {
+  const name = /^(?:\/(?:usr\/)?bin\/)?([^/]+)$/.exec(executable)?.[1];
+  if (!name) return;
+  if (python.test(name)) return "python";
+  if (shell.test(name)) return "shell";
+  if (name === "cat" || name === "head" || name === "env") return name;
+}
+var DiscoveryState = class {
+  constructor(cwd, depth, budget) {
+    this.cwd = cwd;
+    this.depth = depth;
+    this.budget = budget;
+  }
+  cwd;
+  depth;
+  budget;
+  references = [];
+  limitations = [];
+  uncertainWord = false;
+  preceded = false;
+  previousOperator;
+  conditionalCwd = false;
+  explicitCdpath = false;
+  note(text) {
+    this.budget.notice(text);
+    if (!this.limitations.includes(text)) this.limitations.push(text);
+  }
+  invalidateCwd(text) {
+    this.cwd = null;
+    this.note(text);
+  }
+  observeAssignment(word) {
+    if (!word.startsWith("CDPATH=")) return;
+    this.explicitCdpath = true;
+    this.note("Explicit CDPATH assignment is not evaluated; directory-search targets may be unresolved.");
   }
-  if (!balancedQuotes(command)) {
-    note("Shell quoting could not be resolved reliably; script contents were not collected.");
-    return { references, limitations };
+  qualifySnapshot() {
+    if (this.preceded) this.note("Files are current filesystem snapshots; preceding command statements may change them before execution.");
   }
-  const unsupported = unsupportedShellSyntax(command);
-  if (unsupported) {
-    note(unsupported);
-    return { references, limitations };
+  add(filename, executable = false) {
+    if (!literal(filename) || this.uncertainWord) {
+      this.note(`Script filename unresolved: ${filename.replaceAll(VARIABLE, "<variable>")}`);
+      return;
+    }
+    this.budget.reference();
+    this.qualifySnapshot();
+    this.references.push({ filename, cwd: this.cwd, executable });
+  }
+  nested(command) {
+    const nested = scan(command, this.explicitCdpath ? null : this.cwd, this.depth + 1, this.budget);
+    if (nested.references.length) this.qualifySnapshot();
+    this.references.push(...nested.references);
+    nested.limitations.forEach((text) => this.note(text));
+  }
+  afterOperator(operator) {
+    this.previousOperator = operator;
+    this.uncertainWord = false;
+    this.preceded = true;
+    if (operator === "||") {
+      this.invalidateCwd("Conditional fallback makes the working directory uncertain for later statements.");
+    } else if (operator === ";" && this.conditionalCwd) {
+      this.conditionalCwd = false;
+      this.invalidateCwd("Earlier cd may fail or be skipped before this statement; the working directory is unresolved at the branch join.");
+    }
   }
-  let tokens;
-  try {
-    tokens = (0, import_shell_quote.parse)(command, () => VARIABLE);
-  } catch {
-    note("Shell tokenization failed; script targets could not be resolved.");
-    return { references, limitations };
-  }
-  if (tokens.some((t) => typeof t !== "string" && "op" in t && !["&&", "||", ";", "|", "glob"].includes(t.op))) {
-    note("Shell grouping, substitution, background execution or redirection prevents reliable script discovery; inspect command text directly.");
-    return { references, limitations };
-  }
-  let currentCwd = cwd;
-  let words = [];
-  let uncertainWord = false;
-  let preceded = false;
-  let previousOperator;
-  let conditionalCwd = false;
-  let explicitCdpath = false;
-  const observeAssignment = (word) => {
-    if (!word.startsWith("CDPATH=")) return;
-    explicitCdpath = true;
-    note("Explicit CDPATH assignment is not evaluated; directory-search targets may be unresolved.");
-  };
-  const literal = (s) => !s.includes(VARIABLE) && !s.startsWith("~");
-  const qualifySnapshot = () => {
-    if (preceded) note("Files are current filesystem snapshots; preceding command statements may change them before execution.");
-  };
-  const add2 = (filename, executable = false) => {
-    if (!literal(filename) || uncertainWord) {
-      note(`Script filename unresolved: ${filename.replaceAll(VARIABLE, "<variable>")}`);
+};
+function unwrap(args, state) {
+  let builtins = true, builtinOnly = false, wrappers = 0;
+  while (args.peek() && assignment.test(args.peek())) state.observeAssignment(args.take());
+  while (args.peek()) {
+    const name = args.peek();
+    const env = programIdentity(name) === "env";
+    if (!env && !["command", "exec", "builtin"].includes(name)) break;
+    if (wrappers++ >= 8) {
+      const text = "Wrapper nesting exceeds literal discovery's eight-wrapper limit; source was not resolved.";
+      if (builtins) state.invalidateCwd(`${text} The working directory is unresolved.`);
+      else state.note(text);
       return;
     }
-    references.push({ filename, cwd: currentCwd, executable });
-    qualifySnapshot();
-  };
-  const visit = (next) => {
-    const args = words;
-    words = [];
-    let builtins = true;
-    while (args[0] && assignment.test(args[0])) observeAssignment(args.shift());
-    let wrappers = 0;
-    while (["env", "/usr/bin/env", "command", "exec"].includes(args[0] ?? "")) {
-      if (wrappers++ >= 8) {
-        note("Wrapper nesting exceeds literal discovery's eight-wrapper limit; source was not resolved.");
+    const wrapper = args.take();
+    if (env) {
+      if (builtinOnly) {
+        state.note(`Unsupported wrapper composition: ${wrapper} is not assumed to be a shell builtin.`);
         return;
       }
-      const wrapper = args.shift();
-      if (wrapper === "env" || wrapper === "/usr/bin/env") {
-        builtins = false;
-        while (args[0]?.startsWith("-")) {
-          const option = args.shift();
-          if (option === "--") break;
-          if (option === "-i" || option === "--ignore-environment") continue;
-          if (option === "-u" || option === "--unset") {
-            if (!args[0] || !literal(args[0]) || uncertainWord) {
-              note("Missing or unresolved env option argument; invoked source was not resolved.");
-              return;
-            }
-            args.shift();
-            continue;
+      builtins = false;
+      while (args.peek()?.startsWith("-")) {
+        const option = args.take();
+        if (option === "--") break;
+        if (option === "-i" || option === "--ignore-environment") continue;
+        if (option === "-u" || option === "--unset") {
+          if (!args.peek() || !literal(args.peek()) || state.uncertainWord) {
+            state.note("Missing or unresolved env option argument; invoked source was not resolved.");
+            return;
           }
-          note("Unsupported env option; invoked script source could not be resolved.");
-          return;
-        }
-        while (args[0] && assignment.test(args[0])) observeAssignment(args.shift());
-      } else {
-        if (!builtins) {
-          note(`Unsupported wrapper composition: ${wrapper} after an external launcher is not assumed to be a shell builtin.`);
-          return;
-        }
-        if (wrapper === "exec") builtins = false;
-        if (args[0] === "--") args.shift();
-        else if (args[0]?.startsWith("-")) {
-          note(`Unsupported ${wrapper} option; invoked script source was not resolved.`);
-          return;
+          args.take();
+          continue;
         }
+        state.note("Unsupported env option; invoked script source could not be resolved.");
+        return;
+      }
+      while (args.peek() && assignment.test(args.peek())) state.observeAssignment(args.take());
+    } else {
+      if (!builtins) {
+        state.note(`Unsupported wrapper composition: ${wrapper} after an external launcher is not assumed to be a shell builtin.`);
+        return;
       }
-      if (!args[0]) {
-        note(`No command operand after ${wrapper}; invoked script source was not resolved.`);
+      builtinOnly = wrapper === "builtin";
+      if (wrapper === "exec") builtins = false;
+      if (args.peek() === "--") args.take();
+      else if (args.peek()?.startsWith("-")) {
+        const text = `Unsupported ${wrapper} option; invoked script source was not resolved.`;
+        if (builtins && !(wrapper === "command" && ["-v", "-V"].includes(args.peek()))) {
+          state.invalidateCwd(`${text} The working directory is unresolved.`);
+        } else state.note(text);
         return;
       }
     }
-    const executable = args.shift();
-    if (!executable) return;
-    if (executable.startsWith("-")) {
-      note("Wrapper options prevent script discovery.");
+    if (!args.peek()) {
+      state.note(`No command operand after ${wrapper}; invoked script source was not resolved.`);
       return;
     }
-    const base = path5.basename(executable);
-    if (builtins && ["export", "readonly", "declare", "typeset"].includes(executable)) args.forEach(observeAssignment);
-    if (builtins && ["pushd", "popd"].includes(executable)) {
-      currentCwd = null;
-      note("Directory-stack operations are outside literal discovery; the working directory is unresolved.");
-      return;
+  }
+  const executable = args.take();
+  if (!executable) return;
+  if (executable.startsWith("-")) {
+    state.note("Wrapper options prevent script discovery.");
+    return;
+  }
+  return { executable, builtins, builtinOnly };
+}
+function builtin(executable, args, state, next) {
+  if (["export", "readonly", "declare", "typeset"].includes(executable)) {
+    let unsupported = state.uncertainWord;
+    for (const word of args.values()) {
+      state.observeAssignment(word);
+      unsupported ||= !literal(word) || word.startsWith("-") && word !== "--" || word.startsWith("+");
     }
-    if (builtins && executable === "cd") {
-      if (args[0] === "--") args.shift();
-      const target = args[0];
-      const searchesCdpath = target && !path5.isAbsolute(target) && !/^\.\.?(?:\/|$)/.test(target);
-      if (previousOperator === "|" || next === "|") {
-        currentCwd = null;
-        note("Pipeline directory changes do not establish a reliable cwd for later script targets.");
-      } else if (args.length === 1 && target && !target.startsWith("-") && literal(target) && !uncertainWord && !(explicitCdpath && searchesCdpath) && next === "&&" && currentCwd) {
-        currentCwd = path5.resolve(currentCwd, target);
-        conditionalCwd = true;
-      } else {
-        currentCwd = null;
-        note("Working directory after cd is unresolved; relative script targets will not be guessed.");
+    if (unsupported) {
+      state.invalidateCwd(`Unsupported ${executable} operands or options may change shell state; the working directory is unresolved.`);
+    }
+    return true;
+  }
+  if (["pushd", "popd"].includes(executable)) {
+    state.invalidateCwd("Directory-stack operations are outside literal discovery; the working directory is unresolved.");
+    return true;
+  }
+  if (executable === "cd") {
+    if (args.peek() === "--") args.take();
+    const target = args.peek();
+    const searchesCdpath = target && !path5.isAbsolute(target) && !/^\.\.?(?:\/|$)/.test(target);
+    if (state.previousOperator === "|" || next === "|") {
+      state.invalidateCwd("Pipeline directory changes do not establish a reliable cwd for later script targets.");
+    } else if (args.length === 1 && target && !target.startsWith("-") && literal(target) && !state.uncertainWord && !(state.explicitCdpath && searchesCdpath) && next === "&&" && state.cwd) {
+      state.cwd = path5.resolve(state.cwd, target);
+      state.conditionalCwd = true;
+    } else {
+      state.invalidateCwd("Working directory after cd is unresolved; relative script targets will not be guessed.");
+    }
+    return true;
+  }
+  if (executable === "source" || executable === ".") {
+    if (args.peek() === "--") args.take();
+    const target = args.peek();
+    if (target?.startsWith("-")) state.note("Unsupported sourcing option; source target was not resolved.");
+    else if (target && !target.includes("/")) state.note("Bare source operand uses PATH lookup; its file was not resolved.");
+    else if (target) state.add(target);
+    state.invalidateCwd("Sourced code may change the shell environment or working directory.");
+    return true;
+  }
+  if (["eval", "read", "readarray", "mapfile", "getopts", "let", "set", "shopt", "alias", "unalias", "enable", "unset"].includes(executable)) {
+    state.invalidateCwd(`In-process shell state change through ${executable} is outside literal discovery; the working directory is unresolved.`);
+    return true;
+  }
+  if (["if", "then", "else", "fi", "for", "while", "until", "do", "done", "case", "function", "{"].includes(executable)) {
+    state.invalidateCwd("Shell control flow is outside literal discovery; script coverage is incomplete.");
+    return true;
+  }
+  return false;
+}
+function reader(program, args, state) {
+  const operands = [];
+  let options = true;
+  while (args.length) {
+    const arg = args.take();
+    if (options && arg === "--") {
+      options = false;
+      continue;
+    }
+    if (options && arg.startsWith("-") && arg !== "-") {
+      if (program === "cat" && (/^-[AbEenstTuv]+$/.test(arg) || ["--show-all", "--number-nonblank", "--show-ends", "--number", "--squeeze-blank", "--show-tabs", "--show-nonprinting"].includes(arg))) continue;
+      if (program === "head") {
+        if (/^-[qvz]+$/.test(arg) || ["--quiet", "--silent", "--verbose", "--zero-terminated"].includes(arg)) continue;
+        if (["-n", "-c", "--lines", "--bytes"].includes(arg) && /^-?\d+[kKMGTPEZY]?(?:B|iB)?$/.test(args.peek() ?? "")) {
+          args.take();
+          continue;
+        }
+        if (/^(?:-[nc]?|--(?:lines|bytes)=)-?\d+[kKMGTPEZY]?(?:B|iB)?$/.test(arg)) continue;
       }
+      state.note(`Unsupported ${program} option; file operands were not resolved.`);
       return;
     }
-    if (["if", "then", "else", "fi", "for", "while", "until", "do", "done", "case", "function", "{"].includes(base)) {
-      note("Shell control flow is outside literal discovery; script coverage is incomplete.");
-      currentCwd = null;
+    if (arg === "-") state.note(`${program} reads stdin; no file was resolved for that operand.`);
+    else operands.push(arg);
+  }
+  operands.forEach((operand) => state.add(operand));
+}
+function interpreter(isPython, args, state) {
+  while (args.length) {
+    const arg = args.take();
+    if (arg === "--") {
+      const operand = args.peek();
+      if (!operand || isPython && operand === "-") state.note("Interpreter reads stdin; no separate script file was resolved.");
+      else if (!isPython && operand === "-") state.note("Shell '-' operand after -- is outside supported script discovery.");
+      else state.add(operand);
       return;
     }
-    if (!literal(executable)) {
-      note("Executable name contains unresolved expansion; script coverage is incomplete.");
+    if (!isPython && arg === "-") {
+      state.note("Shell '-' invocation is outside supported script discovery.");
       return;
     }
-    if (base === "cat" || base === "head") {
-      const operands = [];
-      let options = true;
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (options && arg === "--") {
-          options = false;
-          continue;
-        }
-        if (options && arg.startsWith("-") && arg !== "-") {
-          if (base === "cat" && (/^-[AbEenstTuv]+$/.test(arg) || ["--show-all", "--number-nonblank", "--show-ends", "--number", "--squeeze-blank", "--show-tabs", "--show-nonprinting"].includes(arg))) continue;
-          if (base === "head") {
-            if (/^-[qvz]+$/.test(arg) || ["--quiet", "--silent", "--verbose", "--zero-terminated"].includes(arg)) continue;
-            if (["-n", "-c", "--lines", "--bytes"].includes(arg) && /^-?\d+[kKMGTPEZY]?(?:B|iB)?$/.test(args[i + 1] ?? "")) {
-              i++;
-              continue;
-            }
-            if (/^(?:-[nc]?|--(?:lines|bytes)=)-?\d+[kKMGTPEZY]?(?:B|iB)?$/.test(arg)) continue;
-          }
-          note(`Unsupported ${base} option; file operands were not resolved.`);
-          return;
-        }
-        if (arg === "-") note(`${base} reads stdin; no file was resolved for that operand.`);
-        else operands.push(arg);
-      }
-      operands.forEach((operand) => add2(operand));
+    if (arg === "-" || !isPython && /^-[abefhiklmnptuvxBCEHPTs]*s[abefhiklmnptuvxBCEHPTs]*$/.test(arg)) {
+      state.note("Interpreter reads stdin; no separate script file was resolved.");
       return;
     }
-    if (python.test(base) || shell.test(base)) {
-      const isPython = python.test(base);
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "--") {
-          const operand = args[i + 1];
-          if (!operand || isPython && operand === "-") note("Interpreter reads stdin; no separate script file was resolved.");
-          else if (!isPython && operand === "-") note("Shell '-' operand after -- is outside supported script discovery.");
-          else add2(operand);
-          return;
-        }
-        if (!isPython && arg === "-") {
-          note("Shell '-' invocation is outside supported script discovery.");
-          return;
-        }
-        if (arg === "-" || !isPython && /^-[abefhiklmnptuvxBCEHPTs]*s[abefhiklmnptuvxBCEHPTs]*$/.test(arg)) {
-          note("Interpreter reads stdin; no separate script file was resolved.");
-          return;
-        }
-        if (isPython && arg === "-c" || !isPython && /^-[abefhiklmnptuvxBCEHPT]*c$/.test(arg)) {
-          if (!args[i + 1] || !literal(args[i + 1]) || uncertainWord) note("Inline interpreter code contains unresolved expansion or is missing; its runtime contents are unavailable.");
-          if (!isPython && args[i + 1] && literal(args[i + 1]) && !uncertainWord) {
-            const nested = discover(args[i + 1], explicitCdpath ? null : currentCwd, depth + 1);
-            references.push(...nested.references);
-            nested.limitations.forEach(note);
-            if (nested.references.length) qualifySnapshot();
-          }
-          return;
-        }
-        if (isPython && (arg === "-m" || arg.startsWith("-m") || arg.startsWith("-c"))) {
-          if (!arg.startsWith("-c")) note("Python module execution: module source is not resolved by direct-script discovery.");
-          return;
-        }
-        if (isPython && (arg === "-W" || arg === "-X") || !isPython && (arg === "-o" || arg === "+o")) {
-          if (!args[i + 1] || !literal(args[i + 1]) || uncertainWord) {
-            note(`Interpreter option ${arg} has a missing or unresolved argument; script source was not resolved.`);
-            return;
-          }
-          i++;
-          continue;
-        }
-        if (arg.startsWith("-") || !isPython && arg.startsWith("+")) {
-          const known = isPython ? /^-[bBdEIOPqRsSuv]+$/.test(arg) || /^-(W|X).+/.test(arg) : /^[-+][abefhiklmnptuvxBCEHPT]+$/.test(arg) || ["--noprofile", "--norc"].includes(arg);
-          if (known) continue;
-          note(`Interpreter option ${arg} is outside supported script discovery.`);
-          return;
-        }
-        add2(arg);
+    if (isPython && arg === "-c" || !isPython && /^-[abefhiklmnptuvxBCEHPT]*c$/.test(arg)) {
+      const code = args.peek();
+      if (!code || !literal(code) || state.uncertainWord) state.note("Inline interpreter code contains unresolved expansion or is missing; its runtime contents are unavailable.");
+      if (!isPython && code && literal(code) && !state.uncertainWord) state.nested(code);
+      return;
+    }
+    if (isPython && (arg === "-m" || arg.startsWith("-m") || arg.startsWith("-c"))) {
+      if (!arg.startsWith("-c")) state.note("Python module execution: module source is not resolved by direct-script discovery.");
+      return;
+    }
+    if (isPython && (arg === "-W" || arg === "-X") || !isPython && (arg === "-o" || arg === "+o")) {
+      if (!args.peek() || !literal(args.peek()) || state.uncertainWord) {
+        state.note(`Interpreter option ${arg} has a missing or unresolved argument; script source was not resolved.`);
         return;
       }
-      return;
+      args.take();
+      continue;
     }
-    if (builtins && (executable === "source" || executable === ".")) {
-      if (args[0] === "--") args.shift();
-      if (args[0]?.startsWith("-")) note("Unsupported sourcing option; source target was not resolved.");
-      else if (args[0] && !args[0].includes("/")) note("Bare source operand uses PATH lookup; its file was not resolved.");
-      else if (args[0]) add2(args[0]);
-      currentCwd = null;
-      note("Sourced code may change the shell environment or working directory.");
+    if (arg.startsWith("-") || !isPython && arg.startsWith("+")) {
+      const known = isPython ? /^-[bBdEIOPqRsSuv]+$/.test(arg) || /^-(W|X).+/.test(arg) : /^[-+][abefhiklmnptuvxBCEHPT]+$/.test(arg) || ["--noprofile", "--norc"].includes(arg);
+      if (known) continue;
+      state.note(`Interpreter option ${arg} is outside supported script discovery.`);
       return;
     }
-    if (executable.includes("/")) add2(executable, true);
-    else if (/\.(py|sh|bash|zsh)$/.test(executable)) note(`Executable ${executable} uses PATH lookup; its file was not resolved.`);
-    else if (["sudo", "su", "ssh", "docker", "podman", "eval", "xargs", "find", "npm", "npx", "make", "uv", "poetry"].includes(base)) {
-      note(`Indirect execution through ${base}: invoked source is not automatically discovered.`);
+    state.add(arg);
+    return;
+  }
+}
+function visit(args, state, next) {
+  const words = new Words(args, state.budget);
+  const invocation = unwrap(words, state);
+  if (!invocation) return;
+  const { executable, builtins, builtinOnly } = invocation;
+  if (!literal(executable)) {
+    const text = "Executable name contains unresolved expansion; script coverage is incomplete.";
+    if (builtins) state.invalidateCwd(`${text} The working directory is unresolved.`);
+    else state.note(text);
+    return;
+  }
+  if (builtins && builtin(executable, words, state, next)) return;
+  if (builtinOnly) {
+    if ([":", "true", "false", "pwd", "echo", "printf", "test"].includes(executable)) return;
+    state.invalidateCwd(`Unsupported builtin operand ${executable}; source and subsequent working directory were not resolved.`);
+    return;
+  }
+  const program = programIdentity(executable);
+  if (program === "cat" || program === "head") return reader(program, words, state);
+  if (program === "python" || program === "shell") return interpreter(program === "python", words, state);
+  if (executable.includes("/")) state.add(executable, true);
+  else if (/\.(py|sh|bash|zsh)$/.test(executable)) state.note(`Executable ${executable} uses PATH lookup; its file was not resolved.`);
+  else if (["sudo", "su", "ssh", "docker", "podman", "eval", "xargs", "find", "npm", "npx", "make", "uv", "poetry"].includes(executable)) {
+    state.note(`Indirect execution through ${executable}: invoked source is not automatically discovered.`);
+  }
+}
+function discover(command, cwd, depth = 0, signal) {
+  return scan(command, cwd, depth, new DiscoveryBudget(signal));
+}
+function scan(command, cwd, depth, budget) {
+  const state = new DiscoveryState(cwd, depth, budget);
+  const result = { references: state.references, limitations: state.limitations };
+  try {
+    budget.admit(command);
+    if (depth > 4 || command.includes("\0") || /[\r\n`]/.test(command)) {
+      state.note("Script discovery unavailable for multiline commands, backticks, NULs, or deeply nested shell strings; inspect command text directly.");
+      return result;
+    }
+    if (!balancedQuotes(command, budget)) {
+      state.note("Shell quoting could not be resolved reliably; script contents were not collected.");
+      return result;
     }
-  };
-  for (const token of tokens) {
-    if (typeof token === "string") words.push(token);
-    else if ("comment" in token) break;
-    else if ("op" in token && token.op === "glob" && "pattern" in token) {
-      words.push(String(token.pattern));
-      uncertainWord = true;
-    } else if ("op" in token && typeof token.op === "string") {
-      visit(token.op);
-      previousOperator = token.op;
-      uncertainWord = false;
-      preceded = true;
-      if (token.op === "||") {
-        currentCwd = null;
-        note("Conditional fallback makes the working directory uncertain for later statements.");
-      } else if (token.op === ";" && conditionalCwd) {
-        currentCwd = null;
-        conditionalCwd = false;
-        note("Earlier cd may fail or be skipped before this statement; the working directory is unresolved at the branch join.");
+    const unsupported = unsupportedShellSyntax(command, budget);
+    if (unsupported) {
+      state.note(unsupported);
+      return result;
+    }
+    let tokens;
+    try {
+      tokens = (0, import_shell_quote.parse)(command, () => VARIABLE);
+    } catch {
+      state.note("Shell tokenization failed; script targets could not be resolved.");
+      return result;
+    }
+    budget.parsed(tokens.length);
+    if (tokens.some((t) => typeof t !== "string" && "op" in t && !["&&", "||", ";", "|", "glob"].includes(t.op))) {
+      state.note("Shell grouping, substitution, background execution or redirection prevents reliable script discovery; inspect command text directly.");
+      return result;
+    }
+    let words = [];
+    for (const token of tokens) {
+      budget.step();
+      if (typeof token === "string") words.push(token);
+      else if ("comment" in token) break;
+      else if ("op" in token && token.op === "glob" && "pattern" in token) {
+        words.push(String(token.pattern));
+        state.uncertainWord = true;
+      } else if ("op" in token && typeof token.op === "string") {
+        visit(words, state, token.op);
+        words = [];
+        state.afterOperator(token.op);
       }
     }
+    visit(words, state);
+    return result;
+  } catch (error) {
+    if (!(error instanceof DiscoveryLimit)) throw error;
+    const text = "Shell discovery exceeded its shared 16 MiB/65,536-token/16,384-reference/16,384-expansion/262,144-step/256-notice/500 ms work limits; remaining source targets were not resolved.";
+    if (!state.limitations.includes(text)) state.limitations.push(text);
+    return result;
   }
-  visit();
-  return { references, limitations };
 }
+
+// src/evidence.ts
 async function capture(reference, budget, signal, scope) {
   const result = { filename: reference.filename, status: "unavailable" };
-  if (!reference.cwd && !path5.isAbsolute(reference.filename)) return { ...result, status: "working directory unresolved; contents not provided" };
-  const filename = path5.isAbsolute(reference.filename) ? reference.filename : `${reference.cwd}/${reference.filename}`;
+  if (!reference.cwd && !path6.isAbsolute(reference.filename)) return { ...result, status: "working directory unresolved; contents not provided" };
+  const filename = path6.isAbsolute(reference.filename) ? reference.filename : `${reference.cwd}/${reference.filename}`;
   result.path = filename;
   signal.throwIfAborted();
   try {
@@ -2632,9 +2870,10 @@ async function capture(reference, budget, signal, scope) {
 }
 async function collectEvidence(input, limits, signal, scope = fileAccess.scope(signal)) {
   signal.throwIfAborted();
+  if (input.command.length > limits.maxEvidenceBytes) throw new Error("Command exceeds configured evidence budget");
   const commandBytes = Buffer.byteLength(input.command);
   if (commandBytes > limits.maxEvidenceBytes) throw new Error("Command exceeds configured evidence budget");
-  const discovery = discover(input.command, input.cwd);
+  const discovery = discover(input.command, input.cwd, 0, signal);
   const evidence = { ...input, kind: "shell", files: [], limitations: [
     ...input.limitations ?? [],
     "Only literal Python/shell source and supported cat/head file operands are collected. Files are full review-time snapshots, not command output. Imports, dependencies, other runtimes and calls inside source files are not recursively inspected.",
@@ -2643,72 +2882,143 @@ async function collectEvidence(input, limits, signal, scope = fileAccess.scope(s
   if (!input.userPrompt) evidence.limitations.push("User prompt unavailable.");
   let remaining = limits.maxEvidenceBytes - commandBytes;
   const limit = new FileLimit(limits.maxFiles, scope);
-  const selected = /* @__PURE__ */ new Map();
+  const declared = /* @__PURE__ */ new Map();
   for (const reference of discovery.references) {
     signal.throwIfAborted();
-    const filename = path5.isAbsolute(reference.filename) ? reference.filename : reference.cwd ? `${reference.cwd}/${reference.filename}` : null;
+    const filename = path6.isAbsolute(reference.filename) ? reference.filename : reference.cwd ? `${reference.cwd}/${reference.filename}` : null;
+    const key = filename ?? /* @__PURE__ */ Symbol();
+    const previous = declared.get(key);
+    if (previous) previous.executable &&= reference.executable;
+    else declared.set(key, { ...reference });
+  }
+  const selected = /* @__PURE__ */ new Map();
+  for (const reference of declared.values()) {
+    signal.throwIfAborted();
+    const filename = path6.isAbsolute(reference.filename) ? reference.filename : reference.cwd ? `${reference.cwd}/${reference.filename}` : null;
     const { key, withinLimit } = await limit.consider(filename, signal);
     const previous = selected.get(key);
     if (previous) {
+      const promote = previous.reference.executable && !reference.executable;
       previous.reference.executable &&= reference.executable;
-      if (filename && filename !== previous.filename && !previous.aliases.includes(filename)) previous.aliases.push(filename);
-    } else selected.set(key, { reference: { ...reference }, filename, withinLimit, aliases: [] });
-  }
-  for (const { reference, filename, withinLimit, aliases } of selected.values()) {
-    signal.throwIfAborted();
-    if (!withinLimit) {
-      evidence.files.push({ filename: reference.filename, ...filename ? { path: filename } : {}, ...aliases.length ? { aliases } : {}, status: "file-count limit reached", warning: omittedFile(filename ?? reference.filename) });
+      if (filename && filename !== previous.filename) previous.aliases.add(filename);
+      if (promote && previous.withinLimit && previous.file.status === "direct executable is not identifiable as Python/shell source; contents not provided") {
+        const file2 = await capture(previous.reference, remaining, signal, scope);
+        Object.assign(previous.file, file2);
+        if (file2.contents !== void 0) {
+          delete previous.file.warning;
+          remaining -= Buffer.byteLength(file2.contents);
+        }
+      }
       continue;
     }
-    const file = await capture(reference, remaining, signal, scope);
-    if (aliases.length) file.aliases = aliases;
+    const file = withinLimit ? await capture(reference, remaining, signal, scope) : { filename: reference.filename, ...filename ? { path: filename } : {}, status: "file-count limit reached" };
     if (file.contents === void 0) file.warning = omittedFile(file.path ?? file.filename);
+    selected.set(key, { reference, filename, withinLimit, aliases: /* @__PURE__ */ new Set(), file });
     evidence.files.push(file);
     remaining -= Buffer.byteLength(file.contents ?? "");
   }
+  for (const { file, aliases } of selected.values()) if (aliases.size) file.aliases = [...aliases];
   signal.throwIfAborted();
   evidence.limitations.push(...limit.limitations);
   return evidence;
 }
 async function collectEditEvidence(input, limits, signal, scope = fileAccess.scope(signal)) {
-  signal.throwIfAborted();
-  const { metadata, ...permissionScope } = input.permission;
+  reviewStage(signal, "Evidence collection");
+  const metadata = input.permission.metadata;
   const limitations = [
     ...input.limitations,
     "Proposed diffs come from the pending host permission, not from applying edits. Full files, dependencies and post-approval formatter changes are not inspected; host diffs may normalize whitespace or omit BOMs."
   ];
   const record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const field = (value, key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) return void 0;
+    if (!Object.hasOwn(descriptor, "value")) throw new Error("Native edit metadata contains an accessor");
+    return descriptor.value;
+  };
+  let headerBytes = 16 * 1024 * 1024;
+  const text = (value) => {
+    if (typeof value !== "string") return;
+    reviewStage(signal, "Evidence collection");
+    if (value.length > headerBytes) throw new Error("Native edit scope exceeds the 16 MiB normalization limit");
+    headerBytes -= Buffer.byteLength(value);
+    if (headerBytes < 0) throw new Error("Native edit scope exceeds the 16 MiB normalization limit");
+    return value;
+  };
+  const patterns = (values) => {
+    if (values.length > 16384) throw new Error("Native edit scope exceeds the 16,384-entry normalization limit");
+    const result = [];
+    for (let index = 0; index < values.length; index++) {
+      const value = text(field(values, String(index)));
+      if (value === void 0) throw new Error("Native edit scope contains an invalid pattern");
+      result.push(value);
+    }
+    return result;
+  };
+  const scopeText = (value) => {
+    const result = text(value);
+    if (result === void 0) throw new Error("Native edit scope contains invalid identity text");
+    return result;
+  };
+  const permissionScope = {
+    id: scopeText(input.permission.id),
+    type: scopeText(input.permission.type),
+    patterns: patterns(input.permission.patterns),
+    always: patterns(input.permission.always),
+    tool: input.permission.tool ? { messageID: scopeText(input.permission.tool.messageID), callID: scopeText(input.permission.tool.callID) } : null
+  };
   const patch = input.tool === "apply_patch";
-  const files = patch ? Array.isArray(metadata.files) ? metadata.files : [] : [{ filePath: metadata.filepath, patch: metadata.diff, type: input.tool, additions: metadata.additions, deletions: metadata.deletions }];
+  const hostFiles = patch ? field(record2(metadata), "files") : void 0;
+  const files = patch ? Array.isArray(hostFiles) ? hostFiles : [] : [metadata];
+  if (files.length > 16384) throw new Error("Native edit changes exceed the 16,384-entry normalization limit");
   if (!files.length) limitations.push("Per-file patch metadata unavailable; affected changes could not be enumerated.");
   let remaining = limits.maxEvidenceBytes;
+  let measurementUnits = 16 * 1024 * 1024;
   const changes = [];
   const limit = new FileLimit(limits.maxFiles, scope);
+  const countsBudget = new DiffBudget();
   for (let index = 0; index < files.length; index++) {
-    signal.throwIfAborted();
-    const file = record2(files[index]);
-    const operation = typeof file.type === "string" && ["add", "update", "delete", "move", "edit", "write"].includes(file.type) ? file.type : "unknown";
+    reviewStage(signal, "Evidence collection");
+    const file = record2(patch ? field(files, String(index)) : metadata);
+    const type = patch ? field(file, "type") : input.tool;
+    const operation = typeof type === "string" && ["add", "update", "delete", "move", "edit", "write"].includes(type) ? type : "unknown";
+    const filePath = text(field(file, patch ? "filePath" : "filepath"));
+    const movePath = patch ? text(field(file, "movePath")) : void 0;
+    const diff = field(file, patch ? "patch" : "diff");
     const change = {
-      path: typeof file.filePath === "string" && file.filePath.trim() ? file.filePath : null,
+      path: filePath?.trim() ? filePath : null,
       operation,
       status: "omitted",
-      ...typeof file.movePath === "string" ? { movePath: file.movePath } : {}
+      ...movePath !== void 0 ? { movePath } : {}
     };
-    const { withinLimit } = await limit.consider(change.path && path5.isAbsolute(change.path) ? change.path : null, signal);
+    const { withinLimit } = await limit.consider(change.path && path6.isAbsolute(change.path) ? change.path : null, signal);
     if (!withinLimit) change.reason = "file-count limit reached";
-    else if (!change.path || !path5.isAbsolute(change.path)) change.reason = "absolute target path unavailable";
+    else if (!change.path || !path6.isAbsolute(change.path)) change.reason = "absolute target path unavailable";
     else if (operation === "unknown" || patch && (operation === "edit" || operation === "write")) change.reason = "file operation unavailable or unsupported";
-    else if (operation === "move" && (!change.movePath || !path5.isAbsolute(change.movePath))) change.reason = "absolute move destination unavailable";
-    else if (typeof file.patch !== "string" || !file.patch.trim()) change.reason = "proposed diff unavailable";
-    else if (Buffer.byteLength(file.patch) > remaining) change.reason = "complete diff exceeds remaining evidence byte budget";
+    else if (operation === "move" && (!change.movePath || !path6.isAbsolute(change.movePath))) change.reason = "absolute move destination unavailable";
+    else if (typeof diff !== "string" || !diff.length) change.reason = "proposed diff unavailable";
+    else if (diff.length > remaining) change.reason = "complete diff exceeds remaining evidence byte budget";
+    else if (diff.length > measurementUnits) change.reason = "shared diff UTF-8 measurement work limit reached";
     else {
-      change.status = "included";
-      change.diff = file.patch;
-      remaining -= Buffer.byteLength(file.patch);
+      measurementUnits -= diff.length;
+      const bytes = Buffer.byteLength(diff);
+      if (bytes > remaining) change.reason = "complete diff exceeds remaining evidence byte budget";
+      else if (!diff.trim()) change.reason = "proposed diff unavailable";
+      else {
+        change.status = "included";
+        change.diff = diff;
+        remaining -= bytes;
+      }
     }
     if (change.status === "omitted") {
       change.warning = omittedFile(change.path);
-      const counts = diffDelta(file.patch, signal) ?? (Number.isSafeInteger(file.additions) && Number(file.additions) >= 0 && Number.isSafeInteger(file.deletions) && Number(file.deletions) >= 0 ? { added: Number(file.additions), removed: Number(file.deletions) } : void 0);
+      let counts = diffDelta(diff, signal, countsBudget);
+      if (!counts) {
+        const added = field(file, "additions"), removed = field(file, "deletions");
+        if (Number.isSafeInteger(added) && Number(added) >= 0 && Number.isSafeInteger(removed) && Number(removed) >= 0) {
+          counts = { added: Number(added), removed: Number(removed) };
+        }
+      }
       if (counts) change.delta = `[\u0394] ${JSON.stringify(change.path)}: +${counts.added} \u2212${counts.removed} lines`;
     }
     changes.push(change);
@@ -2717,7 +3027,8 @@ async function collectEditEvidence(input, limits, signal, scope = fileAccess.sco
   if (partial) limitations.push("Edit evidence is incomplete. Omitted changes are not assessed by the supplied diffs; do not assume the whole proposal is safe.");
   if (!input.userPrompt) limitations.push("User prompt unavailable.");
   limitations.push(...limit.limitations);
-  signal.throwIfAborted();
+  if (countsBudget.exhausted) limitations.push("Some omitted-diff line counts exceeded the shared 16 MiB/65,536-line/250 ms counting allowance; valid host counts were used when available.");
+  reviewStage(signal, "Evidence collection");
   return {
     kind: "edit",
     tool: input.tool,
@@ -2775,10 +3086,10 @@ function patchOperations(input, signal) {
     update = void 0;
     const kind = line.startsWith("*** Add File:") ? "add" : line.startsWith("*** Delete File:") ? "delete" : line.startsWith("*** Update File:") ? "update" : void 0;
     if (!kind) continue;
-    const path10 = line.slice(line.indexOf(":") + 1).trim();
-    if (!path10) throw new Error("Patch operation summary contains an empty target path");
+    const path11 = line.slice(line.indexOf(":") + 1).trim();
+    if (!path11) throw new Error("Patch operation summary contains an empty target path");
     if (operations.length >= 16384) throw new Error("Patch operation summary exceeds bounded JSON structure limits");
-    const operation = { operation: kind, path: path10 };
+    const operation = { operation: kind, path: path11 };
     operations.push(operation);
     if (kind === "update") update = operation;
   }
@@ -2809,7 +3120,7 @@ function boundedCopy(value, budget, valueBudget = 16384) {
       } else add2(code >= 55296 && code <= 57343 ? 6 : 3);
     }
   };
-  const visit = (value2, depth) => {
+  const visit2 = (value2, depth) => {
     if (++nodes > valueBudget || depth > 32) throw new Error("Operation evidence exceeds bounded JSON structure limits");
     if (value2 === null) {
       add2(4);
@@ -2835,7 +3146,7 @@ function boundedCopy(value, budget, valueBudget = 16384) {
         const descriptor = Object.getOwnPropertyDescriptor(value2, String(index));
         if (!descriptor || !Object.hasOwn(descriptor, "value")) throw new Error("Operation evidence contains an array hole or accessor");
         if (count3++) add2(1);
-        entries.push(visit(descriptor.value, depth + 1));
+        entries.push(visit2(descriptor.value, depth + 1));
       }
     } else {
       for (const key in value2) {
@@ -2845,13 +3156,13 @@ function boundedCopy(value, budget, valueBudget = 16384) {
         if (count3++) add2(1);
         text(key);
         add2(1);
-        Object.defineProperty(result, key, { value: visit(descriptor.value, depth + 1), enumerable: true, writable: true, configurable: true });
+        Object.defineProperty(result, key, { value: visit2(descriptor.value, depth + 1), enumerable: true, writable: true, configurable: true });
       }
     }
     ancestors.delete(value2);
     return result;
   };
-  return { value: visit(value, 0), bytes, values: nodes };
+  return { value: visit2(value, 0), bytes, values: nodes };
 }
 function collectToolEvidence(context, limits, signal) {
   signal.throwIfAborted();
@@ -2911,39 +3222,38 @@ function collectDirectoryEvidence(context, limits, signal) {
 }
 
 // src/evaluate.ts
-async function evaluateEvidence(request, reader, options, config, configError, signal, onIdentified, files) {
+async function evaluateEvidence(request, reader2, options, config, configError, signal, onIdentified, files) {
   if (!candidateEnabled(request, options)) return null;
   reviewStage(signal, "Permission context lookup");
-  const invocation = await loadInvocation(request, reader, signal);
+  const invocation = await loadInvocation(request, reader2, signal);
   let ids;
   try {
     ids = await withDeadline(signal, Math.min(1500, remainingTime(signal) / 4), async (s) => {
-      const value = await reader.toolIDs?.(s);
+      const value = await reader2.toolIDs?.(s);
       if (!value || value.length > 16384 || !value.every((id) => typeof id === "string")) throw new Error("Tool registry unavailable");
       return value;
     }, "Tool registry lookup");
   } catch {
     signal.throwIfAborted();
   }
-  const classified = classify(request, invocation, ids, reader.mcpServers?.() ?? []);
+  const classified = classify(request, invocation, ids, reader2.mcpServers?.() ?? []);
   if (!classified) return null;
   if (!enabledKind(classified.kind, options)) return null;
   onIdentified();
   if (!config) throw new Error(configError || "Invalid configuration");
   const scope = files.scope(signal);
-  const cachedReader = { ...reader, message: async () => invocation.message };
   if (classified.kind === "shell") {
-    const context = await loadContext(request, cachedReader, signal, scope);
+    const context = await loadContext(request, reader2, signal, scope, invocation);
     if (!context) throw new Error("Native shell context unavailable");
     reviewStage(signal, "Evidence collection");
     return collectEvidence(context, config, signal, scope);
   }
   if (classified.kind === "edit") {
-    const context = await loadEditContext(request, cachedReader, signal);
+    const context = await loadEditContext(request, reader2, signal, invocation);
     reviewStage(signal, "Evidence collection");
     return collectEditEvidence(context, config, signal, scope);
   }
-  const conversation = await loadConversationContext(request, reader, signal);
+  const conversation = await loadConversationContext(request, reader2, signal);
   if (!invocation.location.instanceDirectory) conversation.limitations.push("Invocation directory unavailable; session origin is not substituted.");
   if (!invocation.location.instanceWorktree) conversation.limitations.push("Invocation worktree unavailable.");
   const common = { ...conversation, tool: invocation.tool, input: invocation.input, permission: permissionContext(request, false), location: invocation.location };
@@ -2957,7 +3267,7 @@ async function evaluateEvidence(request, reader, options, config, configError, s
       definition = await withDeadline(
         signal,
         Math.min(1e3, remainingTime(signal) / 4),
-        (s) => reader.definition?.(invocation.info, invocation.tool, s) ?? Promise.resolve(void 0),
+        (s) => reader2.definition?.(invocation.info, invocation.tool, s) ?? Promise.resolve(void 0),
         "Tool definition lookup"
       );
       if (definition?.id !== invocation.tool) definition = void 0;
@@ -2989,11 +3299,58 @@ function approvalTransport(client, directory) {
   };
 }
 
+// src/pending-refresh.ts
+init_define_REVIEW_PROMPTS();
+var PendingRefresh = class {
+  constructor(pending, read, parent) {
+    this.pending = pending;
+    this.read = read;
+    this.signal = AbortSignal.any([parent, this.abort.signal]);
+  }
+  pending;
+  read;
+  syncing = false;
+  stopped = false;
+  again = false;
+  generation = 0;
+  abort = new AbortController();
+  signal;
+  async refresh() {
+    if (this.stopped || this.signal.aborted) return;
+    if (this.syncing) {
+      this.again = true;
+      return;
+    }
+    this.syncing = true;
+    const generation = ++this.generation;
+    const revision = this.pending.revision;
+    try {
+      const requests = await withDeadline(this.signal, 5e3, this.read, "Pending permission refresh");
+      if (this.stopped || this.signal.aborted || this.generation !== generation || this.pending.revision !== revision) return;
+      this.pending.reconcile(requests, revision);
+    } catch {
+    } finally {
+      if (this.generation === generation) {
+        this.syncing = false;
+        const again = this.again;
+        this.again = false;
+        if (again) void this.refresh();
+      }
+    }
+  }
+  dispose() {
+    this.stopped = true;
+    this.again = false;
+    this.generation++;
+    this.abort.abort();
+  }
+};
+
 // src/lifetime-view.tsx
 init_define_REVIEW_PROMPTS();
 import { createComponent as _$createComponent } from "@opentui/solid";
 import { memo as _$memo } from "@opentui/solid";
-import path7 from "node:path";
+import path8 from "node:path";
 import { createSignal } from "solid-js";
 
 // src/lifetime.ts
@@ -3001,7 +3358,7 @@ init_define_REVIEW_PROMPTS();
 import { constants as constants3 } from "node:fs";
 import { mkdir, open as open3, readdir as readdir2, rename, unlink } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import path6 from "node:path";
+import path7 from "node:path";
 var empty = () => ({ requests: 0, tokenRequests: 0, input: 0, output: 0, priced: 0, cost: 0, since: null });
 var count2 = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 var amount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -3025,7 +3382,7 @@ var LifetimeUsage = class {
   constructor(directory, legacyDirectory) {
     this.directory = directory;
     this.legacyDirectory = legacyDirectory;
-    if (!path6.isAbsolute(directory) || legacyDirectory !== void 0 && !path6.isAbsolute(legacyDirectory)) {
+    if (!path7.isAbsolute(directory) || legacyDirectory !== void 0 && !path7.isAbsolute(legacyDirectory)) {
       throw new Error("Lifetime usage directory must be absolute");
     }
   }
@@ -3052,7 +3409,7 @@ var LifetimeUsage = class {
     }).then(async () => {
       this.local = add(this.local, increment);
       await mkdir(this.directory, { recursive: true, mode: 448 });
-      const temporary = path6.join(this.directory, `${this.id}.${randomUUID()}.tmp`);
+      const temporary = path7.join(this.directory, `${this.id}.${randomUUID()}.tmp`);
       try {
         const file = await open3(temporary, "wx", 384);
         try {
@@ -3061,7 +3418,7 @@ var LifetimeUsage = class {
         } finally {
           await file.close();
         }
-        await rename(temporary, path6.join(this.directory, `${this.id}.json`));
+        await rename(temporary, path7.join(this.directory, `${this.id}.json`));
         const directory = await open3(this.directory, constants3.O_RDONLY | constants3.O_DIRECTORY);
         try {
           await directory.sync();
@@ -3082,8 +3439,9 @@ var LifetimeUsage = class {
   async totals(signal) {
     signal?.throwIfAborted();
     await this.flush();
+    signal?.throwIfAborted();
     let total = empty();
-    const directories = new Set([this.directory, ...this.legacyDirectory ? [this.legacyDirectory] : []].map((directory) => path6.resolve(directory)));
+    const directories = new Set([this.directory, ...this.legacyDirectory ? [this.legacyDirectory] : []].map((directory) => path7.resolve(directory)));
     for (const directory of directories) total = add(total, await this.readDirectory(directory, signal));
     signal?.throwIfAborted();
     return total;
@@ -3094,17 +3452,22 @@ var LifetimeUsage = class {
       if (error.code === "ENOENT") return [];
       throw error;
     });
+    signal?.throwIfAborted();
     let total = empty();
     for (const name of names.filter((name2) => snapshotName.test(name2))) {
       signal?.throwIfAborted();
-      const file = await open3(path6.join(directory, name), constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
+      const file = await open3(path7.join(directory, name), constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
       try {
+        signal?.throwIfAborted();
         const stat = await file.stat();
+        signal?.throwIfAborted();
         if (!stat.isFile() || stat.size > 1024) throw new Error("Invalid lifetime usage snapshot");
         const bytes = Buffer.alloc(1025);
         let size = 0;
         while (size < bytes.length) {
+          signal?.throwIfAborted();
           const read = await file.read(bytes, size, bytes.length - size, size);
+          signal?.throwIfAborted();
           if (!read.bytesRead) break;
           size += read.bytesRead;
         }
@@ -3123,6 +3486,7 @@ var LifetimeUsage = class {
       } finally {
         await file.close();
       }
+      signal?.throwIfAborted();
     }
     signal?.throwIfAborted();
     return total;
@@ -3137,7 +3501,7 @@ function lifetimeReport(totals) {
   return [
     lifetimeCost(totals),
     `${totals.requests} requests with recorded usage`,
-    totals.tokenRequests ? `tokens in/out: ${totals.input}/${totals.output}${totals.tokenRequests < totals.requests ? " (partial coverage)" : ""}` : "tokens unavailable",
+    totals.tokenRequests ? `token: ${totals.input} in ${totals.output} out${totals.tokenRequests < totals.requests ? " (partial coverage)" : ""}` : "tokens unavailable",
     `Token counts available: ${totals.tokenRequests}/${totals.requests} requests`,
     `Pricing available: ${totals.priced}/${totals.requests} requests`,
     ...totals.since === null ? [] : [`Recorded since: ${new Date(totals.since).toISOString().slice(0, 10)}`],
@@ -3146,25 +3510,96 @@ function lifetimeReport(totals) {
   ].join("\n");
 }
 
+// src/lifetime-refresh.ts
+init_define_REVIEW_PROMPTS();
+var LifetimeRefresh = class {
+  constructor(read, publish, parent) {
+    this.read = read;
+    this.publish = publish;
+    this.signal = AbortSignal.any([parent, this.abort.signal]);
+  }
+  read;
+  publish;
+  revision = 0;
+  followUp = false;
+  stopped = false;
+  active;
+  abort = new AbortController();
+  signal;
+  refresh() {
+    if (this.stopped || this.signal.aborted) return;
+    this.revision++;
+    if (this.active) {
+      this.followUp = true;
+      return;
+    }
+    this.start();
+  }
+  /** A failed write invalidates active results and requests queued before it. */
+  failed() {
+    if (this.stopped || this.signal.aborted) return;
+    this.revision++;
+    this.followUp = false;
+    this.publish(void 0);
+  }
+  start() {
+    if (this.stopped || this.signal.aborted) return;
+    this.followUp = false;
+    const transaction = { revision: this.revision, settled: true, finished: false };
+    this.active = transaction;
+    void this.run(transaction);
+  }
+  live(transaction) {
+    return !this.stopped && !this.signal.aborted && this.active === transaction;
+  }
+  async run(transaction) {
+    try {
+      const totals = await withDeadline(this.signal, 5e3, (signal) => {
+        transaction.settled = false;
+        const worker = Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return this.read(signal);
+        });
+        const settled = () => {
+          transaction.settled = true;
+          this.release(transaction);
+        };
+        void worker.then(settled, settled);
+        return worker;
+      }, "Lifetime usage loading");
+      if (this.live(transaction) && this.revision === transaction.revision) this.publish(totals);
+    } catch {
+      if (this.live(transaction)) this.publish(void 0);
+    } finally {
+      transaction.finished = true;
+      this.release(transaction);
+    }
+  }
+  release(transaction) {
+    if (this.active !== transaction || !transaction.finished || !transaction.settled) return;
+    this.active = void 0;
+    if (this.followUp) this.start();
+  }
+  dispose() {
+    this.stopped = true;
+    this.followUp = false;
+    this.revision++;
+    this.abort.abort();
+  }
+};
+
 // src/lifetime-view.tsx
 function lifetimeTracker(api) {
-  const directory = path7.join(api.state.path.state, "opencode-reviewer");
-  const store = new LifetimeUsage(path7.join(directory, "usage-v2"), path7.join(directory, "usage-v1"));
+  const directory = path8.join(api.state.path.state, "opencode-reviewer");
+  const store = new LifetimeUsage(path8.join(directory, "usage-v2"), path8.join(directory, "usage-v1"));
   const [totals, setTotals] = createSignal();
   const [unavailable, setUnavailable] = createSignal(false);
-  let alive = true, revision = 0;
-  const refresh = async () => {
-    const current = ++revision;
-    try {
-      const value = await withDeadline(api.lifecycle.signal, 5e3, (signal) => store.totals(signal));
-      if (alive && revision === current) {
-        setTotals(value);
-        setUnavailable(false);
-      }
-    } catch {
-      if (alive && revision === current) setUnavailable(true);
-    }
-  };
+  const refresh = new LifetimeRefresh((signal) => store.totals(signal), (value) => {
+    if (value) {
+      setTotals(value);
+      setUnavailable(false);
+    } else setUnavailable(true);
+  }, api.lifecycle.signal);
   const unregister = api.keymap.registerLayer({
     commands: [{
       name: "opencode-reviewer.lifetime",
@@ -3172,7 +3607,7 @@ function lifetimeTracker(api) {
       title: "Reviewer: Lifetime usage",
       category: "Reviewer",
       run: () => {
-        void refresh();
+        refresh.refresh();
         api.ui.dialog.replace(() => _$createComponent(api.ui.DialogAlert, {
           title: "Reviewer lifetime usage",
           get message() {
@@ -3183,47 +3618,43 @@ function lifetimeTracker(api) {
     }]
   });
   api.lifecycle.onDispose(() => {
-    alive = false;
+    refresh.dispose();
     unregister();
   });
-  void refresh();
+  refresh.refresh();
   return {
     // The controller must settle aborted review workers before this final queue drain.
     flush: () => store.flush().catch(() => {
     }),
     text: () => unavailable() ? "lifetime: usage unavailable" : totals()?.requests ? lifetimeCost(totals()) : void 0,
     record: (usage) => {
-      void store.record(usage).then(refresh, () => {
-        if (alive) {
-          revision++;
-          setUnavailable(true);
-        }
-      });
+      void store.record(usage).then(() => refresh.refresh(), () => refresh.failed());
     }
   };
 }
 
 // src/tui.tsx
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/session-mode.ts
 init_define_REVIEW_PROMPTS();
 import { constants as constants4 } from "node:fs";
 import { mkdir as mkdir2, open as open4, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import path8 from "node:path";
+import path9 from "node:path";
+var MAX_MODE_READS = 2;
 var SessionModeStore = class {
   constructor(directory, host) {
     this.directory = directory;
     this.host = host;
-    if (!path8.isAbsolute(directory)) throw new Error("Session mode directory must be absolute");
+    if (!path9.isAbsolute(directory)) throw new Error("Session mode directory must be absolute");
   }
   directory;
   host;
   pending = Promise.resolve();
   file(root) {
     const key = createHash("sha256").update(JSON.stringify([this.host, root])).digest("hex");
-    return path8.join(this.directory, `${key}.json`);
+    return path9.join(this.directory, `${key}.json`);
   }
   async read(root, signal) {
     signal.throwIfAborted();
@@ -3238,12 +3669,14 @@ var SessionModeStore = class {
     try {
       signal.throwIfAborted();
       const stat = await file.stat();
+      signal.throwIfAborted();
       if (!stat.isFile() || stat.size > 1024) throw new Error("Invalid session mode record");
       const buffer = Buffer.alloc(1025);
       let size = 0;
       while (size < buffer.length) {
         signal.throwIfAborted();
         const result = await file.read(buffer, size, buffer.length - size, size);
+        signal.throwIfAborted();
         if (!result.bytesRead) break;
         size += result.bytesRead;
       }
@@ -3300,6 +3733,12 @@ var SessionModes = class {
   roots = /* @__PURE__ */ new Map();
   values = /* @__PURE__ */ new Map();
   changes = /* @__PURE__ */ new Map();
+  reads = /* @__PURE__ */ new Map();
+  remember(visited, root, edges) {
+    if (this.roots.size + visited.size > 4096) this.roots.clear();
+    for (const child of visited) this.roots.set(child, { root, edges: edges-- });
+    return root;
+  }
   root(sessionID, parent) {
     return withDeadline(parent, 5e3, async (signal) => {
       const visited = /* @__PURE__ */ new Set();
@@ -3308,29 +3747,57 @@ var SessionModes = class {
         signal.throwIfAborted();
         if (!id || visited.has(id)) throw new Error("Session ancestry unavailable");
         const cached = this.roots.get(id);
-        if (cached) return cached;
+        if (cached) {
+          if (depth + cached.edges > 16) throw new Error("Session ancestry limit reached");
+          return this.remember(visited, cached.root, depth + cached.edges);
+        }
         visited.add(id);
         const value = await this.session(id, signal);
         signal.throwIfAborted();
         if (value?.id !== id || value.parentID !== void 0 && (typeof value.parentID !== "string" || !value.parentID)) {
           throw new Error("Session ancestry unavailable");
         }
-        if (!value.parentID) {
-          if (this.roots.size + visited.size > 4096) this.roots.clear();
-          for (const child of visited) this.roots.set(child, id);
-          return id;
-        }
+        if (!value.parentID) return this.remember(visited, id, depth);
         id = value.parentID;
       }
       throw new Error("Session ancestry limit reached");
     }, "Session mode ancestry");
   }
   async load(root, parent) {
+    parent.throwIfAborted();
     if (this.values.has(root)) return;
+    const pending = this.reads.get(root);
+    if (pending) return withDeadline(parent, 5e3, () => pending.wait, "Session mode loading");
+    if (this.reads.size >= MAX_MODE_READS) throw new Error("Session mode read capacity unavailable");
+    const read = { settled: true, finished: false };
+    this.reads.set(root, read);
+    return read.wait = this.loadMode(root, parent, read);
+  }
+  async loadMode(root, parent, read) {
     const revision = this.changes.get(root);
-    const value = await withDeadline(parent, 5e3, (signal) => this.store.read(root, signal), "Session mode loading");
-    parent.throwIfAborted();
-    if (this.changes.get(root) === revision) this.values.set(root, value);
+    try {
+      const value = await withDeadline(parent, 5e3, (signal) => {
+        read.settled = false;
+        const worker = Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return this.store.read(root, signal);
+        });
+        const settled = () => {
+          read.settled = true;
+          this.releaseRead(root, read);
+        };
+        void worker.then(settled, settled);
+        return worker;
+      }, "Session mode loading");
+      parent.throwIfAborted();
+      if (this.changes.get(root) === revision) this.values.set(root, value);
+    } finally {
+      read.finished = true;
+      this.releaseRead(root, read);
+    }
+  }
+  releaseRead(root, read) {
+    if (read.finished && read.settled && this.reads.get(root) === read) this.reads.delete(root);
   }
   enabled(root) {
     return this.values.get(root) === true;
@@ -3341,7 +3808,7 @@ var SessionModes = class {
     return this.store.write(root, enabled);
   }
   deleted(id) {
-    for (const [child, root] of this.roots) if (child === id || root === id) this.roots.delete(child);
+    for (const [child, value] of this.roots) if (child === id || value.root === id) this.roots.delete(child);
   }
   flush() {
     return this.store.flush();
@@ -3697,15 +4164,15 @@ async function reviewTui(api, options, fileIO, observer) {
   const hostTrace = observer ? new DiagnosticTrace(observer, 0) : void 0;
   const traces = observer ? /* @__PURE__ */ new WeakMap() : void 0;
   let reviewSequence = 0;
-  const reader = contextReader(api, hostTrace);
-  const modes = new SessionModes(new SessionModeStore(path9.join(api.state.path.state, "opencode-reviewer", "session-mode-v1"), api.state.path.directory), async (id, signal) => api.state.session.get(id) ?? reader.session(id, signal));
+  const reader2 = contextReader(api, hostTrace);
+  const modes = new SessionModes(new SessionModeStore(path10.join(api.state.path.state, "opencode-reviewer", "session-mode-v1"), api.state.path.directory), async (id, signal) => api.state.session.get(id) ?? reader2.session(id, signal));
   const files = new FileAccess(fileIO);
   const approval = approvalTransport(api.client, api.state.path.directory);
   let visibleApproval = () => void 0;
   const controller = new Controller(async (request, parent, onIdentified, onProgress) => {
     const trace = observer ? new DiagnosticTrace(observer, ++reviewSequence) : void 0;
     if (trace) traces.set(request, trace);
-    const reviewReader = trace ? contextReader(api, trace) : reader;
+    const reviewReader = trace ? contextReader(api, trace) : reader2;
     let worker;
     try {
       return await withDeadline(parent, config?.timeoutMs ?? 3e4, async (signal) => {
@@ -3740,35 +4207,8 @@ async function reviewTui(api, options, fileIO, observer) {
     modes.deleted(event.properties.info.id);
     controller.deleted(event.properties.info.id);
   });
-  let syncing = false;
-  let stopped = false;
-  let refreshAgain = false;
-  const refresh = async () => {
-    if (stopped) return;
-    if (syncing) {
-      refreshAgain = true;
-      return;
-    }
-    syncing = true;
-    const revision = controller.revision;
-    try {
-      await withDeadline(api.lifecycle.signal, 5e3, async (signal) => {
-        const result = await measured(hostTrace, "pending-refresh", () => api.client.permission.list({
-          directory: api.state.path.directory
-        }, {
-          signal
-        }));
-        if (result.data) controller.reconcile(result.data, revision);
-      });
-    } catch {
-    } finally {
-      syncing = false;
-      if (refreshAgain) {
-        refreshAgain = false;
-        void refresh();
-      }
-    }
-  };
+  const pendingRefresh = new PendingRefresh(controller, (signal) => measured(hostTrace, "pending-refresh", () => approval.list(signal)), api.lifecycle.signal);
+  const refresh = () => pendingRefresh.refresh();
   const unregisterMode = sessionModeCommands(api, modes, (root) => {
     controller.modeChanged(root);
     void refresh();
@@ -3778,7 +4218,7 @@ async function reviewTui(api, options, fileIO, observer) {
   api.event.on("session.idle", () => void refresh());
   api.event.on("session.error", () => void refresh());
   api.lifecycle.onDispose(async () => {
-    stopped = true;
+    pendingRefresh.dispose();
     clearInterval(interval);
     setSidebar(void 0);
     unregisterMode();
@@ -3912,7 +4352,7 @@ async function reviewTui(api, options, fileIO, observer) {
                 }), null);
                 _$insert(_el$14, _$createComponent2(Show, {
                   get when() {
-                    return view().status === "analyzing";
+                    return _$memo2(() => view().status === "analyzing")() && rating() === void 0;
                   },
                   get children() {
                     return _$createComponent2(ReviewLoading, {