@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/{chunk-E5QQZDQN.js → chunk-HNWS7YHN.js}

@@ -5,6 +5,9 @@ import {
   checkPermission
 } from "./chunk-2O2UKMUE.js";
 
+// src/runtime/agent-loop.ts
+import { basename } from "path";
+
 // src/runtime/stall-detection.ts
 import { createHash } from "crypto";
 var STALL_LIMITS = {
@@ -291,6 +294,8 @@ var ContextManager = class {
    */
   async postCompact(removedCount, summaryLength) {
     this.state.estimatedTokens = 0;
+    this.state.inputTokens = 0;
+    this.state.outputTokens = 0;
     const currentPercent = this.percentUsed;
     for (const threshold of PRESSURE_THRESHOLDS) {
       if (currentPercent < threshold) {
@@ -347,176 +352,393 @@ function shouldWarnDenials(state) {
 }
 
 // src/runtime/agent-loop.ts
+var DeadlineExceededError = class extends Error {
+  constructor() {
+    super("agent loop deadline exceeded");
+    this.name = "DeadlineExceededError";
+  }
+};
+async function raceDeadline(work, remainingMs, onDeadline) {
+  if (remainingMs <= 0) {
+    onDeadline();
+    throw new DeadlineExceededError();
+  }
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      onDeadline();
+      reject(new DeadlineExceededError());
+    }, remainingMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([work, deadline]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var TIMED_OUT = /* @__PURE__ */ Symbol("timed-out");
+function withTimeout(p, ms) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), ms);
+    timer.unref?.();
+  });
+  return Promise.race([p, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+async function settleMutationAtDeadline(work, remainingMs, graceMs, onDeadline) {
+  const settled = work.then(
+    (value) => ({ status: "fulfilled", value }),
+    (reason) => ({ status: "rejected", reason })
+  );
+  if (remainingMs > 0) {
+    const first = await withTimeout(settled, remainingMs);
+    if (first !== TIMED_OUT) return { pastDeadline: false, settlement: first };
+  }
+  onDeadline();
+  if (graceMs > 0) {
+    const second = await withTimeout(settled, graceMs);
+    if (second !== TIMED_OUT) return { pastDeadline: true, settlement: second };
+  }
+  return { pastDeadline: true, settlement: { status: "indeterminate" } };
+}
+function createRunAbortController(parent) {
+  const controller = new AbortController();
+  if (!parent) return { controller, dispose: () => {
+  } };
+  if (parent.aborted) {
+    controller.abort(parent.reason);
+    return { controller, dispose: () => {
+    } };
+  }
+  const onParentAbort = () => controller.abort(parent.reason);
+  parent.addEventListener("abort", onParentAbort, { once: true });
+  return {
+    controller,
+    dispose: () => parent.removeEventListener("abort", onParentAbort)
+  };
+}
 async function* agentLoop(userMessage, history, config) {
   const messages = [
     ...history,
     { role: "user", content: userMessage }
   ];
   const totalUsage = { inputTokens: 0, outputTokens: 0 };
-  const abortController = config.abortController ?? new AbortController();
+  const userAbortSignal = config.abortController?.signal;
+  const { controller: abortController, dispose: disposeRunAbort } = createRunAbortController(userAbortSignal);
   const context = {
     cwd: config.cwd,
     agentId: config.agentId,
     abortSignal: abortController.signal,
     sessionState: /* @__PURE__ */ new Map()
   };
-  const allowedTools = config.tools.toAllowedNormalizedTools(config.permissions);
-  const contextManager = createContextManager(config.model, config.hooks);
-  let denialState = createDenialTrackingState();
-  let stallState = createStallState();
-  let turns = 0;
-  let activeModel = config.model;
-  let routedToFallback = false;
-  while (turns < config.maxTurns) {
-    turns++;
-    if (abortController.signal.aborted) {
-      yield { type: "aborted", reason: "Agent stopped by user" };
-      break;
-    }
-    if (config.maxTokenBudget && totalUsage.inputTokens + totalUsage.outputTokens >= config.maxTokenBudget) {
-      yield { type: "error", error: new Error("Token budget exceeded") };
-      break;
-    }
-    let response;
-    try {
-      response = await config.provider.createMessage({
-        model: activeModel,
-        system: config.systemPrompt,
-        messages,
-        tools: allowedTools.length > 0 ? allowedTools : void 0,
-        maxTokens: 4096
-      });
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      yield { type: "error", error };
-      if (config.hooks.onError) await config.hooks.onError(error, context);
-      break;
-    }
-    totalUsage.inputTokens += response.usage.inputTokens;
-    totalUsage.outputTokens += response.usage.outputTokens;
-    if (config.tokenBudgetMiddleware) {
-      const result = await config.tokenBudgetMiddleware.onTokenUsed(
-        response.usage.inputTokens,
-        response.usage.outputTokens
-      );
-      if (result.warned && config.hooks.onNotification) {
-        await config.hooks.onNotification(
-          `\u26A0\uFE0F Token budget at ${result.percentUsed}%. Fallback model: ${result.fallback ?? "none (task will terminate at 100%)"}.`
+  try {
+    const allowedTools = config.tools.toAllowedNormalizedTools(config.permissions);
+    const contextManager = createContextManager(config.model, config.hooks);
+    let denialState = createDenialTrackingState();
+    let stallState = createStallState();
+    let turns = 0;
+    let activeModel = config.model;
+    let routedToFallback = false;
+    const loopStartedAt = Date.now();
+    const maxDurationMs = config.maxDurationMs ?? 30 * 6e4;
+    const maxConsecutiveFailures = config.maxConsecutiveFailures ?? 6;
+    const mutationGraceMs = config.mutationGraceMs ?? 3e4;
+    let consecutiveFailedTurns = 0;
+    while (turns < config.maxTurns) {
+      turns++;
+      if (Date.now() - loopStartedAt >= maxDurationMs) {
+        yield {
+          type: "error",
+          error: new Error(
+            `Agent loop exceeded max duration (${maxDurationMs}ms) after ${turns - 1} turns \u2014 terminating to avoid an unbounded fetch loop.`
+          )
+        };
+        break;
+      }
+      if (abortController.signal.aborted) {
+        yield {
+          type: "aborted",
+          reason: userAbortSignal?.aborted ? "Agent stopped by user" : "Agent run aborted (internal wall-clock deadline or token cap)"
+        };
+        break;
+      }
+      if (config.maxTokenBudget && totalUsage.inputTokens + totalUsage.outputTokens >= config.maxTokenBudget) {
+        yield { type: "error", error: new Error("Token budget exceeded") };
+        break;
+      }
+      let response;
+      try {
+        response = await raceDeadline(
+          config.provider.createMessage({
+            model: activeModel,
+            system: config.systemPrompt,
+            messages,
+            tools: allowedTools.length > 0 ? allowedTools : void 0,
+            maxTokens: 4096,
+            abortSignal: abortController.signal
+          }),
+          maxDurationMs - (Date.now() - loopStartedAt),
+          () => abortController.abort()
         );
+      } catch (err) {
+        if (err instanceof DeadlineExceededError) {
+          yield {
+            type: "error",
+            error: new Error(
+              `Agent loop exceeded max duration (${maxDurationMs}ms) during a provider call after ${turns - 1} completed turns \u2014 aborted the in-flight request to enforce the wall-clock ceiling.`
+            )
+          };
+          break;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        yield { type: "error", error };
+        if (config.hooks.onError) await config.hooks.onError(error, context);
+        break;
       }
-      if (result.exceeded && !routedToFallback) {
-        if (config.hooks.onTokenBudgetExceeded) {
-          await config.hooks.onTokenBudgetExceeded(context, result.fallback);
+      totalUsage.inputTokens += response.usage.inputTokens;
+      totalUsage.outputTokens += response.usage.outputTokens;
+      if (config.tokenBudgetMiddleware) {
+        const result = await config.tokenBudgetMiddleware.onTokenUsed(
+          response.usage.inputTokens,
+          response.usage.outputTokens
+        );
+        if (result.warned && config.hooks.onNotification) {
+          await config.hooks.onNotification(
+            `\u26A0\uFE0F Token budget at ${result.percentUsed}%. Fallback model: ${result.fallback ?? "none (task will terminate at 100%)"}.`
+          );
         }
-        if (result.fallback && result.fallback !== activeModel) {
-          routedToFallback = true;
-          activeModel = result.fallback;
-          if (config.hooks.onNotification) {
-            await config.hooks.onNotification(
-              `\u{1F53B} Token budget exceeded \u2014 routing to fallback model ${result.fallback} to finish the task.`
-            );
+        if (result.exceeded && !routedToFallback) {
+          if (config.hooks.onTokenBudgetExceeded) {
+            await config.hooks.onTokenBudgetExceeded(context, result.fallback);
+          }
+          if (result.fallback && result.fallback !== activeModel) {
+            routedToFallback = true;
+            activeModel = result.fallback;
+            if (config.hooks.onNotification) {
+              await config.hooks.onNotification(
+                `\u{1F53B} Token budget exceeded \u2014 routing to fallback model ${result.fallback} to finish the task.`
+              );
+            }
+          } else {
+            abortController.abort();
+            yield { type: "error", error: new Error("Token budget exceeded. Task requires manual continuation.") };
+            break;
           }
-        } else {
-          abortController.abort();
-          yield { type: "error", error: new Error("Token budget exceeded. Task requires manual continuation.") };
-          break;
         }
       }
-    }
-    contextManager.updateFromApiUsage(response.usage.inputTokens, response.usage.outputTokens);
-    contextManager.updateFromMessages(messages);
-    await contextManager.checkPressure();
-    if (contextManager.shouldCompact() && messages.length > 12) {
-      const { memoriesToExtract } = await contextManager.preCompact(
-        messages.slice(0, -10)
-      );
-      if (memoriesToExtract.length > 0 && config.hooks.onNotification) {
-        await config.hooks.onNotification(
-          `Pre-compaction: extracted ${memoriesToExtract.length} key decisions to memory`
+      contextManager.updateFromApiUsage(response.usage.inputTokens, response.usage.outputTokens);
+      contextManager.updateFromMessages(messages);
+      await contextManager.checkPressure();
+      if (contextManager.shouldCompact() && messages.length > 12) {
+        const { memoriesToExtract } = await contextManager.preCompact(
+          messages.slice(0, -10)
         );
+        if (memoriesToExtract.length > 0) {
+          const persist = config.persistMemory ?? (await import("./memory-queue-client-ADSDP6OX.js")).writeMemoryViaDaemon;
+          const projectName = basename(config.cwd) || "unknown";
+          const sessionId = `exe-agent-${loopStartedAt}`;
+          let persistedCount = 0;
+          for (const decision of memoriesToExtract) {
+            try {
+              await persist({
+                raw_text: decision,
+                agent_id: config.agentId,
+                tool_name: "pre-compaction",
+                project_name: projectName,
+                session_id: sessionId,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                importance: 7,
+                memory_type: "decision"
+              });
+              persistedCount++;
+            } catch {
+            }
+          }
+          if (persistedCount > 0 && config.hooks.onNotification) {
+            await config.hooks.onNotification(
+              `Pre-compaction: extracted ${persistedCount} key decisions to memory`
+            );
+          }
+        }
+        const compacted = await compactMessages(messages, config.provider, config.model);
+        const removedCount = compacted.removedCount;
+        if (removedCount > 0) {
+          messages.length = 0;
+          messages.push(...compacted.messages);
+          await contextManager.postCompact(removedCount, messages[0]?.content?.toString().length ?? 0);
+        }
       }
-      const compacted = await compactMessages(messages, config.provider, config.model);
-      const removedCount = compacted.removedCount;
-      if (removedCount > 0) {
-        messages.length = 0;
-        messages.push(...compacted.messages);
-        await contextManager.postCompact(removedCount, messages[0]?.content?.toString().length ?? 0);
+      for (const block of response.content) {
+        if (block.type === "text" && block.text) {
+          yield { type: "text", text: block.text };
+        }
       }
-    }
-    for (const block of response.content) {
-      if (block.type === "text" && block.text) {
-        yield { type: "text", text: block.text };
+      messages.push({ role: "assistant", content: response.content });
+      if (response.stopReason === "end_turn" || response.stopReason === "max_tokens") {
+        yield { type: "turn_complete", turn: turns, usage: response.usage };
+        break;
       }
-    }
-    messages.push({ role: "assistant", content: response.content });
-    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens") {
-      yield { type: "turn_complete", turn: turns, usage: response.usage };
-      break;
-    }
-    const toolUseBlocks = response.content.filter(
-      (b) => b.type === "tool_use"
-    );
-    if (toolUseBlocks.length === 0) {
-      yield { type: "turn_complete", turn: turns, usage: response.usage };
-      break;
-    }
-    const { concurrent, sequential } = partitionTools(toolUseBlocks, config.tools);
-    const toolResults = [];
-    if (concurrent.length > 0) {
-      const concurrentResults = await Promise.all(
-        concurrent.map(
-          (block) => executeToolBlock(
-            block,
-            config,
-            context,
-            denialState
-          )
-        )
+      const toolUseBlocks = response.content.filter(
+        (b) => b.type === "tool_use"
       );
-      for (let i = 0; i < concurrent.length; i++) {
-        const block = concurrent[i];
-        const execResult = concurrentResults[i];
+      if (toolUseBlocks.length === 0) {
+        yield { type: "turn_complete", turn: turns, usage: response.usage };
+        break;
+      }
+      const { concurrent, sequential } = partitionTools(toolUseBlocks, config.tools);
+      const toolResults = [];
+      if (concurrent.length > 0) {
+        let concurrentResults;
+        try {
+          concurrentResults = await raceDeadline(
+            Promise.all(
+              concurrent.map(
+                (block) => executeToolBlock(
+                  block,
+                  config,
+                  context,
+                  denialState
+                )
+              )
+            ),
+            maxDurationMs - (Date.now() - loopStartedAt),
+            () => abortController.abort()
+          );
+        } catch (err) {
+          if (err instanceof DeadlineExceededError) {
+            yield {
+              type: "error",
+              error: new Error(
+                `Agent loop exceeded max duration (${maxDurationMs}ms) during read-only tool execution after ${turns - 1} completed turns \u2014 abandoned the in-flight read-only calls to enforce the wall-clock ceiling.`
+              )
+            };
+            break;
+          }
+          throw err;
+        }
+        for (let i = 0; i < concurrent.length; i++) {
+          const block = concurrent[i];
+          const execResult = concurrentResults[i];
+          denialState = execResult.denialState;
+          yield execResult.event;
+          if (execResult.permissionEvent) yield execResult.permissionEvent;
+          yield { type: "tool_result", name: block.name, id: block.id, result: execResult.result };
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: execResult.result.content,
+            is_error: execResult.result.isError
+          });
+        }
+      }
+      let sequentialTimedOut = false;
+      let indeterminateTool = null;
+      for (const block of sequential) {
+        const typedBlock = block;
+        const isMutating = !(config.tools.get(typedBlock.name)?.isReadOnly === true);
+        const remainingMs = maxDurationMs - (Date.now() - loopStartedAt);
+        let execResult;
+        if (!isMutating) {
+          try {
+            execResult = await raceDeadline(
+              executeToolBlock(typedBlock, config, context, denialState),
+              remainingMs,
+              () => abortController.abort()
+            );
+          } catch (err) {
+            if (err instanceof DeadlineExceededError) {
+              sequentialTimedOut = true;
+              break;
+            }
+            throw err;
+          }
+        } else {
+          const { pastDeadline, settlement } = await settleMutationAtDeadline(
+            executeToolBlock(typedBlock, config, context, denialState),
+            remainingMs,
+            mutationGraceMs,
+            () => abortController.abort()
+          );
+          if (settlement.status === "indeterminate") {
+            indeterminateTool = typedBlock.name;
+            const result = {
+              content: `INDETERMINATE: "${typedBlock.name}" was still running when the agent loop's wall-clock deadline (${maxDurationMs}ms) and the ${mutationGraceMs}ms mutation grace window both elapsed. It is a mutating tool, so it may or may not have applied its changes. Do NOT assume it did not happen \u2014 verify the target state before retrying.`,
+              isError: true
+            };
+            yield { type: "tool_result", name: typedBlock.name, id: typedBlock.id, result };
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: typedBlock.id,
+              content: result.content,
+              is_error: true
+            });
+            sequentialTimedOut = true;
+            break;
+          }
+          if (settlement.status === "rejected") {
+            const reason = settlement.reason;
+            throw reason instanceof Error ? reason : new Error(String(reason));
+          }
+          execResult = settlement.value;
+          if (pastDeadline) sequentialTimedOut = true;
+        }
         denialState = execResult.denialState;
         yield execResult.event;
         if (execResult.permissionEvent) yield execResult.permissionEvent;
-        yield { type: "tool_result", name: block.name, id: block.id, result: execResult.result };
+        yield { type: "tool_result", name: typedBlock.name, id: typedBlock.id, result: execResult.result };
         toolResults.push({
           type: "tool_result",
-          tool_use_id: block.id,
+          tool_use_id: typedBlock.id,
           content: execResult.result.content,
           is_error: execResult.result.isError
         });
+        if (sequentialTimedOut) break;
+      }
+      if (sequentialTimedOut) {
+        yield {
+          type: "error",
+          error: new Error(
+            indeterminateTool ? `Agent loop exceeded max duration (${maxDurationMs}ms) during tool execution after ${turns - 1} completed turns. The mutating tool "${indeterminateTool}" did not finish within the ${mutationGraceMs}ms grace window, so its outcome is INDETERMINATE \u2014 it may still apply changes.` : `Agent loop exceeded max duration (${maxDurationMs}ms) during tool execution after ${turns - 1} completed turns \u2014 in-flight read-only calls were abandoned; any in-flight mutation was awaited to completion and its result recorded.`
+          )
+        };
+        break;
+      }
+      messages.push({ role: "user", content: toolResults });
+      yield { type: "turn_complete", turn: turns, usage: response.usage };
+      stallState = recordTurn(stallState, turnSignature(
+        toolUseBlocks.map((b) => ({ name: b.name, input: b.input })),
+        toolResults.map((r) => ({
+          content: typeof r.content === "string" ? r.content : "",
+          isError: Boolean(r.is_error)
+        }))
+      ));
+      if (isStalled(stallState)) {
+        yield { type: "error", error: new Error(stallReason(stallState, toolUseBlocks.map((b) => b.name))) };
+        break;
+      }
+      const allToolsFailed = toolUseBlocks.length > 0 && toolResults.length > 0 && toolResults.every((r) => Boolean(r.is_error));
+      if (allToolsFailed) {
+        consecutiveFailedTurns++;
+      } else {
+        consecutiveFailedTurns = 0;
+      }
+      if (consecutiveFailedTurns >= maxConsecutiveFailures) {
+        yield {
+          type: "error",
+          error: new Error(
+            `Agent loop circuit breaker tripped: ${consecutiveFailedTurns} consecutive turns with only failing tool calls \u2014 terminating to avoid an unbounded fetch loop.`
+          )
+        };
+        break;
       }
     }
-    for (const block of sequential) {
-      const typedBlock = block;
-      const execResult = await executeToolBlock(typedBlock, config, context, denialState);
-      denialState = execResult.denialState;
-      yield execResult.event;
-      if (execResult.permissionEvent) yield execResult.permissionEvent;
-      yield { type: "tool_result", name: typedBlock.name, id: typedBlock.id, result: execResult.result };
-      toolResults.push({
-        type: "tool_result",
-        tool_use_id: typedBlock.id,
-        content: execResult.result.content,
-        is_error: execResult.result.isError
-      });
-    }
-    messages.push({ role: "user", content: toolResults });
-    yield { type: "turn_complete", turn: turns, usage: response.usage };
-    stallState = recordTurn(stallState, turnSignature(
-      toolUseBlocks.map((b) => ({ name: b.name, input: b.input })),
-      toolResults.map((r) => ({
-        content: typeof r.content === "string" ? r.content : "",
-        isError: Boolean(r.is_error)
-      }))
-    ));
-    if (isStalled(stallState)) {
-      yield { type: "error", error: new Error(stallReason(stallState, toolUseBlocks.map((b) => b.name))) };
-      break;
-    }
+    yield { type: "done", totalUsage, turns };
+  } finally {
+    disposeRunAbort();
   }
-  yield { type: "done", totalUsage, turns };
 }
 async function executeToolBlock(block, config, context, denialState) {
   const startEvent = { type: "tool_use_start", name: block.name, id: block.id };

package/dist/{chunk-VV5EZZNT.js → chunk-HTBEVCO2.js}

@@ -1,6 +1,6 @@
 import {
   resolveExeDataDir
-} from "./chunk-JTB5V6BV.js";
+} from "./chunk-3SXHEQ7X.js";
 import {
   isValidX25519Recipient,
   pubKeyHash

package/dist/{chunk-OZBII5E3.js → chunk-I4DNJFDR.js}

@@ -1,13 +1,13 @@
 import {
   deactivateBehavior
-} from "./chunk-MBNIJXKI.js";
+} from "./chunk-WMEYJT4R.js";
 import {
   getActiveAgent
-} from "./chunk-KYFFVTGO.js";
+} from "./chunk-55BEFF4V.js";
 import {
   canCoordinate,
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/mcp/tools/deactivate-behavior.ts
 import { z } from "zod";
@@ -24,7 +24,7 @@ function registerDeactivateBehavior(server) {
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
       try {
-        const { StewardGate } = await import("./steward-gate-LTNFB3FY.js");
+        const { StewardGate } = await import("./steward-gate-BFCCMCSW.js");
         const steward = new StewardGate();
         const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
         if (!gateDecision.allowed) {

package/dist/{chunk-SI5SZAJA.js → chunk-IBS2FAI4.js}

@@ -95,6 +95,11 @@ function parsePrJson(raw) {
     return [];
   }
 }
+function parseSupersededByTrailer(body) {
+  if (!body) return null;
+  const m = /^\s*(?:superseded-by|closed-in-favor-of|replaced-by)\s*:\s*#(\d+)\s*$/im.exec(body);
+  return m ? parseInt(m[1], 10) : null;
+}
 async function mapPool(items, concurrency, fn) {
   const results = new Array(items.length);
   let next = 0;
@@ -123,15 +128,20 @@ var ghPrStateLookup = async (repoRoot, branchNames) => {
         "--limit",
         String(BULK_PR_LIMIT),
         "--json",
-        "number,state,mergedAt,headRefName"
+        "number,state,mergedAt,headRefName,body"
       ],
       repoRoot
     );
   } catch {
     return null;
   }
+  const allPrs = parsePrJson(bulkRaw);
+  const mergedByNumber = /* @__PURE__ */ new Map();
+  for (const pr of allPrs) {
+    if (typeof pr.number === "number") mergedByNumber.set(pr.number, !!pr.mergedAt);
+  }
   const best = /* @__PURE__ */ new Map();
-  for (const pr of parsePrJson(bulkRaw)) {
+  for (const pr of allPrs) {
     const head = pr.headRefName;
     if (!head) continue;
     const cur = best.get(head);
@@ -141,8 +151,15 @@ var ghPrStateLookup = async (repoRoot, branchNames) => {
   const missing = [];
   for (const name of branchNames) {
     const pr = best.get(name);
-    if (pr) result.set(name, { state: toState(pr), number: pr.number ?? null });
-    else missing.push(name);
+    if (pr) {
+      const state = toState(pr);
+      let supersededByMerged = false;
+      if (state === "closed_unmerged") {
+        const target = parseSupersededByTrailer(pr.body);
+        if (target !== null && mergedByNumber.get(target) === true) supersededByMerged = true;
+      }
+      result.set(name, { state, number: pr.number ?? null, supersededByMerged });
+    } else missing.push(name);
   }
   const targeted = missing.slice(0, MAX_TARGETED_PR_LOOKUPS);
   const overflow = missing.slice(MAX_TARGETED_PR_LOOKUPS);

package/dist/{chunk-J5EYOBFF.js → chunk-IHXW4VUI.js}

@@ -2,7 +2,7 @@ import {
   MODELS_DIR,
   loadConfigSync,
   resolveEmbedModelFile
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/backfill-gate.ts
 import { existsSync } from "fs";