mixdog 1.2.4 → 1.2.6

package/src/runtime/shared/notify-trace.mjs

@@ -1,4 +1,6 @@
-// Lightweight always-on completion-notification trace. The display path for
+// Opt-in (MIXDOG_NOTIFY_TRACE=1) completion-notification trace: off by
+// default, so a normal install writes no line per delivery decision (it kept
+// a multi-MB log growing in every data dir). The display path for
 // background completions is event-time only and has repeatedly failed silently
 // in the field (2026-08-17: bench shell output never rendered while the model
 // queue twin worked every time). One append-only line per decision point keeps
@@ -36,7 +38,12 @@ function tracePath() {
   return join(traceDir, 'notify-trace.log');
 }
 
+function notifyTraceEnabled() {
+  return process.env.MIXDOG_NOTIFY_TRACE === '1';
+}
+
 export function notifyTrace(stage, fields = {}) {
+  if (!notifyTraceEnabled()) return;
   try {
     const parts = [`[${new Date().toISOString()}]`, `pid=${process.pid}`, stage];
     for (const [key, value] of Object.entries(fields)) {

package/src/runtime/shared/pristine-execution-contract.json

@@ -88,6 +88,11 @@
       "credentialFile": "antigravity-oauth.json",
       "credentialPathEnv": "ANTIGRAVITY_OAUTH_CREDENTIALS_PATH",
       "modelCatalogFile": "antigravity-oauth-models.json"
+    },
+    "opencode-go-oauth": {
+      "credentialFile": "opencode-go-oauth.json",
+      "credentialPathEnv": "OPENCODE_GO_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "opencode-go-oauth-models.json"
     }
   },
   "apiKeyProviders": {
@@ -96,7 +101,6 @@
     "gemini": "GEMINI_API_KEY",
     "deepseek": "DEEPSEEK_API_KEY",
     "xai": "XAI_API_KEY",
-    "opencode-go": "OPENCODE_API_KEY",
     "openrouter": "OPENROUTER_API_KEY"
   },
   "personalStateCounters": [

package/src/runtime/shared/process-runner-worker.mjs

@@ -0,0 +1,7 @@
+// Worker-thread body for process-runner.mjs: helper children (process-table
+// enumeration, tree kills) are spawned on this thread, never on the host
+// event loop (run-child.mjs).
+import { runChild } from './run-child.mjs';
+import { serveWorkerRequests } from './worker-requests.mjs';
+
+serveWorkerRequests(runChild);

package/src/runtime/shared/process-runner.mjs

@@ -0,0 +1,38 @@
+// Run short helper processes from one shared worker thread, so their
+// synchronous native process creation never stalls the host event loop. A
+// daemon profile under heavy agent load measured single PowerShell spawns
+// blocking the daemon's loop for up to 7 s each. Separate from the git
+// runner's worker: a slow helper start never queues a git child behind it.
+import { SHARE_ENV } from 'node:worker_threads';
+import { runChild } from './run-child.mjs';
+import { createWorkerRequestClient } from './worker-requests.mjs';
+
+// Created on first use. A bundled copy of this module (the desktop service's
+// CommonJS bundle) has no module URL and no worker file beside it: there the
+// child is started on the calling thread, exactly as before.
+let requestProcess = null;
+function processClient() {
+  if (requestProcess !== null) return requestProcess;
+  try {
+    // SHARE_ENV: children inherit the live process environment, exactly as a
+    // spawn from this thread would.
+    requestProcess = createWorkerRequestClient(new URL('./process-runner-worker.mjs', import.meta.url), {
+      env: SHARE_ENV,
+    });
+  } catch {
+    requestProcess = false;
+  }
+  return requestProcess;
+}
+
+/**
+ * Resolves to { code, stdout, stderr } (a non-zero exit is the caller's to
+ * judge). Rejects with code ETIMEDOUT after timeoutMs (the child is killed;
+ * 0 sets no deadline),
+ * EMAXBUFFER once stdout+stderr exceed maxBytes, or the spawn error itself.
+ */
+export function runProcessOffThread(command, args, { cwd, input = '', env = null, timeoutMs, maxBytes }) {
+  const request = processClient();
+  const payload = { command, args, cwd, input, env, timeoutMs, maxBytes };
+  return request ? request(payload) : runChild(payload);
+}

package/src/runtime/shared/provider-accounts.mjs

@@ -13,6 +13,7 @@ export const ACCOUNT_PROVIDERS = Object.freeze([
   'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
+  'opencode-go-oauth',
 ]);
 const MAX_ACCOUNTS = 20;
 // `dataDir` defaults to this process's data dir; an isolated runtime passes
@@ -79,7 +80,7 @@ function normalizeLabels(pool) {
 // only; `limit` keeps the selected account until it reaches a limit and then
 // moves to the account with the most headroom; `headroom` starts every new
 // session on the account with the most headroom and keeps it for that session.
-export const ACCOUNT_POLICIES = Object.freeze(['manual', 'limit', 'headroom']);
+const ACCOUNT_POLICIES = Object.freeze(['manual', 'limit', 'headroom']);
 
 // `auto` predates `policy` and is still written beside it, so a build that
 // knows only `auto` reads the same switching on/off. Whenever the two

package/src/runtime/shared/provider-api-key.mjs

@@ -13,7 +13,6 @@ export const AGENT_PROVIDER_ENV = Object.freeze({
   gemini: 'GEMINI_API_KEY',
   deepseek: 'DEEPSEEK_API_KEY',
   xai: 'XAI_API_KEY',
-  'opencode-go': 'OPENCODE_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
 });
 

package/src/runtime/shared/read-row-numbers.mjs

@@ -88,7 +88,7 @@ export function readSourceWindow(text) {
       rows.push({ number, content: row[2] });
       continue;
     }
-    const metadata = /^\[lines (\d+)-(\d+) of (\d+)(?:; pass offset:\d+ to continue)?\]$/.exec(line);
+    const metadata = /^\[lines (\d+)-(\d+) of (\d+)(?:; offset:\d+ for more)?\]$/.exec(line);
     if (!metadata || footer) return null;
     footer = metadata;
     totalLines = Number(metadata[3]);

package/src/runtime/shared/resource-admission.mjs

@@ -1,4 +1,4 @@
-import { freemem, totalmem } from 'node:os';
+import { availableParallelism, freemem, totalmem } from 'node:os';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { requestMemoryPressureSnapshot } from './memory-snapshot.mjs';
 import { nonNegativeInt, positiveInt } from './numbers.mjs';
@@ -6,12 +6,20 @@ import { nonNegativeInt, positiveInt } from './numbers.mjs';
 const MB = 1024 * 1024;
 
 // The unified daemon queues bursts instead of starting an unbounded number of
-// agent/provider/shell tasks in one process. Environment overrides remain
-// available for larger hosts; memory thresholds are diagnostic only.
+// agent/provider tasks in one process. Shell commands start immediately: their
+// only bound is maxShells (64) live foreground commands, a runaway guard
+// rather than a CPU budget; the OS shares the cores. Environment overrides remain available; memory thresholds
+// are diagnostic only.
+// Agent leases are held only while an agent runs tools (they yield during
+// provider I/O) and their tool work is mostly child-process I/O, so two per
+// core keeps the host busy: 30-agent stress on 20 cores halved wall time at
+// 40 versus 8 with no event-loop or memory cost. 8 is the floor for small
+// hosts. maxHighLoad now bounds agents only and defaults to the same.
+const AGENT_LIMIT = Math.max(8, 2 * availableParallelism());
 const RESOURCE_ADMISSION_DEFAULTS = Object.freeze({
-  maxAgents: 8,
-  maxShells: 8,
-  maxHighLoad: 12,
+  maxAgents: AGENT_LIMIT,
+  maxShells: 64,
+  maxHighLoad: AGENT_LIMIT,
   maxQueue: 1024,
   minFreeMemoryMb: 0,
   maxRssMb: 0,
@@ -79,12 +87,15 @@ class ResourceAdmissionQueueFullError extends ResourcePressureError {
  * shells. Running work is never revoked: pressure only rejects a new request or
  * keeps a concurrency-blocked request in the bounded FIFO queue.
  *
- * A shell lease covers only the foreground part of a command: promotion to a
- * background job releases it (lib/shell-run-background/promote-job.mjs), so
- * background jobs count toward neither maxShells nor the maxHighLoad budget
- * shared with agents, and are not capped at all: they are mostly idle
- * servers/watchers at below-normal OS priority whose memory lives in their own
- * processes. Session/runtime close stops them (shell-jobs shutdownShellJobs).
+ * Shell leases are their own pool of maxShells: they are not part of the
+ * maxHighLoad budget, do not suspend the calling agent's lease, and never wait
+ * behind queued agent work, so a command starts at once unless maxShells
+ * commands are already running. A shell lease covers only the foreground part
+ * of a command: promotion to a background job releases it
+ * (lib/shell-run-background/promote-job.mjs), so background jobs are not
+ * capped at all: they are mostly idle servers/watchers at below-normal OS
+ * priority whose memory lives in their own processes. Session/runtime close
+ * stops them (shell-jobs shutdownShellJobs).
  */
 export class ResourceAdmissionController {
   constructor({ limits = {}, metrics = defaultMetrics, now = Date.now, env = process.env } = {}) {
@@ -98,6 +109,20 @@ export class ResourceAdmissionController {
     // Live leases for saturation diagnostics only (labels/ages in snapshot()).
     this.activeLeases = new Set();
     this.context = new AsyncLocalStorage();
+    // Admission waits by pool: first acquisition (agent/shell) and the
+    // reacquisition after a yielded provider call (restore). Shows whether
+    // the agent cap actually delays work.
+    this.waitStats = {};
+  }
+
+  _recordWait(pool, waitedMs) {
+    this.waitStats[pool] ??= { admitted: 0, waited: 0, totalWaitMs: 0, maxWaitMs: 0 };
+    const stats = this.waitStats[pool];
+    stats.admitted += 1;
+    if (waitedMs <= 0) return;
+    stats.waited += 1;
+    stats.totalWaitMs += waitedMs;
+    stats.maxWaitMs = Math.max(stats.maxWaitMs, waitedMs);
   }
 
   _recordMemoryPressure(kind) {
@@ -129,9 +154,14 @@ export class ResourceAdmissionController {
   }
 
   _canStart(kind) {
-    const total = this.active.agent + this.active.shell;
-    const kindLimit = kind === 'shell' ? this.limits.maxShells : this.limits.maxAgents;
-    return total < this.limits.maxHighLoad && this.active[kind] < kindLimit;
+    if (kind === 'shell') return this.active.shell < this.limits.maxShells;
+    return this.active.agent < this.limits.maxHighLoad && this.active.agent < this.limits.maxAgents;
+  }
+
+  // Shell and agent waiters never delay each other's new requests.
+  _queuedInPool(lane) {
+    const shell = lane === 'shell';
+    return this.queue.some((item) => (item.kind === 'shell') === shell);
   }
 
   _adjustOwnerCount(kind, ownerKey, delta) {
@@ -240,6 +270,7 @@ export class ResourceAdmissionController {
       },
     };
     this.activeLeases.add(lease);
+    this._recordWait(kind, lease.queuedMs);
     return lease;
   }
 
@@ -294,8 +325,9 @@ export class ResourceAdmissionController {
     this._recordMemoryPressure(lane);
     const ambientParent = this.context.getStore();
     const detachedDependency = dependency === 'detached' && ambientParent?.controller === this;
-    const parent = detachedDependency ? null : this._suspendParent(ambientParent);
-    if (detachedDependency && (!this._canStart(lane) || this.queue.length > 0)) {
+    // A shell runs beside its agent instead of taking the agent's slot.
+    const parent = detachedDependency || lane === 'shell' ? null : this._suspendParent(ambientParent);
+    if (detachedDependency && (!this._canStart(lane) || this._queuedInPool(lane))) {
       const error = new ResourcePressureError(
         `detached nested ${lane} work has no admission capacity; retry after running work completes`,
         { kind: lane }
@@ -303,7 +335,7 @@ export class ResourceAdmissionController {
       error.code = 'ERESOURCEDEPENDENCY';
       return Promise.reject(error);
     }
-    if (this._canStart(lane) && this.queue.length === 0) {
+    if (this._canStart(lane) && !this._queuedInPool(lane)) {
       const lease = this._lease(lane, null, parent, owner, taskPriority);
       lease.label = label;
       lease.signal = signal;
@@ -439,6 +471,7 @@ export class ResourceAdmissionController {
       if (item.restore) {
         item.parent.restorePending = null;
         item.parent.counted = true;
+        this._recordWait(`${item.kind}Restore`, Math.max(0, this.now() - item.queuedAt));
         this.active[item.kind] += 1;
         this._adjustOwnerCount(item.kind, item.ownerKey, 1);
         item.resolve();
@@ -461,6 +494,15 @@ export class ResourceAdmissionController {
         shell: this.activeByOwner.shell.size,
       },
       queued: this.queue.length,
+      waitStats: Object.fromEntries(
+        Object.entries(this.waitStats).map(([pool, stats]) => [
+          pool,
+          {
+            ...stats,
+            averageQueuedMs: stats.waited > 0 ? Math.round(stats.totalWaitMs / stats.waited) : 0,
+          },
+        ])
+      ),
       limits: {
         ...this.limits,
         maxAgents: wireLimit(this.limits.maxAgents),

package/src/runtime/shared/run-child.mjs

@@ -0,0 +1,84 @@
+// One child process run to completion, its output collected — the body of
+// the off-thread runners (git-runner-worker.mjs, process-runner-worker.mjs).
+// Starting a child process is a synchronous native call (CreateProcess on
+// Windows, amplified by on-access scanning and seconds long under load), so
+// those workers spawn here instead of on the host event loop.
+// Resolves to { code, stdout, stderr }; rejects with code ETIMEDOUT after
+// timeoutMs (the child is killed), EMAXBUFFER once stdout+stderr exceed
+// maxBytes, or the spawn error itself.
+import { spawn } from 'node:child_process';
+
+export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const hasInput = (typeof input === 'string' || ArrayBuffer.isView(input)) && input.length > 0;
+    const child = spawn(command, args, {
+      cwd,
+      ...(env ? { env } : {}),
+      windowsHide: true,
+      stdio: [hasInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+    });
+    const stdout = [];
+    const stderr = [];
+    let outputBytes = 0;
+    let stdinError = null;
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) rejectPromise(error);
+      else resolvePromise(result);
+    };
+    // timeoutMs 0: no deadline (the caller's own work bounds the child).
+    const timer =
+      timeoutMs > 0
+        ? setTimeout(() => {
+            const error = new Error(`${command} ${args.join(' ')} timed out after ${timeoutMs}ms`);
+            error.code = 'ETIMEDOUT';
+            try {
+              child.kill();
+            } catch {}
+            finish(error);
+          }, timeoutMs)
+        : null;
+    const collect = (chunks, chunk) => {
+      const next = Buffer.from(chunk);
+      outputBytes += next.length;
+      if (outputBytes > maxBytes) {
+        const error = new Error(`${command} ${args.join(' ')} exceeded ${maxBytes} output bytes`);
+        error.code = 'EMAXBUFFER';
+        try {
+          child.kill();
+        } catch {}
+        finish(error);
+        return;
+      }
+      chunks.push(next);
+    };
+    child.stdout.on('data', (chunk) => collect(stdout, chunk));
+    child.stderr.on('data', (chunk) => collect(stderr, chunk));
+    child.once('error', (error) => finish(error));
+    child.once('close', (code) => {
+      const result = {
+        code: Number(code ?? 1),
+        // 'base64' keeps non-UTF-8 bytes (a replayable patch) intact across the thread hop.
+        stdout: Buffer.concat(stdout).toString(stdoutEncoding === 'base64' ? 'base64' : 'utf8'),
+        stderr: Buffer.concat(stderr).toString('utf8'),
+      };
+      // A failed stdin write only matters when the child otherwise reported success.
+      if (stdinError && result.code === 0) {
+        finish(stdinError);
+        return;
+      }
+      finish(null, result);
+    });
+    if (child.stdin) {
+      // A short-lived child can close before stdin is flushed. Keep that
+      // transport race inside this promise instead of an unhandled EPIPE.
+      child.stdin.on('error', (error) => {
+        stdinError = error;
+      });
+      child.stdin.end(input);
+    }
+  });
+}

package/src/runtime/shared/session-activity-signal.mjs

@@ -0,0 +1,23 @@
+// session-activity-signal.mjs
+// Process-local "a session's activity state may have changed" pulse: a turn
+// started or settled, a task wait began or ended, a background task was
+// handed off or finished. Status surfaces that project activity from the
+// runtime map (the Agents pool) listen and re-read at once instead of waiting
+// for their next store event. Import-free leaf.
+const listeners = new Set();
+
+export function onSessionActivityChange(listener) {
+  if (typeof listener !== 'function') return () => {};
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function emitSessionActivityChange(sessionId = '') {
+  for (const listener of [...listeners]) {
+    try {
+      listener(String(sessionId || ''));
+    } catch {
+      /* a listener's failure never affects the transition */
+    }
+  }
+}

package/src/runtime/shared/shell-output-summary.mjs

@@ -0,0 +1,23 @@
+// Formatting shared by every surface that hands shell output to an agent.
+// Program output is untrusted text: anything shaped like a harness/system tag
+// is escaped so it can never forge a notice, a result boundary or a reminder.
+// (Capping lives in tools/builtin/lib/shell-delivery.mjs, per-job cursors in
+// tools/builtin/lib/shell-task-output.mjs.)
+
+// A tag-looking token: `<name`, `</name`, where the name is a known
+// harness/system/transcript word or any hyphenated/underscored/namespaced
+// name (task-notification, system-reminder, tool_result, ns:tag ...). Plain
+// HTML-ish words like <div> or a comparison `a<b` stay readable.
+const HARNESS_TAG =
+  /<(\/?)(?=(?:[a-z][\w]*[-_:][\w:-]*|system|result|results|summary|status|error|user|assistant|human|tool|function|functions|instructions|context|notification|reminder|output|invoke|parameter|thinking)\b)/gi;
+
+export function escapeHarnessTags(text) {
+  return String(text ?? '').replace(HARNESS_TAG, '&lt;$1');
+}
+
+export function formatDuration(ms) {
+  if (!(ms >= 0)) return '';
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60_000);
+  return `${minutes}m ${Math.round((ms % 60_000) / 1000)}s`;
+}

package/src/runtime/shared/singleton-owner.mjs

@@ -1,8 +1,23 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { readFile, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { withFileLock, withFileLockSync } from './file-lock.mjs';
 import { readJsonSafe } from './json-file.mjs';
 import { isPidAlive } from './pid-liveness.mjs';
-import { sleepSync } from './sleep.mjs';
+
+// Claim-lock protocol shared by the sync and async paths: `<path>.claim.lock`
+// is a file-lock.mjs lock, published atomically with its holder's pid and
+// token. A holder whose pid is alive is waited out however long it holds the
+// lock — a holder stalled mid-refresh still owns it: reclaiming it on age let
+// a successor claim the record and the stalled refresh then overwrite it. Its
+// lock is reclaimed only once that pid is dead, and only the holder's own
+// acquisition (pid + token) is ever released. A lock naming no holder — the
+// bare directory versions before this one took the lock with — is reclaimed
+// once older than CLAIM_LOCK_STALE_MS, as those versions did.
+const CLAIM_LOCK_TIMEOUT_MS = 500;
+const CLAIM_LOCK_STALE_MS = 5000;
+const CLAIM_LOCK_OPTS = Object.freeze({ timeoutMs: CLAIM_LOCK_TIMEOUT_MS, staleMs: CLAIM_LOCK_STALE_MS });
+const BUSY = Symbol('claim lock busy');
 
 function writeJsonAtomic(path, value) {
   mkdirSync(dirname(path), { recursive: true });
@@ -11,28 +26,82 @@ function writeJsonAtomic(path, value) {
   renameSync(tmp, path);
 }
 
-function acquireClaimLock(path) {
+// Held by another live process or this one's async holder ('busy'). Any other
+// failure (an unwritable data directory) is thrown, as before.
+function claimLockHeld(error) {
+  return error?.code === 'ELOCKCONTENDED' || (error?.code === 'ELOCKTIMEOUT' && error.cause?.code === 'EEXIST');
+}
+
+function legacyLockStale(info) {
+  return info.isDirectory() && Date.now() - info.mtimeMs > CLAIM_LOCK_STALE_MS;
+}
+
+// An older version's stale bare lock directory is removed with rmdir alone,
+// never recursive or forced: between the stat and the removal a contender may
+// have replaced it with a live owner-named lock file. rmdir refuses a file
+// (ENOENT on Windows, ENOTDIR elsewhere) and a non-empty directory
+// (ENOTEMPTY); a missing path (ENOENT) is already gone. Any refusal (EPERM
+// included) leaves the path untouched to the shared acquire loop below, which
+// waits a live holder out and reclaims only a dead one's lock.
+
+// `fn()` under the claim lock, or BUSY. file-lock creates a missing data
+// directory (a first boot, e.g. a daemon an ssh bootstrap starts on a fresh
+// server).
+function withClaimLockSync(path, fn) {
   const lockPath = `${path}.claim.lock`;
-  // A first boot (e.g. a daemon an ssh bootstrap starts on a fresh server)
-  // has no data directory yet: the lock's parent must exist.
-  mkdirSync(dirname(path), { recursive: true });
-  for (let i = 0; i < 20; i++) {
-    try {
-      mkdirSync(lockPath, { recursive: false });
-      return lockPath;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        const ageMs = Date.now() - statSync(lockPath).mtimeMs;
-        if (ageMs > 5000) {
-          rmSync(lockPath, { recursive: true, force: true });
-          continue;
-        }
-      } catch {}
-      sleepSync(25);
-    }
+  try {
+    if (legacyLockStale(statSync(lockPath))) rmdirSync(lockPath);
+  } catch {}
+  let entered = false;
+  try {
+    return withFileLockSync(
+      lockPath,
+      () => {
+        entered = true;
+        return fn();
+      },
+      CLAIM_LOCK_OPTS
+    );
+  } catch (error) {
+    if (!entered && claimLockHeld(error)) return BUSY;
+    throw error;
+  }
+}
+
+// The same lock taken without blocking the event loop: every file operation
+// and every retry wait is awaited (a synchronous refresh once held the
+// daemon's loop for 20 s in one rmSync under disk contention).
+async function withClaimLock(path, fn) {
+  const lockPath = `${path}.claim.lock`;
+  try {
+    if (legacyLockStale(await stat(lockPath))) await rmdir(lockPath);
+  } catch {}
+  let entered = false;
+  try {
+    return await withFileLock(
+      lockPath,
+      () => {
+        entered = true;
+        return fn();
+      },
+      CLAIM_LOCK_OPTS
+    );
+  } catch (error) {
+    if (!entered && claimLockHeld(error)) return BUSY;
+    throw error;
+  }
+}
+
+function namesOtherPid(record, pid) {
+  return Boolean(record?.pid) && Number(record.pid) !== Number(pid);
+}
+
+async function readJsonSafeAsync(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return null;
   }
-  return null;
 }
 
 // A live pid alone does not prove the record's process still owns it: the OS
@@ -64,18 +133,15 @@ export function claimSingletonOwner(path, { kind = 'runtime', pid = process.pid,
     return { owned: false, owner: current };
   }
 
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
-  try {
+  const result = withClaimLockSync(path, () => {
     const lockedCurrent = readJsonSafe(path);
     if (livePeer(lockedCurrent)) {
       return { owned: false, owner: lockedCurrent };
     }
     writeJsonAtomic(path, owner);
     return { owned: true, owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { owned: false, owner: readJsonSafe(path) } : result;
 }
 
 export function releaseSingletonOwner(path, pid = process.pid) {
@@ -94,16 +160,37 @@ export function releaseSingletonOwner(path, pid = process.pid) {
 // naming another pid is reported, never overwritten ('superseded'); a claim
 // lock held past its wait leaves the record alone ('busy').
 export function refreshSingletonOwner(path, owner) {
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { status: 'busy', owner: null };
-  try {
+  const result = withClaimLockSync(path, () => {
     const current = readJsonSafe(path);
-    if (current?.pid && Number(current.pid) !== Number(owner.pid)) return { status: 'superseded', owner: current };
+    if (namesOtherPid(current, owner.pid)) return { status: 'superseded', owner: current };
     writeJsonAtomic(path, owner);
     return { status: 'refreshed', owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { status: 'busy', owner: null } : result;
+}
+
+/** refreshSingletonOwner without blocking the event loop: the same claim
+ *  lock (mutually exclusive with the sync claim/refresh/handoff), the same
+ *  verdicts, every file operation and retry wait awaited. Its awaited write
+ *  may stall, so the record is read again right before it is replaced: a
+ *  record another pid wrote meanwhile is reported, never overwritten. */
+export async function refreshSingletonOwnerAsync(path, owner) {
+  const result = await withClaimLock(path, async () => {
+    const current = await readJsonSafeAsync(path);
+    if (namesOtherPid(current, owner.pid)) return { status: 'superseded', owner: current };
+    let tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await writeFile(tmp, `${JSON.stringify(owner, null, 2)}\n`);
+      const latest = await readJsonSafeAsync(path);
+      if (namesOtherPid(latest, owner.pid)) return { status: 'superseded', owner: latest };
+      await rename(tmp, path);
+      tmp = null;
+      return { status: 'refreshed', owner };
+    } finally {
+      if (tmp) await rm(tmp, { force: true }).catch(() => {});
+    }
+  });
+  return result === BUSY ? { status: 'busy', owner: null } : result;
 }
 
 // Atomic ownership handoff: replace the owner record from fromPid to toOwner
@@ -113,11 +200,9 @@ export function refreshSingletonOwner(path, owner) {
 // (someone else won), the handoff is refused (owned:false) and the caller
 // should fall back to the winner rather than overwrite it.
 export function handoffSingletonOwner(path, fromPid, toOwner = {}) {
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
-  try {
+  const result = withClaimLockSync(path, () => {
     const current = readJsonSafe(path);
-    if (current?.pid && Number(current.pid) !== Number(fromPid)) {
+    if (namesOtherPid(current, fromPid)) {
       return { owned: false, owner: current };
     }
     const owner = {
@@ -127,7 +212,6 @@ export function handoffSingletonOwner(path, fromPid, toOwner = {}) {
     };
     writeJsonAtomic(path, owner);
     return { owned: true, owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { owned: false, owner: readJsonSafe(path) } : result;
 }

package/src/runtime/shared/tool-output-limit.mjs

@@ -3,6 +3,8 @@
 // context cost of any one tool call is bounded and consistent. Override with
 // MIXDOG_TOOL_OUTPUT_MAX_BYTES. Line-based sub-caps (e.g. bash max lines) stay
 // per-tool; this governs only the byte budget.
+import { capMarker } from './tool-output-marker.mjs';
+export { capMarker, formatCapSize, windowMarker } from './tool-output-marker.mjs';
 // A positive integer from an env var, or `fallback` when unset or invalid.
 export function positiveEnvInt(name, fallback) {
   const v = parseInt(process.env[name], 10);
@@ -53,7 +55,7 @@ export function capLineOrientedToolOutput(result, maxBytes, footerForPrefix) {
   while (lo <= hi) {
     const mid = Math.floor((lo + hi) / 2);
     const kept = lines.slice(0, mid);
-    const footer = String(footerForPrefix?.(kept, lines) || '... [output budget reached; remainder omitted]');
+    const footer = String(footerForPrefix?.(kept, lines) || capMarker({ limit: cap }));
     const candidate = `${kept.join('\n')}${kept.length ? '\n' : ''}${footer}`;
     if (Buffer.byteLength(candidate, 'utf8') <= cap) {
       best = candidate;
@@ -63,5 +65,5 @@ export function capLineOrientedToolOutput(result, maxBytes, footerForPrefix) {
     }
   }
   if (best) return best;
-  return _prefixByBytes(String(footerForPrefix?.([], lines) || '... [output budget reached; remainder omitted]'), cap);
+  return _prefixByBytes(String(footerForPrefix?.([], lines) || capMarker({ limit: cap })), cap);
 }