mixdog 1.4.0 → 1.4.2

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

@@ -1,16 +1,8 @@
-import {
-  linkSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs';
+import { linkSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import {
   link as linkAsync,
   mkdir as mkdirAsync,
+  readdir as readdirAsync,
   readFile as readFileAsync,
   stat as statAsync,
   unlink as unlinkAsync,
@@ -384,10 +376,16 @@ function lockStaleMs(opts) {
 // A staged owner record lives for one link call; a process killed between its
 // create and unlink leaves `<lock>.<pid>.<hex>.tmp` behind. Each lock path is
 // swept once per process for staged files older than this whose pid is dead.
+// The sweep is cleanup only — no lock decision depends on it — so it runs
+// beside the acquisition instead of in front of it: listing a crowded
+// directory synchronously blocked every lock taker for seconds. A file it
+// removes belongs to a dead pid and is past any link call, so it cannot race
+// a live acquisition.
 const STAGED_LOCK_FILE_STALE_MS = 60_000;
 const sweptLockPaths = new Set();
 
-export function sweepStagedLockFiles(lockPath, now = Date.now()) {
+/** Resolves with the number of staged files removed; 0 once the path was swept in this process. */
+export async function sweepStagedLockFiles(lockPath, now = Date.now()) {
   if (sweptLockPaths.has(lockPath)) return 0;
   sweptLockPaths.add(lockPath);
   const dir = dirname(lockPath);
@@ -395,7 +393,7 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
   let removed = 0;
   let names;
   try {
-    names = readdirSync(dir);
+    names = await readdirAsync(dir);
   } catch {
     return 0;
   }
@@ -405,9 +403,9 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
     if (!match) continue;
     const path = join(dir, name);
     try {
-      if (now - statSync(path).mtimeMs < STAGED_LOCK_FILE_STALE_MS) continue;
+      if (now - (await statAsync(path)).mtimeMs < STAGED_LOCK_FILE_STALE_MS) continue;
       if (ownerIsLive({ pid: Number(match[1]), token: null })) continue;
-      unlinkSync(path);
+      await unlinkAsync(path);
       removed += 1;
     } catch {
       // Another sweeper or a late unlink got there first.
@@ -421,7 +419,7 @@ function* acquireLock(lockPath, opts, mode, markHeld, timing = null) {
   const staleMs = lockStaleMs(opts);
   const deadline = Date.now() + timeoutMs;
   yield ['mkdirp', dirname(lockPath)];
-  sweepStagedLockFiles(lockPath);
+  void sweepStagedLockFiles(lockPath);
   const waitStartedAt = Date.now();
   let attempt = 0;
   let lastError = null;

package/src/runtime/shared/git-launch.d.mts

@@ -0,0 +1,9 @@
+export function gitCommand(env?: NodeJS.ProcessEnv | null): string;
+export function gitChildEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export function gitChildEnv(env?: null): NodeJS.ProcessEnv | null;
+export function forgetMissingGit(command: string, error: unknown): boolean;
+export function startGit<T>(
+  env: NodeJS.ProcessEnv,
+  start: (command: string, env: NodeJS.ProcessEnv) => Promise<T>,
+  spawnError?: (outcome: T) => unknown
+): Promise<T>;

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

@@ -0,0 +1,213 @@
+// The git executable product code starts, and the environment it starts with.
+//
+// On Windows `git` on PATH is usually Git for Windows' launcher,
+// <root>\cmd\git.exe (or the identical <root>\bin\git.exe). It only prepares
+// the environment and starts <root>\<msystem>\bin\git.exe as a second process,
+// so every git child costs two process creations. When PATH's git is that
+// launcher, children start the real binary directly with the environment the
+// launcher would have built. The steps below follow git-wrapper.c
+// (git-for-windows/MINGW-packages, mingw-w64-git/git-wrapper.c): main()'s
+// `git.exe` branch and setup_environment(top_level_path, full_path=1) plus
+// maybe_read_config(). Anything else — another platform, a scoop shim, MinGit,
+// a git.exe outside such a layout, an ambiguous or incomplete install — keeps
+// plain `git` and the caller's environment, exactly as before.
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join } from 'node:path';
+
+// The wrapper's compile-time MSYSTEM, lower-cased, names its binary directory.
+const MSYSTEM_DIRECTORIES = ['mingw64', 'clangarm64', 'mingw32'];
+
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Windows names are case-insensitive. Of several spellings in one object
+// Node passes the first in sorted order to the child, so that one is read and
+// written.
+function envKey(env, name) {
+  const upper = name.toUpperCase();
+  return (
+    Object.keys(env)
+      .filter((key) => key.toUpperCase() === upper)
+      .sort()[0] ?? name
+  );
+}
+
+function envValue(env, name) {
+  const value = env[envKey(env, name)];
+  return value === undefined || value === null ? undefined : String(value);
+}
+
+// The wrapper's my_path_append: one backslash between the parts.
+function appendPath(list, part) {
+  return list.endsWith('\\') ? `${list}${part}` : `${list}\\${part}`;
+}
+
+// libuv's search for a bare `git` (no directory, no extension): each PATH
+// entry in order, `git.com` before `git.exe`.
+function launcherOnPath(pathValue) {
+  for (const raw of String(pathValue || '').split(delimiter)) {
+    const entry = raw.trim().replace(/^"(.*)"$/, '$1');
+    if (!entry) continue;
+    // A relative entry resolves against each child's cwd; not decidable once.
+    if (!isAbsolute(entry)) return null;
+    if (isFile(join(entry, 'git.com'))) return null;
+    const candidate = join(entry, 'git.exe');
+    if (isFile(candidate)) return candidate;
+  }
+  return null;
+}
+
+// etc\git-bash.config `MSYS=` lines, each prepended to MSYS in file order.
+function readMsysConfig(root) {
+  let text = '';
+  try {
+    text = readFileSync(join(root, 'etc', 'git-bash.config'), 'utf8');
+  } catch {
+    return [];
+  }
+  return text
+    .split('\n')
+    .map((line) => line.replace(/\r$/, ''))
+    .filter((line) => line.startsWith('MSYS='))
+    .map((line) => line.slice(5));
+}
+
+/**
+ * The Git for Windows layout behind PATH's `git`, or null when there is none
+ * to bypass. `{ command, root, msystem, msysConfig }`.
+ */
+export function resolveGitLaunch({ platform = process.platform, pathValue = process.env.PATH } = {}) {
+  if (platform !== 'win32') return null;
+  const found = launcherOnPath(pathValue);
+  if (!found) return null;
+  let launcher;
+  try {
+    // The wrapper locates its install from its own final path.
+    launcher = realpathSync.native(found);
+  } catch {
+    return null;
+  }
+  if (basename(launcher).toLowerCase() !== 'git.exe') return null;
+  const launcherDirectory = dirname(launcher);
+  if (!['cmd', 'bin'].includes(basename(launcherDirectory).toLowerCase())) return null;
+  const root = dirname(launcherDirectory);
+  // The installer and PortableGit ship git-bash.exe; MinGit and other layouts do not.
+  if (!isFile(join(root, 'git-bash.exe')) || !isDirectory(join(root, 'usr', 'bin'))) return null;
+  const installed = MSYSTEM_DIRECTORIES.filter((name) => isFile(join(root, name, 'bin', 'git.exe')));
+  if (installed.length !== 1) return null;
+  const [msystemDirectory] = installed;
+  return {
+    command: join(root, msystemDirectory, 'bin', 'git.exe'),
+    root,
+    msystem: msystemDirectory.toUpperCase(),
+    msysConfig: readMsysConfig(root),
+  };
+}
+
+function isSystemDirectory(path) {
+  const system = join(process.env.SystemRoot || process.env.windir || 'C:\\Windows', 'System32');
+  return path.toLowerCase() === system.toLowerCase();
+}
+
+/** `base` as the launcher would hand it to the real git (setup_environment). */
+export function gitLaunchEnvironment(launch, base) {
+  const env = { ...base };
+  const set = (name, value) => {
+    env[envKey(env, name)] = value;
+  };
+  set('MSYSTEM', launch.msystem);
+  if (envValue(env, 'PLINK_PROTOCOL') === undefined) set('PLINK_PROTOCOL', 'ssh');
+  if (envValue(env, 'HOME') === undefined) {
+    const homePath = envValue(env, 'HOMEPATH');
+    const drive = `${envValue(env, 'HOMEDRIVE') ?? ''}${homePath ?? ''}`;
+    if (homePath !== undefined && !isSystemDirectory(drive) && isDirectory(drive)) set('HOME', drive);
+    else if (envValue(env, 'USERPROFILE') !== undefined) set('HOME', envValue(env, 'USERPROFILE'));
+  }
+  // <root>\<msystem>\bin;<root>\usr\bin;<HOME>\bin; ahead of the inherited PATH.
+  const prefix =
+    `${appendPath(launch.root, `${launch.msystem.toLowerCase()}\\bin`)};` +
+    appendPath(launch.root, 'usr\\bin;') +
+    appendPath(envValue(env, 'HOME') ?? '', 'bin;');
+  set('PATH', `${prefix}${envValue(env, 'PATH') ?? ''}`);
+  for (const msys of launch.msysConfig) {
+    const current = envValue(env, 'MSYS');
+    set('MSYS', current === undefined ? msys : `${msys} ${current}`);
+  }
+  return env;
+}
+
+// PATH value -> its launch (or null), resolved once per PATH: a child is
+// started with the git its own environment's PATH names, as bare `git` is.
+const resolved = new Map();
+function gitLaunch(env) {
+  const pathValue = envValue(env ?? process.env, 'PATH') ?? '';
+  if (!resolved.has(pathValue)) resolved.set(pathValue, resolveGitLaunch({ pathValue }));
+  return resolved.get(pathValue);
+}
+
+/** The program to spawn for git with `env` (null: this process's environment). */
+export function gitCommand(env = null) {
+  return gitLaunch(env)?.command ?? 'git';
+}
+
+/**
+ * The environment for a git child: `env` (null: this process's environment)
+ * with the launcher's additions when {@link gitCommand} bypasses it. Without a
+ * bypass `env` is returned unchanged, null included.
+ */
+export function gitChildEnv(env = null) {
+  const launch = gitLaunch(env);
+  return launch ? gitLaunchEnvironment(launch, env ?? process.env) : env;
+}
+
+/**
+ * Whether a spawn of `command` failed because that resolved binary is gone (an
+ * uninstalled or moved Git). Its resolutions are dropped then, so the next
+ * {@link gitCommand} resolves PATH afresh. ENOENT alone is not enough: a
+ * missing cwd reports it too, with the binary still in place.
+ */
+export function forgetMissingGit(command, error) {
+  if (error?.code !== 'ENOENT' || command === 'git' || isFile(command)) return false;
+  for (const [pathValue, launch] of resolved) if (launch?.command === command) resolved.delete(pathValue);
+  return true;
+}
+
+/**
+ * Starts git as `start(command, childEnv)` and, when that spawn failed only
+ * because the resolved binary is gone, once more with a fresh resolution —
+ * where bare `git` would have found whatever PATH holds now. `start` rejects
+ * with the spawn error, or settles an outcome `spawnError` reads it from.
+ */
+export async function startGit(env, start, spawnError = () => null) {
+  const command = gitCommand(env);
+  let outcome;
+  try {
+    outcome = await start(command, gitChildEnv(env));
+  } catch (error) {
+    if (!forgetMissingGit(command, error)) throw error;
+    return start(gitCommand(env), gitChildEnv(env));
+  }
+  if (!forgetMissingGit(command, spawnError(outcome))) return outcome;
+  return start(gitCommand(env), gitChildEnv(env));
+}
+
+/** {@link startGit} for a synchronous `start` (spawnSync). */
+export function startGitSync(env, start, spawnError = (result) => result?.error) {
+  const command = gitCommand(env);
+  const outcome = start(command, gitChildEnv(env));
+  if (!forgetMissingGit(command, spawnError(outcome))) return outcome;
+  return start(gitCommand(env), gitChildEnv(env));
+}

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

@@ -2,7 +2,8 @@
 // thread, never on the host event loop (run-child.mjs). Each request resolves
 // to { code, stdout, stderr } or an error with the same codes the in-process
 // runner used (ETIMEDOUT, EMAXBUFFER, spawn errors).
+import { startGit } from './git-launch.mjs';
 import { runChild } from './run-child.mjs';
 import { serveWorkerRequests } from './worker-requests.mjs';
 
-serveWorkerRequests((request) => runChild({ ...request, command: 'git' }));
+serveWorkerRequests((request) => startGit(request.env, (command, env) => runChild({ ...request, command, env })));

package/src/runtime/shared/handoff-artifacts.d.mts

@@ -8,7 +8,8 @@ export interface HandoffFile {
   id?: string;
 }
 export function normalizeHandoffFiles(files: unknown): HandoffFile[];
-export function artifactLines(files: unknown, omitted?: number, options?: { ids?: boolean }): string[];
+export function artifactLines(files: unknown, omitted?: number): string[];
+export function producedFileLines(files: unknown, omitted?: number): string[];
 export interface HandoffRecord {
   id: string;
   attachmentRef: string;

package/src/runtime/shared/handoff-artifacts.mjs

@@ -31,20 +31,30 @@ export function normalizeHandoffFiles(files) {
     }));
 }
 
-/** The model-facing list of `files`, empty when there are none. `ids`: the
- *  row also records the stored files as its attachments (a task report), so
- *  their ids can be forwarded; a plain-text handoff (an agent completion)
- *  lists paths only — an id named in text is never trusted. */
-export function artifactLines(files, omitted = 0, { ids = true } = {}) {
+/** An agent completion's compact list of files it produced (name and path
+ *  only; the Lead forwards or links by path), empty when there are none. */
+export function producedFileLines(files, omitted = 0) {
   const list = normalizeHandoffFiles(files);
   if (!list.length) return [];
-  const attachable = (file) => (ids ? ` [attachment:${file.id}]` : ' (attachable: forward it by path)');
   return [
-    `Files from this turn (forward one with attachments: [${ids ? 'id or path' : 'path'}]; link a path to show it):`,
+    'Files produced:',
+    ...list.map((file) => `- ${oneLine(file.name)} — ${oneLine(file.path)}`),
+    ...(omitted > 0 ? [`- …and ${omitted} more`] : []),
+  ];
+}
+
+/** The model-facing list of a bot task report's `files`, empty when there are
+ *  none; the row also records the stored files as its attachments, so their
+ *  ids can be forwarded. */
+export function artifactLines(files, omitted = 0) {
+  const list = normalizeHandoffFiles(files);
+  if (!list.length) return [];
+  return [
+    'Files from this turn (forward one with attachments: [id or path]; link a path to show it):',
     ...list.map(
       (file) =>
         `- ${oneLine(file.name)} (${oneLine(file.mimeType)}, ${sizeLabel(file.size)}) — ${oneLine(file.path)}${
-          file.id ? attachable(file) : ' (too large or unsupported to attach; link the path)'
+          file.id ? ` [attachment:${file.id}]` : ' (too large or unsupported to attach; link the path)'
         }`
     ),
     ...(omitted > 0 ? [`- …and ${omitted} more file(s)`] : []),

package/src/runtime/shared/idle-auto-clear-gate.mjs

@@ -44,15 +44,37 @@ function hasModelVisibleConversation(session) {
   });
 }
 
-// When a session's prompt cache was last used by a successful cache warm (a
-// read with no write), registered by the warmer (cache-warm.mjs, from its
-// durable touch store); 0 when none.
-let lastCacheWarmUse = () => 0;
+// A session's last successful cache-warm use (a read with no write),
+// registered by the warmer (cache-warm.mjs, from its durable touch store):
+// `{ at, provider, model, accountId }` — when, and the route and account whose
+// cached prefix it read — or a bare epoch-ms time; null/0 when none.
+let lastCacheWarmUse = () => null;
 
 /** Register the source of a session's last successful cache-warm use
- *  (`(sessionId) => epoch ms | 0`); null restores none. */
+ *  (`(sessionId) => { at, provider, model, accountId } | epoch ms | null`);
+ *  null restores none. */
 export function setCacheWarmUseSource(source) {
-  lastCacheWarmUse = typeof source === 'function' ? source : () => 0;
+  lastCacheWarmUse = typeof source === 'function' ? source : () => null;
+}
+
+/** When a successful cache warm last used the session's prompt cache (epoch
+ *  ms), or 0: the warm read and refreshed the cached prefix without moving
+ *  any of the session's own timestamps. */
+export function lastCacheWarmUseAt(sessionId) {
+  const use = sessionId ? lastCacheWarmUse(sessionId) : null;
+  return timestampMs(use && typeof use === 'object' ? use.at : use);
+}
+
+/** When a successful cache warm last used the prefix a request on `provider`
+ *  / `model` / `accountId` reads (epoch ms), or 0: a warm on another route or
+ *  account refreshed an entry this request cannot read, and a use without a
+ *  recorded identity matches nothing. */
+export function cacheWarmUseFor(sessionId, { provider, model, accountId = '' } = {}) {
+  const use = sessionId ? lastCacheWarmUse(sessionId) : null;
+  if (!use || typeof use !== 'object' || !use.provider) return 0;
+  const matches =
+    use.provider === provider && use.model === model && String(use.accountId || '') === String(accountId || '');
+  return matches ? timestampMs(use.at) : 0;
 }
 
 /**
@@ -65,7 +87,7 @@ export function setCacheWarmUseSource(source) {
 export function sessionActivityTimestamp(session, fallback = 0) {
   if (!hasModelVisibleConversation(session)) return 0;
   const own = timestampMs(session?.lastUsedAt) || timestampMs(session?.updatedAt) || timestampMs(fallback);
-  return Math.max(own, timestampMs(lastCacheWarmUse(session?.id)));
+  return Math.max(own, lastCacheWarmUseAt(session?.id));
 }
 
 // A zero is often an unavailable/stale meter field, not an authoritative

package/src/runtime/shared/llm/cost.mjs

@@ -100,7 +100,11 @@ export function priceUsage(args) {
   // A provider-billed figure for a media request (e.g. xAI cost_in_usd_ticks)
   // is the price, with or without a catalog row.
   const media = args.media || null;
-  if (typeof media?.reportedCostUsd === 'number' && Number.isFinite(media.reportedCostUsd) && media.reportedCostUsd >= 0)
+  if (
+    typeof media?.reportedCostUsd === 'number' &&
+    Number.isFinite(media.reportedCostUsd) &&
+    media.reportedCostUsd >= 0
+  )
     return {
       input,
       costUsd: Number(media.reportedCostUsd.toFixed(6)),
@@ -129,7 +133,12 @@ export function priceUsage(args) {
   // premium request needs the model's published Fast/Priority rates.
   const anthropicFast = premium && sentTier === 'fast' && supportsAnthropicFastMode(identity.pricingModel);
   const premiumPricing = sentTier === 'ultrafast' ? meta.ultrafastPricing : meta.fastPricing;
-  const rateMeta = premium && !anthropicFast ? premiumPricing || {} : meta;
+  // A request the server reports as served on Flex (Vertex Flex PayGo can be
+  // served by Provisioned Throughput first) bills the catalog's flex columns.
+  const flex = args.serviceTier === 'flex';
+  let rateMeta = meta;
+  if (flex) rateMeta = meta.flexPricing || {};
+  else if (premium && !anthropicFast) rateMeta = premiumPricing || {};
   if (args.historicalAggregate && rateMeta.pricingTiers?.some((tier) => promptTokens > tier.aboveInputTokens)) {
     // A daily sum cannot establish which individual requests crossed a
     // context boundary. Do not price the whole day as one huge prompt.