mixdog 0.9.173 → 0.9.174

package/src/runtime/agent/orchestrator/session/token-estimate-floors.mjs

@@ -1,35 +1,147 @@
-// Exact auxiliary floors for the token estimator. Count whole matching runs
-// rather than allocating one array entry per non-whitespace character.
-function matchingChars(text, expression) {
-  let count = 0;
-  for (const match of text.matchAll(expression)) count += match[0].length;
-  return count;
+// Exact auxiliary floors for the token estimator, computed by single
+// charCodeAt scans that allocate nothing. Each scanner reproduces, code unit
+// for code unit, the regular expression it replaced (named above each one);
+// the differential tests pin them against those expressions.
+
+// RegExp `\s` and String#trim whitespace: WhiteSpace + LineTerminator.
+export function isWhitespace(c) {
+  if (c <= 0x20) return c === 0x20 || (c >= 0x09 && c <= 0x0d);
+  if (c < 0xa0) return false;
+  return (
+    c === 0xa0 ||
+    c === 0x1680 ||
+    (c >= 0x2000 && c <= 0x200a) ||
+    c === 0x2028 ||
+    c === 0x2029 ||
+    c === 0x202f ||
+    c === 0x205f ||
+    c === 0x3000 ||
+    c === 0xfeff
+  );
+}
+
+// Characters RegExp `.` refuses to match (a `\n` never occurs inside a line).
+function isLineTerminator(c) {
+  return c === 0x0d || c === 0x2028 || c === 0x2029;
 }
 
+function isStructural(c) {
+  // [ ] { } " : , = < > | \
+  return (
+    c === 0x5b ||
+    c === 0x5d ||
+    c === 0x7b ||
+    c === 0x7d ||
+    c === 0x22 ||
+    c === 0x3a ||
+    c === 0x2c ||
+    c === 0x3d ||
+    c === 0x3c ||
+    c === 0x3e ||
+    c === 0x7c ||
+    c === 0x5c
+  );
+}
+
+const UNDERSCORE = 0x5f;
+
+// Dense runs: /[\x21-\x7e]{16,}/g, each run priced by its length.
+// Encoded words: /\b(?=[A-Za-z0-9]{8,}\b)(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*\d)[A-Za-z0-9]+\b/g
+// matches exactly the maximal alphanumeric runs of 8+ characters holding a
+// letter and a digit whose neighbours are not `_` (the only other `\w`).
 export function denseTokenFloor(s) {
+  const length = s.length;
   let floor = 0;
-  for (const match of s.matchAll(/[\x21-\x7e]{16,}/g)) {
-    floor += match[0].length * (match[0].length >= 64 ? 0.65 : 0.5);
+  let denseRun = 0;
+  let wordStart = -1;
+  let wordLetter = false;
+  let wordDigit = false;
+  let encodedWords = 0;
+  let encodedChars = 0;
+  for (let index = 0; index <= length; index += 1) {
+    const c = index < length ? s.charCodeAt(index) : -1;
+    if (c >= 0x21 && c <= 0x7e) {
+      denseRun += 1;
+    } else if (denseRun) {
+      if (denseRun >= 16) floor += denseRun * (denseRun >= 64 ? 0.65 : 0.5);
+      denseRun = 0;
+    }
+    const digit = c >= 0x30 && c <= 0x39;
+    const letter = (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a);
+    if (digit || letter) {
+      if (wordStart < 0) {
+        wordStart = index;
+        wordLetter = false;
+        wordDigit = false;
+      }
+      wordLetter ||= letter;
+      wordDigit ||= digit;
+    } else if (wordStart >= 0) {
+      if (
+        index - wordStart >= 8 &&
+        wordLetter &&
+        wordDigit &&
+        c !== UNDERSCORE &&
+        (wordStart === 0 || s.charCodeAt(wordStart - 1) !== UNDERSCORE)
+      ) {
+        encodedWords += 1;
+        encodedChars += index - wordStart;
+      }
+      wordStart = -1;
+    }
   }
-  const encodedWords =
-    s.match(/\b(?=[A-Za-z0-9]{8,}\b)(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*\d)[A-Za-z0-9]+\b/g) || [];
-  if (encodedWords.length >= 3) {
-    const encodedChars = encodedWords.reduce((sum, word) => sum + word.length, 0);
-    floor = Math.max(floor, encodedChars * 0.5 + (s.length - encodedChars) * 0.25);
+  if (encodedWords >= 3) {
+    floor = Math.max(floor, encodedChars * 0.5 + (length - encodedChars) * 0.25);
   }
   return floor;
 }
 
+// Lines: s.split(/\r?\n/) keeping those with line.trim(); a line is JSON-like
+// when it matches /^\s*[[{].*[\]}],?\s*$/. Non-whitespace counts /\S/ code
+// units and structural counts /[[\]{}":,=<>|\\]/ code units. Splitting on
+// `\n` alone is equivalent: the `\r` of a CRLF is trailing whitespace.
 export function structuredTokenFloor(s) {
-  const lines = s.split(/\r?\n/).filter((line) => line.trim());
+  const length = s.length;
+  let lines = 0;
+  let jsonLikeLines = 0;
+  let nonWhitespace = 0;
+  let structural = 0;
+  let first = -1; // first non-whitespace index of the current line
+  let last = -1; // last non-whitespace index of the current line
+  let pendingTerminator = false; // a `.`-breaking terminator after `first`
+  let innerTerminator = false; // ...followed by more non-whitespace
+  for (let index = 0; index <= length; index += 1) {
+    const c = index < length ? s.charCodeAt(index) : 0x0a;
+    if (c === 0x0a) {
+      if (first >= 0) {
+        lines += 1;
+        const open = s.charCodeAt(first);
+        let close = s.charCodeAt(last);
+        if (close === 0x2c && last - 1 > first) close = s.charCodeAt(last - 1);
+        if ((open === 0x5b || open === 0x7b) && (close === 0x5d || close === 0x7d) && !innerTerminator) {
+          jsonLikeLines += 1;
+        }
+      }
+      first = -1;
+      last = -1;
+      pendingTerminator = false;
+      innerTerminator = false;
+      continue;
+    }
+    if (isWhitespace(c)) {
+      if (first >= 0 && isLineTerminator(c)) pendingTerminator = true;
+      continue;
+    }
+    nonWhitespace += 1;
+    if (isStructural(c)) structural += 1;
+    if (first < 0) first = index;
+    else if (pendingTerminator) innerTerminator = true;
+    last = index;
+  }
   // None of the structured-text conditions can apply to fewer than three
-  // nonblank lines. Avoid scanning ordinary single-line messages again.
-  if (lines.length < 3) return 0;
-  const nonWhitespace = matchingChars(s, /\S+/g);
-  if (nonWhitespace === 0) return 0;
-  const structural = matchingChars(s, /[[\]{}":,=<>|\\]+/g);
-  const jsonLikeLines = lines.filter((line) => /^\s*[[{].*[\]}],?\s*$/.test(line)).length;
-  return jsonLikeLines >= Math.ceil(lines.length / 2) || structural / nonWhitespace >= 0.12
-    ? nonWhitespace * 0.5 + (s.length - nonWhitespace) * 0.25
+  // nonblank lines.
+  if (lines < 3 || nonWhitespace === 0) return 0;
+  return jsonLikeLines >= Math.ceil(lines / 2) || structural / nonWhitespace >= 0.12
+    ? nonWhitespace * 0.5 + (length - nonWhitespace) * 0.25
     : 0;
 }

package/src/runtime/agent/orchestrator/session/token-estimate.mjs

@@ -89,8 +89,21 @@ function codePointTokenWeight(cp) {
 export function estimateTokens(text) {
   const s = String(text ?? '');
   if (s.length === 0) return 0;
+  // Walk code points exactly like `for (const ch of s)` (a lone surrogate is
+  // its own code point) without materializing a string per character.
   let weighted = 0;
-  for (const ch of s) weighted += codePointTokenWeight(ch.codePointAt(0));
+  const length = s.length;
+  for (let index = 0; index < length; index += 1) {
+    let cp = s.charCodeAt(index);
+    if (cp >= 0xd800 && cp <= 0xdbff && index + 1 < length) {
+      const low = s.charCodeAt(index + 1);
+      if (low >= 0xdc00 && low <= 0xdfff) {
+        cp = (cp - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+        index += 1;
+      }
+    }
+    weighted += codePointTokenWeight(cp);
+  }
   const denseAsciiFloor = Math.max(denseTokenFloor(s), structuredTokenFloor(s));
   const asciiFloor = s.length / 4; // never below the legacy chars/4 lower bound
   return Math.ceil(Math.max(weighted, asciiFloor, denseAsciiFloor) * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);

package/src/runtime/agent/orchestrator/session/tool-batch/execute-call.mjs

@@ -2,7 +2,6 @@
 // eager-result consumption or serial execution, and the same-anchor edit
 // retry. Returns the execution record the outcome/finalize phases consume.
 import { markSessionToolCall } from '../manager.mjs';
-import { resolveToolSelfDeadlineMs } from '../../agent-runtime/agent-progress-watchdog.mjs';
 import { classifyResultKind } from '../result-classification.mjs';
 import { normalizeToolEnvelope } from '../tool-envelope.mjs';
 import { captureReadCacheState, tryReadCached, tryScopedToolCached } from '../read-dedup.mjs';
@@ -21,7 +20,7 @@ function classifyToolReturn(value, toolName = '') {
 
 export async function executeBatchCall(batch, call, callIndex) {
   const { sessionId, sessionRef } = batch;
-  if (sessionId) markSessionToolCall(sessionId, call.name, resolveToolSelfDeadlineMs(call.name, call.arguments));
+  if (sessionId) markSessionToolCall(sessionId, call.name);
   const exec = {
     result: undefined,
     resultKind: 'normal',
@@ -224,42 +223,36 @@ function recordExecutionInterval(exec) {
 // rejected edit had no side effects, so re-execution is safe.
 async function retryAmbiguousEdit(batch, call, exec) {
   const group = editSeqGroupFor(batch.plan, call);
-  if (
-    group &&
-    exec.resultKind === 'error' &&
-    typeof exec.result === 'string' &&
-    /old_string found \d+ times/.test(exec.result)
-  ) {
-    const remaining = group.total - group.applied;
-    if (remaining >= 1) {
-      const retryStartedAt = Date.now();
-      try {
-        const retry = await batch.executeToolFn(
-          call.name,
-          call.arguments,
-          batch.cwd,
-          batch.sessionId,
-          batch.sessionRef,
-          {
-            ...invocationOptions(batch, call, exec),
-            ...(remaining >= 2 ? { editOccurrence: { expected: remaining } } : {}),
-          }
-        );
-        if (classifyToolReturn(retry, call.name) !== 'error') {
-          exec.result = retry;
-          exec.resultKind = 'normal';
-          exec.executeOk = true;
-          exec.toolEndedAt = Date.now();
-          // Mirror the eager mutation epoch: later read-only eager results
-          // computed against pre-edit content must re-execute.
-          batch.epoch.mutation += 1;
-        }
-      } catch {
-        /* keep the original ambiguity error */
-      } finally {
-        exec.executionIntervals.push({ started_at_ms: retryStartedAt, completed_at_ms: Date.now() });
-      }
-    }
+  if (!group) return;
+  const remaining = group.total - group.applied;
+  if (remaining >= 1 && isAmbiguousEditFailure(exec)) await rerunAmbiguousEdit(batch, call, exec, remaining);
+  if (exec.executeOk && exec.resultKind !== 'skipped') group.applied += 1;
+}
+
+function isAmbiguousEditFailure(exec) {
+  return (
+    exec.resultKind === 'error' && typeof exec.result === 'string' && /old_string found \d+ times/.test(exec.result)
+  );
+}
+
+async function rerunAmbiguousEdit(batch, call, exec, remaining) {
+  const retryStartedAt = Date.now();
+  try {
+    const retry = await batch.executeToolFn(call.name, call.arguments, batch.cwd, batch.sessionId, batch.sessionRef, {
+      ...invocationOptions(batch, call, exec),
+      ...(remaining >= 2 ? { editOccurrence: { expected: remaining } } : {}),
+    });
+    if (classifyToolReturn(retry, call.name) === 'error') return;
+    exec.result = retry;
+    exec.resultKind = 'normal';
+    exec.executeOk = true;
+    exec.toolEndedAt = Date.now();
+    // Mirror the eager mutation epoch: later read-only eager results
+    // computed against pre-edit content must re-execute.
+    batch.epoch.mutation += 1;
+  } catch {
+    /* keep the original ambiguity error */
+  } finally {
+    exec.executionIntervals.push({ started_at_ms: retryStartedAt, completed_at_ms: Date.now() });
   }
-  if (group && exec.executeOk && exec.resultKind !== 'skipped') group.applied += 1;
 }

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -16,7 +16,7 @@ import { lstat, open, readdir, readFile, stat, unlink, writeFile } from 'node:fs
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { getPluginData } from '../config.mjs';
-import { normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
+import { countSplitLines, normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
 import { classifyResultKind } from './result-classification.mjs';
 import { registerSessionPurgeHook } from './store.mjs';
 
@@ -190,15 +190,6 @@ function buildPreview(text, maxChars = TOOL_RESULT_PREVIEW_CHARS) {
   };
 }
 
-function countLines(text) {
-  if (!text) return 0;
-  let lines = 1;
-  for (let i = 0; i < text.length; i += 1) {
-    if (text.charCodeAt(i) === 10) lines += 1;
-  }
-  return lines;
-}
-
 function artifactMeta(sessionId, toolCallId, channel, content) {
   if (!sessionId || !toolCallId || typeof content !== 'string') return null;
   const sha256 = createHash('sha256').update(content, 'utf8').digest('hex');
@@ -208,7 +199,7 @@ function artifactMeta(sessionId, toolCallId, channel, content) {
     path: join(dir, artifactIdentity(sha256)),
     bytes: Buffer.byteLength(content, 'utf8'),
     chars: content.length,
-    lines: countLines(content),
+    lines: countSplitLines(content),
     sha256,
   };
 }
@@ -480,7 +471,9 @@ export async function pruneOffloadSession(sessionId, getMessages) {
   } catch {
     /* best-effort */
   }
-  if (!candidates) return;
+  // Only an old sidecar can be deleted. Without one, nothing below could have
+  // any effect, so skip serializing the transcript and walking the archives.
+  if (!candidates?.length) return;
   let serialized;
   try {
     serialized = JSON.stringify(getMessages());
@@ -488,9 +481,27 @@ export async function pruneOffloadSession(sessionId, getMessages) {
     return;
   }
   const haystack = process.platform === 'win32' ? serialized.toLowerCase() : serialized;
+  // A sidecar whose path or name the transcript mentions is retained. Every
+  // name the walk below can reach from the transcript itself is such a
+  // mention, so only the unmentioned candidates depend on the archive graph.
+  let unreferenced = candidates.filter(({ name, filePath }) => {
+    const needles = [normalizeOutputPath(filePath), name];
+    return !needles.some((needle) => {
+      const value = process.platform === 'win32' ? needle.toLowerCase() : needle;
+      return haystack.includes(value);
+    });
+  });
+  if (!unreferenced.length) return;
   // Compact archives may themselves reference older archives or offloaded
-  // results. Keep the reachable graph, not just directly visible files.
+  // results. Keep the reachable graph, not just directly visible files. The
+  // walk ends as soon as every candidate is known reachable: from there it
+  // could only either finish or abort, and neither deletes anything.
   const reachable = new Set(haystack.match(/\b[a-f0-9]{64}\.txt\b/g) || []);
+  const retainReachable = () => {
+    unreferenced = unreferenced.filter(({ name }) => !reachable.has(name));
+    return unreferenced.length > 0;
+  };
+  if (!retainReachable()) return;
   const pending = [...reachable];
   for (let i = 0; i < pending.length; i += 1) {
     let text;
@@ -499,28 +510,21 @@ export async function pruneOffloadSession(sessionId, getMessages) {
     } catch {
       return;
     } // An unreadable root must not destroy recovery evidence.
+    let grew = false;
     for (const name of text.match(/\b[a-f0-9]{64}\.txt\b/g) || []) {
       if (reachable.has(name)) continue;
       reachable.add(name);
       pending.push(name);
+      grew = true;
     }
+    if (grew && !retainReachable()) return;
   }
   await Promise.all(
-    candidates
-      .filter(({ name, filePath }) => {
-        if (reachable.has(name)) return false;
-        const normalizedPath = normalizeOutputPath(filePath);
-        const needles = [normalizedPath, name];
-        return !needles.some((needle) => {
-          const value = process.platform === 'win32' ? needle.toLowerCase() : needle;
-          return haystack.includes(value);
-        });
+    unreferenced.map(({ filePath }) =>
+      unlink(filePath).catch(() => {
+        /* best-effort */
       })
-      .map(({ filePath }) =>
-        unlink(filePath).catch(() => {
-          /* best-effort */
-        })
-      )
+    )
   );
 }
 
@@ -546,7 +550,7 @@ export const _internals = {
   TOOL_RESULT_MESSAGE_MAX_CHARS,
   TOOL_RESULT_MIN_PART_OFFLOAD_CHARS,
   buildPreview,
-  countLines,
+  countLines: countSplitLines,
   inlineTextLength,
   offloadableTextLength,
 };

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -304,12 +304,6 @@ export function resolveAgentStallThresholds(agent, env = process.env) {
   return { warn, abort, firstByteAbort };
 }
 
-export function resolveAgentToolThresholdSeconds(agent, thresholdSeconds) {
-  const cfg = agent ? getHiddenAgent(agent) : null;
-  if (cfg?.stallCap?.toolRunningSeconds > 0) return cfg.stallCap.toolRunningSeconds;
-  return thresholdSeconds;
-}
-
 export function providerTimeoutError(label, timeoutMs) {
   const err = new Error(`${label} timed out after ${timeoutMs}ms`);
   err.name = 'ProviderTimeoutError';
@@ -329,14 +323,18 @@ export function createTimeoutSignal(parentSignal, timeoutMs, label) {
     if (parentListener && parentSignal) {
       try {
         parentSignal.removeEventListener('abort', parentListener);
-      } catch {}
+      } catch {
+        /* already detached */
+      }
       parentListener = null;
     }
   };
   const abort = (reason) => {
     try {
       ac.abort(reason);
-    } catch {}
+    } catch {
+      /* abort is best-effort */
+    }
   };
   if (parentSignal) {
     parentListener = () => abort(parentSignal.reason);
@@ -365,13 +363,17 @@ export function createPassthroughSignal(parentSignal) {
   let parentListener = () => {
     try {
       ac.abort(parentSignal.reason);
-    } catch {}
+    } catch {
+      /* abort is best-effort */
+    }
   };
   const cleanup = () => {
     if (parentListener && parentSignal) {
       try {
         parentSignal.removeEventListener('abort', parentListener);
-      } catch {}
+      } catch {
+        /* already detached */
+      }
       parentListener = null;
     }
   };

package/src/runtime/agent/orchestrator/tools/builtin/advisory-lock.mjs

@@ -5,6 +5,7 @@
 // in this Node, advisory lock serialises across Node processes.
 import { openSync, closeSync, writeSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
 import { compareCodePoints } from '../../../../shared/code-point-order.mjs';
+import { sleep } from '../../../../shared/sleep.mjs';
 import { dirname, basename, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 
@@ -35,12 +36,8 @@ function isPidAlive(pid) {
 function readLockInfo(lockFile) {
   try {
     const raw = readFileSync(lockFile, 'utf-8').trim();
-    // Token format: `${pid}.${hex}`. Fall back to legacy bare-pid contents.
-    const dot = raw.indexOf('.');
-    if (dot > 0) {
-      const pid = parseInt(raw.slice(0, dot), 10);
-      return { pid: Number.isInteger(pid) ? pid : 0, token: raw };
-    }
+    // Token format: `${pid}.${hex}`, or legacy bare-pid contents. parseInt
+    // stops at the dot, so both read the leading pid.
     const pid = parseInt(raw, 10);
     return { pid: Number.isInteger(pid) ? pid : 0, token: raw };
   } catch {
@@ -130,7 +127,7 @@ async function acquireAdvisoryLock(targetPath, { timeoutMs = 5000, pollMs = 25 }
       // sleep also absorbs the OS-level race window where the
       // original kill(0) returned ESRCH before the holder fully
       // exited the spawn/registration window.
-      await new Promise((r) => setTimeout(r, 50));
+      await sleep(50);
       const second = readLockInfo(lockFile);
       if (second.pid !== holderPid || second.token !== holderToken) {
         // Another contender already touched the lock; resync — but the
@@ -145,7 +142,7 @@ async function acquireAdvisoryLock(targetPath, { timeoutMs = 5000, pollMs = 25 }
         unlinkIfOwned(lockFile, holderToken);
         // Small jitter to avoid avalanche of contenders racing into
         // tryCreateLock simultaneously after the unlink.
-        await new Promise((r) => setTimeout(r, Math.floor(Math.random() * 5) + 1));
+        await sleep(Math.floor(Math.random() * 5) + 1);
         // The stale lock is gone: retry the create. Past the deadline
         // exactly ONE such attempt is granted — a lock repeatedly taken
         // and abandoned by dying holders would otherwise livelock here
@@ -160,11 +157,11 @@ async function acquireAdvisoryLock(targetPath, { timeoutMs = 5000, pollMs = 25 }
       // Second probe says the holder is alive after all — fall through to
       // the live-holder wait so the same deadline applies.
       if (Date.now() >= deadline) throw timeoutError(holderPid);
-      await new Promise((r) => setTimeout(r, pollMs));
+      await sleep(pollMs);
       continue;
     }
     if (Date.now() >= deadline) throw timeoutError(holderPid);
-    await new Promise((r) => setTimeout(r, pollMs));
+    await sleep(pollMs);
   }
 }