mixdog 1.2.0 → 1.2.2

package/src/runtime/shared/atomic-file.mjs

@@ -21,7 +21,7 @@ import {
 } from 'node:fs/promises';
 import { dirname, basename, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { DEFAULT_BACKOFFS_MS, withFileLock, withFileLockSync } from './file-lock.mjs';
+import { DEFAULT_BACKOFFS_MS, recordLockTiming, withFileLock, withFileLockSync } from './file-lock.mjs';
 import {
   enforceOwnerOnlyAclWin32 as _enforceOwnerOnlyAclWin32,
   enforceOwnerOnlyAclWin32Async as _enforceOwnerOnlyAclWin32Async,
@@ -321,9 +321,30 @@ export async function writeFileAtomicAsync(filePath, data, opts = {}) {
   };
   // Acquire the file lock before occupying an I/O slot. Otherwise a waiter can
   // exhaust the gate while the current lock owner needs it to finish its write.
-  return opts.lock === true
-    ? withFileLock(`${filePath}.lock`, () => _runAdaptiveFileIo(run), opts)
-    : _runAdaptiveFileIo(run);
+  if (opts.lock !== true) return _runAdaptiveFileIo(run);
+  const lockPath = `${filePath}.lock`;
+  return withFileLock(
+    lockPath,
+    async () => {
+      const queuedAt = Date.now();
+      let startedAt = 0;
+      try {
+        return await _runAdaptiveFileIo(() => {
+          startedAt = Date.now();
+          return run();
+        });
+      } finally {
+        const now = Date.now();
+        // Recorded from this (lock-owner) context so the held warning can
+        // split the hold into gate wait vs. the write itself.
+        recordLockTiming(lockPath, {
+          ioGateWaitMs: (startedAt || now) - queuedAt,
+          writeMs: startedAt ? now - startedAt : 0,
+        });
+      }
+    },
+    opts
+  );
 }
 
 export function writeJsonAtomicAsync(filePath, value, opts = {}) {

package/src/runtime/shared/background-tasks.mjs

@@ -18,6 +18,10 @@ export { TOOL_ASYNC_EXECUTION_CONTRACT, TOOL_MANUAL_CONTROL_CONTRACT, TOOL_SYNC_
 const TASK_TTL_MS = 30 * 60_000;
 const MAX_TASKS = 300;
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+// A `notifyOnCancel` task reports its cancellation to the owner once, after its
+// run settles, so the notification can carry what the run produced before it
+// stopped. A run that never settles still reports, header-only, after this grace.
+const CANCEL_NOTIFY_GRACE_MS = 10_000;
 const tasks = new Map();
 let seq = 0;
 
@@ -151,6 +155,7 @@ export function registerBackgroundTask({
   resultType,
   renderResult,
   cancel,
+  notifyOnCancel = false,
 } = {}) {
   pruneTasks();
   const explicitId = clean(taskId);
@@ -189,6 +194,7 @@ export function registerBackgroundTask({
     resultType: clean(resultType) || null,
     renderResult: typeof renderResult === 'function' ? renderResult : null,
     cancel: typeof cancel === 'function' ? cancel : null,
+    notifyOnCancel: notifyOnCancel === true,
   };
   tasks.set(id, task);
   return task;
@@ -200,10 +206,14 @@ export function startBackgroundTask(options = {}) {
     .then(() => options.run?.())
     .then((result) => {
       completeBackgroundTask(task.taskId, { status: 'completed', result, terminalReason: 'run-resolved' });
+      deliverCancelledNotification(task);
       return result;
     })
     .catch((error) => {
-      if (task.status === 'cancelled') return null;
+      if (task.status === 'cancelled') {
+        deliverCancelledNotification(task);
+        return null;
+      }
       completeBackgroundTask(task.taskId, {
         status: 'failed',
         error,
@@ -258,15 +268,62 @@ export function cleanupBackgroundTasks(options = {}) {
   return { removed: before - after, tasks: after };
 }
 
-export function cancelBackgroundTask(taskId, reason = 'cancelled') {
+// `notify`: true notifies immediately, false never notifies (owner teardown).
+// Left unset, a `notifyOnCancel` task defers its single `cancelled`
+// notification until its run settles (see settleCancelledBackgroundTask); any
+// other task stays silent.
+function cancelRunningTask(task, reason, notify) {
+  try {
+    task.cancel?.();
+  } catch {}
+  completeBackgroundTask(task.taskId, { status: 'cancelled', error: reason, notify: notify === true });
+  if (task.notifyOnCancel !== true || notify === true || task.status !== 'cancelled' || task.cancelNotify) return;
+  if (notify === false) {
+    task.cancelNotify = 'silent';
+    return;
+  }
+  task.cancelNotify = 'pending';
+  task.cancelNotifyTimer = setTimeout(() => deliverCancelledNotification(task), CANCEL_NOTIFY_GRACE_MS);
+  task.cancelNotifyTimer.unref?.();
+}
+
+// Owner teardown/delete (`notify: false`) also silences a cancellation that is
+// still waiting for its run to settle.
+function resolvePendingCancelNotify(task, next) {
+  if (task.cancelNotify !== 'pending') return false;
+  clearTimeout(task.cancelNotifyTimer);
+  task.cancelNotifyTimer = null;
+  task.cancelNotify = next;
+  return true;
+}
+
+function silenceCancelledNotification(task) {
+  resolvePendingCancelNotify(task, 'silent');
+}
+
+function deliverCancelledNotification(task) {
+  if (!resolvePendingCancelNotify(task, 'delivered')) return false;
+  if (tasks.get(task.taskId) !== task) return false;
+  task.meta = sanitizeTaskMeta(task.meta);
+  return notifyTaskCompletion(task, task.notificationInstruction);
+}
+
+export function cancelBackgroundTask(taskId, reason = 'cancelled', { notify } = {}) {
   const task = getBackgroundTask(taskId);
   if (!task) return null;
-  if (!TERMINAL_STATUSES.has(task.status)) {
-    try {
-      task.cancel?.();
-    } catch {}
-    completeBackgroundTask(task.taskId, { status: 'cancelled', error: reason, notify: false });
-  }
+  if (!TERMINAL_STATUSES.has(task.status)) cancelRunningTask(task, reason, notify);
+  else if (notify === false) silenceCancelledNotification(task);
+  return task;
+}
+
+/** The cancelled run has stopped: attach what it produced before stopping (if
+ *  any) and deliver the task's single deferred `cancelled` notification. A
+ *  no-op unless that notification is still pending. */
+export function settleCancelledBackgroundTask(taskId, { result } = {}) {
+  const task = getBackgroundTask(taskId);
+  if (task?.status !== 'cancelled' || task.cancelNotify !== 'pending') return null;
+  if (result !== undefined) task.result = result;
+  deliverCancelledNotification(task);
   return task;
 }
 
@@ -280,11 +337,11 @@ export function cancelBackgroundTasks(options = {}) {
     // visible/recoverable, but may not be claimed by whichever session happens
     // to close first.
     if (!taskMatchesScope(task, options, { includeUnattributed: false })) continue;
-    if (TERMINAL_STATUSES.has(task.status)) continue;
-    try {
-      task.cancel?.();
-    } catch {}
-    completeBackgroundTask(task.taskId, { status: 'cancelled', error: reason, notify: options.notify === true });
+    if (TERMINAL_STATUSES.has(task.status)) {
+      if (options.notify === false) silenceCancelledNotification(task);
+      continue;
+    }
+    cancelRunningTask(task, reason, options.notify);
     cancelled += 1;
   }
   return { cancelled };
@@ -358,10 +415,26 @@ export function completeBackgroundTask(
   return task;
 }
 
+// Surfaces whose later reads consume the structured result object itself:
+// shell `task read` re-reads output via result paths and renders exit_code /
+// timed_out / signal; agent job views return `job.result`. They keep it for the
+// TTL; every other surface keeps only resultText + metadata once delivered.
+const RESULT_KEPT_SURFACES = new Set(['shell', 'agent']);
+
+function releaseDeliveredResult(task, body) {
+  if (task.result === undefined || RESULT_KEPT_SURFACES.has(task.surface)) return;
+  // Pin the rendered body first so re-renders and retries stay identical.
+  if (!task.resultText) task.resultText = body;
+  task.result = undefined;
+}
+
 export function notifyTaskCompletion(task, instruction) {
   if (!task) return false;
   if (!TERMINAL_STATUSES.has(task.status)) return false;
   if (task.completionAcknowledged === true) return false;
+  // A deferred cancellation is delivered only by deliverCancelledNotification;
+  // a silent (owner-teardown) cancellation never notifies.
+  if (task.cancelNotify === 'pending' || task.cancelNotify === 'silent') return false;
   // `notified` tracks whether *any* completion notification was sent (e.g. an
   // early header-only preview from the agent surface). A later call that can
   // finally include the result body must still fire once, otherwise the owner
@@ -396,7 +469,10 @@ export function notifyTaskCompletion(task, instruction) {
   });
   if (sent) {
     task.notified = true;
-    if (hasBody) task.notifiedWithBody = true;
+    if (hasBody) {
+      task.notifiedWithBody = true;
+      releaseDeliveredResult(task, body);
+    }
   }
   return sent;
 }
@@ -457,6 +533,8 @@ export function renderBackgroundTaskNotification(task) {
     status: task.status,
     result,
     error: task.error,
+    // A cancelled Agent's header names the cancel reason.
+    detail: task.surface === 'agent' && task.status === 'cancelled' ? task.error : null,
   });
 }
 

package/src/runtime/shared/err-text.mjs

@@ -180,9 +180,34 @@ export function isCancelLikeError(error) {
   );
 }
 
+// One-line reason per provider kind. Fixed sentences (optionally with a
+// parenthesised value) are the renderer's translation keys.
+const KIND_LINES = {
+  overloaded: 'Provider is busy at capacity.',
+  rate_limited: ({ retryAfterMs }) =>
+    retryAfterMs ? `Provider is rate-limited (retry in ${formatDurationMs(retryAfterMs)}).` : 'Provider is rate-limited.',
+  quota_exhausted: 'Provider usage limit reached.',
+  entitlement: 'Not included in your plan.',
+  billing: 'Out of credits or at spend limit.',
+  permission: 'Access denied by the provider.',
+  policy: 'Refused by the provider safety policy.',
+  auth: 'Provider authentication failed.',
+};
+
+// Typed evidence: a persisted descriptor or structured status/code fields.
+// A bare message carries none, so its wording keeps the legacy text path.
+function hasTypedEvidence(error) {
+  if (!error || typeof error !== 'object') return false;
+  return Boolean(error.errorKind?.kind) || errorHttpStatus(error) > 0 || Boolean(error.code) || Boolean(error.retryAfterMs);
+}
+
 export function presentErrorText(error, options = {}) {
   const presentation = describeError(error);
   if (['image-size', 'payload-size', 'request'].includes(presentation.kind)) return presentation.summary;
+  const kindLine = hasTypedEvidence(error) ? KIND_LINES[presentation.providerKind] : null;
+  if (kindLine && presentation.kind !== 'unknown') {
+    return typeof kindLine === 'function' ? kindLine(presentation) : kindLine;
+  }
   const surface = options.surface || options.tool || '';
   const subject = subjectForSurface(surface);
   const max = options.max ?? 240;

package/src/runtime/shared/error-presentation.mjs

@@ -1,3 +1,4 @@
+import { PROVIDER_ERROR_KINDS, providerErrorKind } from '../agent/orchestrator/providers/provider-error-kind.mjs';
 import { transportErrorText } from './transport-error-text.mjs';
 
 const DETAILS_LIMIT = 12_000;
@@ -72,34 +73,167 @@ export function isRejected429(value) {
   return /\bAPI 429 request rejected\b/.test(messageOf(value));
 }
 
+// Provider kind → presentation. Summaries are also the persisted form of a
+// failure, so each maps back to its kind when only the text survives.
+const KIND_COPY = {
+  overloaded: ['overloaded', 'The provider is busy right now.', 'Try again later or choose another model.'],
+  rate_limited: ['rate-limit', 'The provider is temporarily rate-limiting requests.', 'Try again shortly.'],
+  quota_exhausted: [
+    'quota',
+    'The provider usage limit was reached.',
+    'Wait for the limit to reset or choose another account.',
+  ],
+  entitlement: [
+    'entitlement',
+    "This model isn't included in your plan.",
+    'Upgrade your plan, or choose another model or provider.',
+  ],
+  billing: [
+    'billing',
+    'The provider account is out of credits or at its spend limit.',
+    'Check your billing with the provider, then try again.',
+  ],
+  permission: [
+    'permission',
+    "You don't have access to this resource.",
+    'Check your account permissions, or choose another model.',
+  ],
+  context_overflow: [
+    'context-overflow',
+    'The conversation is too long for this model.',
+    'Compact the conversation or start a new one.',
+  ],
+  request_too_large: [
+    'payload-size',
+    'The request exceeds the size limit.',
+    'Reduce the attachments or request size, then try again.',
+  ],
+  policy: [
+    'policy',
+    'The provider refused this request under its safety policy.',
+    'Rephrase the request or choose another model.',
+  ],
+  service_tier_unavailable: [
+    'service-tier',
+    'The requested service tier is unavailable right now.',
+    'Switch to the standard tier or try again later.',
+  ],
+};
+const SUMMARY_KINDS = new Map(Object.entries(KIND_COPY).map(([providerKind, [, summary]]) => [summary, providerKind]));
+
+function waitLabel(ms) {
+  const seconds = Math.max(1, Math.ceil(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.ceil(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return minutes % 60 ? `${hours}h ${minutes % 60}m` : `${hours}h`;
+}
+
+/** Local HH:mm, prefixed with month/day when the reset is not today. */
+function resetLabel(resetAt) {
+  const reset = new Date(resetAt);
+  const pad = (n) => String(n).padStart(2, '0');
+  const time = `${pad(reset.getHours())}:${pad(reset.getMinutes())}`;
+  return reset.toDateString() === new Date().toDateString() ? time : `${reset.getMonth() + 1}/${reset.getDate()} ${time}`;
+}
+
+// Only legacy items (no persisted descriptor) and untyped strings reach this.
+const LEGACY_TEXT_KINDS = [
+  [/The provider usage limit was reached|quota.*(?:hit|exceed)|usage limit/i, 'quota_exhausted'],
+  [/rate[_ -]?limit|too many requests/i, 'rate_limited'],
+];
+
+/**
+ * The provider kind descriptor: the persisted one, else typed evidence, else
+ * wording. `typed` is true when the kind came from a persisted descriptor or a
+ * typed error: wording heuristics must then never override it.
+ */
+function classify(value, raw, clean, status, code) {
+  const persisted = value?.errorKind;
+  if (persisted && PROVIDER_ERROR_KINDS.includes(persisted.kind)) {
+    return { descriptor: persisted, typed: persisted.kind !== 'unknown' };
+  }
+  const hasTypedFields =
+    value &&
+    typeof value === 'object' &&
+    Boolean(value.status || value.httpStatus || value.response?.status || value.code || value.retryAfterMs);
+  if (!hasTypedFields) {
+    // Legacy persisted strings: their wording (and wait) is the only evidence.
+    const legacy = SUMMARY_KINDS.get(clean) ?? LEGACY_TEXT_KINDS.find(([re]) => re.test(clean))?.[1];
+    if (legacy) {
+      const wait = /retryAfter=(\d+)(ms|s|m)\b/i.exec(raw);
+      const retryAfterMs = wait ? Number(wait[1]) * { ms: 1, s: 1000, m: 60_000 }[wait[2].toLowerCase()] : undefined;
+      return { descriptor: { kind: legacy, ...(retryAfterMs ? { retryAfterMs } : {}) }, typed: false };
+    }
+  }
+  let descriptor = value && typeof value === 'object' ? providerErrorKind(value) : null;
+  const typed = Boolean(descriptor) && descriptor.kind !== 'unknown';
+  if (!descriptor || descriptor.kind === 'unknown') {
+    descriptor = providerErrorKind(
+      Object.assign(new Error(raw), { ...(status ? { status } : {}), ...(code ? { code } : {}) })
+    );
+  }
+  if (descriptor.kind === 'unknown') {
+    const known = SUMMARY_KINDS.get(clean);
+    const legacy = known ?? LEGACY_TEXT_KINDS.find(([re]) => re.test(clean))?.[1];
+    if (legacy) return { descriptor: { ...descriptor, kind: legacy }, typed: false };
+  }
+  return { descriptor, typed };
+}
+
 /** Presentation only: never changes retry policy or the underlying failure. */
 export function describeError(value) {
-  const { raw, message, status, code } = unwrap(value);
-  const rejected429 = isRejected429(value);
+  const { raw, message, status: textStatus, code: textCode } = unwrap(value);
   const details = safeErrorDetails(raw);
   const clean = safeErrorDetails(message)
     .replace(/^(?:Error invoking remote method ['"][^'"]+['"]:\s*)?(?:Error:\s*)?/i, '')
     .trim();
+  const { descriptor, typed } = classify(value, raw, clean, textStatus, textCode);
+  // A typed or persisted kind owns the verdict: its own status and code stand
+  // in for the text-derived ones, and wording below may only refine it.
+  const status = typed ? Number(descriptor.status) || 0 : textStatus;
+  const code = typed ? String(descriptor.code || '') : textCode;
+  // A 429 refusal without quota headers refines a rate limit, nothing else.
+  const rejected429 = isRejected429(value) && (!typed || descriptor.kind === 'rate_limited');
+  const copy = KIND_COPY[descriptor.kind];
+  const retryAfterMs = Number(descriptor.retryAfterMs) > 0 ? Number(descriptor.retryAfterMs) : null;
+  const resetAt = Number(descriptor.resetAt) > 0 ? Number(descriptor.resetAt) : null;
   let kind = 'unknown';
   let summary = '';
   let recovery = '';
-  const transport = transportErrorText(value) || transportErrorText(raw);
+  // Localization hook: a recovery that carries a value is given as a template.
+  let recoveryTemplate = '';
+  let params = null;
+  // A persisted descriptor keeps the status and errno code, not the cause
+  // chain: rebuild the transport evidence from them. Wording only reads for
+  // untyped failures and transient ones (a bare "fetch failed" is that evidence).
+  const transport =
+    transportErrorText(value) ||
+    (typed && transportErrorText({ code: code.toUpperCase(), status })) ||
+    (!typed || descriptor.kind === 'transient' ? transportErrorText(raw) : null);
   if (
     value?.reauthRequired === true ||
-    /invalid_grant|refresh token (?:expired|revoked|not available)|sign in again|sign-in expired|Reauth Required/i.test(raw)
+    (!typed &&
+      /invalid_grant|refresh token (?:expired|revoked|not available)|sign in again|sign-in expired|Reauth Required/i.test(raw))
   ) {
     kind = 'reauth';
     summary = 'Sign-in expired.';
     recovery = 'Sign in again from Providers.';
   } else if (
-    status === 401 ||
-    status === 403 ||
-    /\b(?:invalid|expired)\s+(?:api[ _-]?key|access token|credentials?)\b|Provider authentication failed/i.test(clean)
+    descriptor.kind === 'auth' ||
+    (descriptor.kind === 'unknown' &&
+      /\b(?:invalid|expired)\s+(?:api[ _-]?key|access token|credentials?)\b|Provider authentication failed/i.test(clean))
   ) {
     kind = 'authentication';
     summary = 'Provider authentication failed';
     recovery = 'Check your sign-in or API key, then try again.';
+  } else if (rejected429) {
+    kind = 'request';
+    summary = 'The provider rejected this request.';
+    recovery = 'Review the request details before trying again.';
   } else if (
+    ['invalid_request', 'unknown', 'request_too_large'].includes(descriptor.kind) &&
     /image.*dimensions.*exceed|image.*(?:too large|maximum.*(?:size|dimension))|many-image requests|An attached image exceeds the provider limit/i.test(
       clean
     )
@@ -108,20 +242,21 @@ export function describeError(value) {
     summary = 'An attached image exceeds the provider limit.';
     recovery = 'Reduce the image dimensions or number of images, then try again.';
   } else if (
-    status === 413 ||
+    descriptor.kind === 'unknown' &&
     /payload too large|request (?:body )?too large|The request exceeds the size limit/i.test(clean)
   ) {
-    kind = 'payload-size';
-    summary = 'The request exceeds the size limit.';
-    recovery = 'Reduce the attachments or request size, then try again.';
-  } else if (
-    !rejected429 &&
-    (status === 429 ||
-      /rate[_ -]?limit|quota.*(?:hit|exceed)|too many requests|The provider usage limit was reached/i.test(clean))
-  ) {
-    kind = 'rate-limit';
-    summary = 'The provider usage limit was reached.';
-    recovery = 'Wait for the limit to reset or choose another account.';
+    [kind, summary, recovery] = KIND_COPY.request_too_large;
+  } else if (copy) {
+    [kind, summary, recovery] = copy;
+    if (descriptor.kind === 'rate_limited' && retryAfterMs) {
+      recovery = `Try again in ${waitLabel(retryAfterMs)}.`;
+      recoveryTemplate = 'Try again in {{wait}}.';
+      params = { wait: waitLabel(retryAfterMs) };
+    } else if (descriptor.kind === 'quota_exhausted' && resetAt) {
+      recovery = `It resets at ${resetLabel(resetAt)}. Switch accounts or providers to continue now.`;
+      recoveryTemplate = 'It resets at {{time}}. Switch accounts or providers to continue now.';
+      params = { time: resetLabel(resetAt) };
+    }
   } else if (transport) {
     kind = 'connection';
     summary = transport.replace(/\.$/, '');
@@ -150,6 +285,11 @@ export function describeError(value) {
     kind,
     summary,
     recovery,
+    recoveryTemplate,
+    params,
+    providerKind: descriptor.kind,
+    resetAt,
+    retryAfterMs,
     details,
     // Known structured failures ignore volatile indexes; unknown failures
     // retain their diagnostic identity rather than merging unrelated work.

package/src/runtime/shared/extension-scopes.mjs

@@ -16,6 +16,7 @@
 import { resolve, sep } from 'node:path';
 import { clean } from './clean.mjs';
 import { isPlainObject } from './object.mjs';
+import { parseMcpToolName } from './tool-primitives.mjs';
 
 export const EXTENSION_SCOPE_KINDS = Object.freeze(['skills', 'mcp', 'plugins']);
 
@@ -123,9 +124,10 @@ export function skillAllowedForCwd(scopes, skill, cwd) {
   return true;
 }
 
-export function mcpServerNameOfTool(toolName) {
-  const match = /^mcp__(.+?)__(.+)$/.exec(clean(toolName));
-  return match ? match[1] : '';
+/** Server of an MCP tool definition or name (metadata first; see parseMcpToolName). */
+export function mcpServerNameOfTool(toolOrName) {
+  const value = toolOrName && typeof toolOrName === 'object' ? toolOrName : clean(toolOrName);
+  return clean(parseMcpToolName(value)?.server);
 }
 
 /** New config with one entry replaced; `projects` null/empty removes it (global). */

package/src/runtime/shared/file-lock.mjs

@@ -177,16 +177,38 @@ function warnLockRateLimited(warnedAt, lockPath, line) {
   }
 }
 
-function reportLockWait(lockPath, waitedMs, mode) {
+function formatLockTiming(timing) {
+  return Object.entries(timing || {})
+    .filter(([, ms]) => Number.isFinite(ms))
+    .map(([name, ms]) => ` ${name}=${ms}ms`)
+    .join('');
+}
+
+// Lets a lock owner's callback attribute its time (io gate wait, write) to the
+// held-warning of the lock it runs under.
+export function recordLockTiming(lockPath, fields) {
+  const lease = heldLockPaths.getStore()?.get(lockPath);
+  if (lease?.active) Object.assign(lease.timing, fields);
+}
+
+function reportLockWait(lockPath, waitedMs, mode, timing) {
   if (waitedMs < LOCK_WAIT_WARN_MS) return;
-  warnLockRateLimited(lockWaitWarnedAt, lockPath, `[atomic-file] ${mode} lock wait ${waitedMs}ms: ${lockPath}\n`);
+  warnLockRateLimited(
+    lockWaitWarnedAt,
+    lockPath,
+    `[atomic-file] ${mode} lock wait ${waitedMs}ms:${formatLockTiming(timing)} ${lockPath}\n`
+  );
 }
 
 // A lock held this long starves every waiter (they time out at 2s), so the
 // holder's duration is reported once released.
-function reportLockHeld(lockPath, heldMs, mode) {
+function reportLockHeld(lockPath, heldMs, mode, timing) {
   if (heldMs < LOCK_HELD_WARN_MS) return;
-  warnLockRateLimited(lockHeldWarnedAt, lockPath, `[atomic-file] ${mode} lock held ${heldMs}ms: ${lockPath}\n`);
+  warnLockRateLimited(
+    lockHeldWarnedAt,
+    lockPath,
+    `[atomic-file] ${mode} lock held ${heldMs}ms:${formatLockTiming(timing)} ${lockPath}\n`
+  );
 }
 
 function* tryAcquireReclaimGuard(lockPath) {
@@ -387,7 +409,7 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
   return removed;
 }
 
-function* acquireLock(lockPath, opts, mode, markHeld) {
+function* acquireLock(lockPath, opts, mode, markHeld, timing = null) {
   const timeoutMs = lockTimeoutMs(opts);
   const staleMs = lockStaleMs(opts);
   const deadline = Date.now() + timeoutMs;
@@ -415,7 +437,9 @@ function* acquireLock(lockPath, opts, mode, markHeld) {
       attempt += 1;
       continue;
     }
-    reportLockWait(lockPath, Date.now() - waitStartedAt, mode);
+    const osMs = Date.now() - waitStartedAt;
+    if (timing) timing.osAcquireMs = osMs;
+    reportLockWait(lockPath, osMs, mode, timing);
     return;
   }
   throw timeoutError(lockPath, timeoutMs, lastError, yield* describeLockHolder(lockPath));
@@ -444,13 +468,15 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
 export async function withFileLock(lockPath, fn, opts = {}) {
   if (heldLockPaths.getStore()?.get(lockPath)?.active) return fn();
   if (lockTimeoutMs(opts) <= 0) return withOsFileLock(lockPath, fn, opts);
-  return lockQueue(lockPath, () => withOsFileLock(lockPath, fn, opts));
+  const enqueuedAt = Date.now();
+  return lockQueue(lockPath, () => withOsFileLock(lockPath, fn, opts, Date.now() - enqueuedAt));
 }
 
-async function withOsFileLock(lockPath, fn, opts = {}) {
-  await runAsync(acquireLock(lockPath, opts, 'async', true));
+async function withOsFileLock(lockPath, fn, opts = {}, queueWaitMs = 0) {
+  const timing = { queueWaitMs };
+  await runAsync(acquireLock(lockPath, opts, 'async', true, timing));
   const heldSince = Date.now();
-  const lease = { active: false };
+  const lease = { active: false, timing };
   try {
     if (opts.secret === true) await enforceOwnerOnlyAclWin32Async(lockPath, { fresh: true });
     // Async descendants inherit a reference to this lease, not permanent
@@ -464,7 +490,7 @@ async function withOsFileLock(lockPath, fn, opts = {}) {
     try {
       await runAsync(releaseLock(lockPath));
     } finally {
-      reportLockHeld(lockPath, Date.now() - heldSince, 'async');
+      reportLockHeld(lockPath, Date.now() - heldSince, 'async', timing);
       // Unmark only once the lock file is gone: a sync waiter arriving while
       // the release is still pending must fail fast, not block its completion.
       unmarkOsHeld(lockPath);

package/src/runtime/shared/llm/anthropic-betas.mjs

@@ -13,12 +13,13 @@ export const SERVER_SIDE_FALLBACK_BETA_HEADER = 'server-side-fallback-2026-07-01
 // `speed: "fast"` and Opus 4.6 silently runs at standard speed.
 const KNOWN_FAST_MODE_MODELS = /^claude-opus-(?:4-8|5)(?:$|[-@])/;
 
-// The id pattern is the offline floor. A model the pricing catalog declares
-// Fast-capable is accepted too, so a later release needs no edit here.
+// The catalog's declaration (true or false) decides; the id pattern is only
+// the offline floor for a model the catalog says nothing about.
 export function supportsAnthropicFastMode(model) {
   const id = normalizeClaudeModelId(model);
   if (!id) return false;
-  return KNOWN_FAST_MODE_MODELS.test(id) || getModelMetadataSync(id, 'anthropic')?.supportsFastMode === true;
+  const declared = getModelMetadataSync(id, 'anthropic')?.supportsFastMode;
+  return typeof declared === 'boolean' ? declared : KNOWN_FAST_MODE_MODELS.test(id);
 }
 
 export function buildAnthropicBetaHeaders({