mixdog 1.1.2 → 1.2.1

package/src/runtime/memory/lib/session-ingest.mjs

@@ -201,8 +201,8 @@ function isExcludedUserIngestText(m, text) {
   if (metaSource === 'task-notification') return true;
   // `Reference files:` synthetic user rows (manager.mjs isReferenceFilesMessage).
   if (/^Reference files:\s*/i.test(trimmedStart)) return true;
-  // Attachment-only placeholder rows (e.g. Discord provider discord.mjs:724
-  // `"(attachment)"` fallback when a message carries no text, only files).
+  // Attachment-only placeholder rows (`"(attachment)"` fallback written by the
+  // former channel provider when a message carried no text, only files).
   if (text.trim() === '(attachment)') return true;
   // Compaction summary user rows (compact.mjs isSummaryMessage / SUMMARY_PREFIX).
   if (metaSource === 'compact-summary') return true;

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,
@@ -240,6 +240,12 @@ export function writeJsonAtomicSync(filePath, value, opts = {}) {
   return writeFileAtomicSync(filePath, `${JSON.stringify(value, null, opts.compact ? 0 : 2)}\n`, opts);
 }
 
+// Windows editors and PowerShell 5 save UTF-8 with a leading byte order mark,
+// which JSON.parse rejects; a hand-edited state file must still load.
+export function parseJsonText(text) {
+  return JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
+}
+
 function recoverJsonMutationRead(error) {
   // Missing/malformed JSON retains the existing initializer contract. An I/O
   // or permission failure is not an empty document and must never authorize
@@ -255,7 +261,7 @@ export function updateJsonAtomicSync(filePath, mutator, opts = {}) {
     () => {
       let cur = null;
       try {
-        cur = JSON.parse(readFileSync(filePath, 'utf8'));
+        cur = parseJsonText(readFileSync(filePath, 'utf8'));
       } catch (error) {
         cur = recoverJsonMutationRead(error);
       }
@@ -315,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 = {}) {
@@ -336,7 +363,7 @@ export async function updateJsonAtomic(filePath, mutator, opts = {}) {
     async () => {
       let cur = null;
       try {
-        cur = JSON.parse(await readFileAsync(filePath, 'utf8'));
+        cur = parseJsonText(await readFileAsync(filePath, 'utf8'));
       } catch (error) {
         cur = recoverJsonMutationRead(error);
       }

package/src/runtime/shared/best-effort-stderr.mjs

@@ -0,0 +1,8 @@
+// stderr diagnostics that must never throw (closed or broken stderr).
+export function writeStderrBestEffort(line) {
+  try {
+    process.stderr.write(line);
+  } catch {
+    /* diagnostics only */
+  }
+}

package/src/runtime/shared/code-graph-state.mjs

@@ -74,6 +74,18 @@ export function markCodeGraphDirtyPaths(paths) {
   }
 }
 
+/** Drop the resident graph, pending dirty paths and dirty generation of one
+ *  root (exact canonical match; nested roots are other roots). Returns the
+ *  names of the state that was actually dropped. */
+export function forgetCodeGraphStateRoot(root) {
+  const key = canonicalGraphCwd(root);
+  const removed = [];
+  if (codeGraphCache.delete(key)) removed.push('resident-graph');
+  if (codeGraphDirtyPaths.delete(key)) removed.push('dirty-paths');
+  if (codeGraphDirtyGen.delete(key)) removed.push('dirty-generation');
+  return removed;
+}
+
 export function registerCodeGraphDrain(fn) {
   drainCodeGraphCacheFn = typeof fn === 'function' ? fn : null;
 }

package/src/runtime/shared/defaults-separation.mjs

@@ -21,6 +21,7 @@ import { DEFAULTS_VERSION, DEFAULTS_VERSION_KEY, configPath, readConfig, updateC
 import { DEFAULT_DISABLED_AGENT_ROSTER, disabledAgentDelta, disabledAgentIds } from './agent-route-config.mjs';
 import { withGrandfatheredBuiltins } from './builtin-grandfathering.mjs';
 import { DEFAULT_ORCHESTRATION_MODE, legacyWorkflowOrchestrationMode } from './orchestration.mjs';
+import { WORKTREE_SETTINGS_DEFAULTS } from './worktrees/settings.mjs';
 
 export { DEFAULTS_VERSION, DEFAULTS_VERSION_KEY };
 
@@ -33,6 +34,7 @@ const AGENT_SECTION_DEFAULTS = Object.freeze({
   update: Object.freeze({ auto: true }),
   recap: Object.freeze({ enabled: true }),
   memoryTools: Object.freeze({ enabled: true }),
+  worktree: WORKTREE_SETTINGS_DEFAULTS,
 });
 const MODULE_DEFAULTS = Object.freeze({ enabled: true });
 

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/git-runner-worker.mjs

@@ -6,7 +6,7 @@
 import { spawn } from 'node:child_process';
 import { serveWorkerRequests } from './worker-requests.mjs';
 
-function runGit({ args, cwd, input, env, timeoutMs, maxBytes }) {
+function runGit({ 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('git', args, {
@@ -55,7 +55,8 @@ function runGit({ args, cwd, input, env, timeoutMs, maxBytes }) {
     child.once('close', (code) => {
       const result = {
         code: Number(code ?? 1),
-        stdout: Buffer.concat(stdout).toString('utf8'),
+        // '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 git otherwise reported success.

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

@@ -13,8 +13,9 @@ const requestGit = createWorkerRequestClient(new URL('./git-runner-worker.mjs',
 /**
  * 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.
+ * maxBytes, or the spawn error itself. `stdoutEncoding: 'base64'` returns the
+ * exact stdout bytes base64-encoded instead of decoded as UTF-8.
  */
-export function runGitOffThread(args, { cwd, input = '', env = null, timeoutMs, maxBytes }) {
-  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes });
+export function runGitOffThread(args, { cwd, input = '', env = null, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
+  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding });
 }

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

@@ -96,6 +96,20 @@ function _catalogLevels(model) {
   return null;
 }
 
+/**
+ * Effort levels the wire builder sends unchanged for `model` (reserved `max`
+ * excluded), from the same capability gates normalizeAnthropicEffortInput and
+ * applyAnthropicEffortToBody use: catalog record first, regex ladder for an
+ * absent record. A model without effort support, or whose catalog record
+ * declares none, accepts none.
+ */
+export function anthropicEffortLevelsFor(model) {
+  if (!modelSupportsEffort(model)) return [];
+  const levels = ['low', 'medium', 'high'];
+  if (modelSupportsXhighEffort(model)) levels.push('xhigh');
+  return levels;
+}
+
 export const EFFORT_BETA_HEADER = 'effort-2025-11-24';
 
 export const LEGACY_EFFORT_BUDGET = Object.freeze({

package/src/runtime/shared/llm/default-context-window.mjs

@@ -24,6 +24,12 @@ function positiveTokens(value) {
   return Number.isFinite(tokens) && tokens > 0 ? Math.floor(tokens) : 0;
 }
 
+/** An exact context-window selection in tokens (`contextTokens`); undefined when unset or invalid. */
+export function normalizeContextTokens(value) {
+  const tokens = Math.round(Number(value));
+  return Number.isFinite(tokens) && tokens > 0 ? tokens : undefined;
+}
+
 /**
  * The default and the largest selectable window of one model row, in tokens.
  * `defaultWindow` is 0 when the row states no window to start from.

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -69,7 +69,8 @@ function projectModelsDevRow(row) {
   if (limit) out.limit = limit;
   const modalities = pickArrays(row.modalities, MODELSDEV_MODALITY_FIELDS);
   if (modalities) out.modalities = modalities;
-  if (row.reasoning === true) out.reasoning = true;
+  // A declared `reasoning: false` must stay distinct from absent (capabilityFlag).
+  if (typeof row.reasoning === 'boolean') out.reasoning = row.reasoning;
   if (Array.isArray(row.reasoning_options) && row.reasoning_options.length > 0) {
     out.reasoning_options = row.reasoning_options;
   }
@@ -129,8 +130,8 @@ const LITELLM_NUMBER_FIELDS = [
   'output_cost_per_video_token',
   'output_cost_per_second',
 ];
-// _normalize tests each of these with `=== true`, so only a true value carries
-// information; anything else is indistinguishable from absent.
+// _normalize keeps each declared boolean (an explicit false outranks a lower
+// layer's true); any other value is indistinguishable from absent.
 const LITELLM_FLAG_FIELDS = [
   'supports_vision',
   'supports_function_calling',
@@ -164,7 +165,7 @@ function projectLitellmRow(row) {
       out[field] = value;
   }
   for (const field of LITELLM_FLAG_FIELDS) {
-    if (row[field] === true) out[field] = true;
+    if (typeof row[field] === 'boolean') out[field] = row[field];
   }
   for (const field of LITELLM_STRING_FIELDS) {
     const value = row[field];