mixdog 0.9.147 → 0.9.148

package/scripts/verify-release-assets.mjs

@@ -26,6 +26,14 @@ export const SPAWN_PLATFORMS = {
   'win32-x64': 'mixdog-spawn-win32-x64.exe',
 };
 
+export const TOKEN_PLATFORMS = {
+  'darwin-arm64': 'mixdog-token-darwin-arm64.node',
+  'darwin-x64': 'mixdog-token-darwin-x64.node',
+  'linux-arm64': 'mixdog-token-linux-arm64.node',
+  'linux-x64': 'mixdog-token-linux-x64.node',
+  'win32-x64': 'mixdog-token-win32-x64.node',
+};
+
 const RUNTIME_PLATFORMS = [
   'linux-x64',
   'linux-arm64',
@@ -43,6 +51,8 @@ const RUNTIME_MANIFEST_PATH = 'src/runtime/memory/data/runtime-manifest.json';
 const GRAPH_MANIFEST_PATH = 'src/runtime/agent/orchestrator/tools/graph-manifest.json';
 const SPAWN_MANIFEST_PATH = 'src/runtime/agent/orchestrator/tools/spawn-manifest.json';
 const SPAWN_CARGO_PATH = 'native/mixdog-spawn/Cargo.toml';
+const TOKEN_MANIFEST_PATH = 'src/runtime/agent/orchestrator/tools/token-manifest.json';
+const TOKEN_CARGO_PATH = 'native/mixdog-token/Cargo.toml';
 const PACKAGE_PATH = 'package.json';
 
 function assertPlainObject(value, label) {
@@ -125,14 +135,43 @@ export function validatePatchManifest(manifest, cargoToml) {
 
 export function validateRuntimeManifest(manifest) {
   assertPlainObject(manifest, 'Runtime manifest');
-  if (!manifest.release_tag || !manifest.assets || typeof manifest.assets !== 'object') {
-    throw new Error(`${RUNTIME_MANIFEST_PATH} is missing release_tag or assets`);
+  assertExactKeys(
+    manifest,
+    ['schema_version', 'generated_at', 'release_tag', 'pg', 'pgvector', 'assets'],
+    'Runtime manifest',
+  );
+  if (manifest.schema_version !== 1) {
+    throw new Error('Runtime manifest schema_version must be 1');
+  }
+  if (typeof manifest.generated_at !== 'string' || !manifest.generated_at) {
+    throw new Error('Runtime manifest generated_at must be a non-empty string');
+  }
+  if (typeof manifest.release_tag !== 'string' || !/^runtime-v\d+\.\d+\.\d+$/.test(manifest.release_tag)) {
+    throw new Error(`Runtime manifest release_tag is invalid: ${manifest.release_tag}`);
+  }
+  assertPlainObject(manifest.pg, 'Runtime manifest pg');
+  assertExactKeys(manifest.pg, ['major', 'minor'], 'Runtime manifest pg');
+  if (!Number.isSafeInteger(manifest.pg.major) || manifest.pg.major < 1) {
+    throw new Error('Runtime manifest pg.major is invalid');
+  }
+  if (!Number.isSafeInteger(manifest.pg.minor) || manifest.pg.minor < 0) {
+    throw new Error('Runtime manifest pg.minor is invalid');
+  }
+  assertPlainObject(manifest.pgvector, 'Runtime manifest pgvector');
+  assertExactKeys(manifest.pgvector, ['version'], 'Runtime manifest pgvector');
+  if (typeof manifest.pgvector.version !== 'string' || !STRICT_VERSION.test(manifest.pgvector.version)) {
+    throw new Error(`Runtime manifest pgvector.version is invalid: ${manifest.pgvector.version}`);
   }
   assertPlainObject(manifest.assets, 'Runtime manifest assets');
   assertExactKeys(manifest.assets, RUNTIME_PLATFORMS, 'Runtime manifest assets');
-  for (const [platform, asset] of Object.entries(manifest.assets)) {
-    if (typeof asset?.url !== 'string' || new URL(asset.url).protocol !== 'https:') {
-      throw new Error(`${platform}: invalid HTTPS asset URL`);
+  for (const platform of RUNTIME_PLATFORMS) {
+    const asset = manifest.assets[platform];
+    assertPlainObject(asset, `Runtime asset ${platform}`);
+    assertExactKeys(asset, ['url', 'sha256', 'size'], `Runtime asset ${platform}`);
+    const filename = `mixdog-runtime-${platform}-pg${manifest.pg.major}.${manifest.pg.minor}-pgvector${manifest.pgvector.version}.tar.gz`;
+    const expected = `https://github.com/tribgames/mixdog/releases/download/${manifest.release_tag}/${filename}`;
+    if (asset.url !== expected) {
+      throw new Error(`${platform}: runtime asset URL must be ${expected}`);
     }
     if (typeof asset.sha256 !== 'string' || !SHA256.test(asset.sha256)) {
       throw new Error(`${platform}: invalid sha256`);
@@ -219,6 +258,50 @@ export function validateSpawnManifest(manifest, cargoToml) {
   return manifest;
 }
 
+export function validateTokenManifest(manifest, cargoToml) {
+  assertPlainObject(manifest, 'Token manifest');
+  assertExactKeys(manifest, ['version', '_comment', 'assets'], 'Token manifest');
+  if (typeof manifest.version !== 'string' || !STRICT_VERSION.test(manifest.version)) {
+    throw new Error(`Token manifest version is not strict MAJOR.MINOR.PATCH: ${manifest.version}`);
+  }
+  if (typeof manifest._comment !== 'string' || !manifest._comment) {
+    throw new Error('Token manifest _comment must be a non-empty string');
+  }
+  let inPackage = false;
+  let cargoVersion;
+  for (const line of String(cargoToml).split(/\r?\n/)) {
+    const section = line.match(/^\s*\[([^\]]+)\]\s*$/)?.[1];
+    if (section) {
+      inPackage = section === 'package';
+      continue;
+    }
+    if (inPackage) {
+      const version = line.match(/^\s*version\s*=\s*"([^"]+)"\s*$/)?.[1];
+      if (version) {
+        cargoVersion = version;
+        break;
+      }
+    }
+  }
+  if (!cargoVersion) throw new Error('Could not read [package] version from native/mixdog-token/Cargo.toml');
+  if (cargoVersion !== manifest.version) {
+    throw new Error(`Token Cargo version ${cargoVersion} does not match manifest version ${manifest.version}`);
+  }
+  assertPlainObject(manifest.assets, 'Token manifest assets');
+  assertExactKeys(manifest.assets, Object.keys(TOKEN_PLATFORMS), 'Token manifest assets');
+  for (const [platform, filename] of Object.entries(TOKEN_PLATFORMS)) {
+    const asset = manifest.assets[platform];
+    assertPlainObject(asset, `Token asset ${platform}`);
+    assertExactKeys(asset, ['url', 'sha256'], `Token asset ${platform}`);
+    const expected = `https://github.com/tribgames/mixdog/releases/download/token-v${manifest.version}/${filename}`;
+    if (asset.url !== expected) throw new Error(`${platform}: token asset URL must be ${expected}`);
+    if (typeof asset.sha256 !== 'string' || !SHA256.test(asset.sha256)) {
+      throw new Error(`${platform}: invalid token asset sha256`);
+    }
+  }
+  return manifest;
+}
+
 async function downloadAndVerify(label, asset, fetchImpl, timeoutMs, maxAssetBytes) {
   console.log(`Downloading and verifying ${label}`);
   const controller = new AbortController();
@@ -307,22 +390,37 @@ export async function verifyReleaseAssets({
   graphManifestPath = GRAPH_MANIFEST_PATH,
   spawnManifestPath = SPAWN_MANIFEST_PATH,
   spawnCargoPath = SPAWN_CARGO_PATH,
+  tokenManifestPath = TOKEN_MANIFEST_PATH,
+  tokenCargoPath = TOKEN_CARGO_PATH,
   packagePath = PACKAGE_PATH,
   downloadOptions,
 } = {}) {
-  const [patchSource, cargoToml, runtimeSource, graphSource, spawnSource, spawnCargo, packageSource] = await Promise.all([
+  const [
+    patchSource,
+    cargoToml,
+    runtimeSource,
+    graphSource,
+    spawnSource,
+    spawnCargo,
+    tokenSource,
+    tokenCargo,
+    packageSource,
+  ] = await Promise.all([
     readFile(patchManifestPath, 'utf8'),
     readFile(cargoPath, 'utf8'),
     readFile(runtimeManifestPath, 'utf8'),
     readFile(graphManifestPath, 'utf8'),
     readFile(spawnManifestPath, 'utf8'),
     readFile(spawnCargoPath, 'utf8'),
+    readFile(tokenManifestPath, 'utf8'),
+    readFile(tokenCargoPath, 'utf8'),
     readFile(packagePath, 'utf8'),
   ]);
   const patchManifest = validatePatchManifest(JSON.parse(patchSource), cargoToml);
   const runtimeManifest = validateRuntimeManifest(JSON.parse(runtimeSource));
   const graphManifest = validateGraphManifest(JSON.parse(graphSource), JSON.parse(packageSource));
   const spawnManifest = validateSpawnManifest(JSON.parse(spawnSource), spawnCargo);
+  const tokenManifest = validateTokenManifest(JSON.parse(tokenSource), tokenCargo);
   await verifyAssetDownloads(patchManifest.assets, downloadOptions);
   console.log(`Verified all bundled patch assets for patch-v${patchManifest.version}.`);
   await verifyAssetDownloads(runtimeManifest.assets, downloadOptions);
@@ -331,6 +429,8 @@ export async function verifyReleaseAssets({
   console.log(`Verified all bundled graph assets for graph-v${graphManifest.version}.`);
   await verifyAssetDownloads(spawnManifest.assets, downloadOptions);
   console.log(`Verified all bundled spawn assets for spawn-v${spawnManifest.version}.`);
+  await verifyAssetDownloads(tokenManifest.assets, downloadOptions);
+  console.log(`Verified all bundled token assets for token-v${tokenManifest.version}.`);
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/scripts/verify-voice-runtime-release.mjs

@@ -0,0 +1,89 @@
+import { createHash } from 'node:crypto'
+import { readFile, stat } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+import {
+  VOICE_RUNTIME_CONFIG,
+  VOICE_RUNTIME_TAG,
+  assertVoiceRuntimeManifestIdentity,
+  buildVoiceRuntimePlatforms,
+  downloadReleaseAsset,
+  fetchGithubRelease,
+  releaseAssetSha256,
+} from './generate-voice-runtime-manifest.mjs'
+
+const delay = (ms) => new Promise((resolveDelay) => setTimeout(resolveDelay, ms))
+
+async function verifyOnce(manifestPath, repository, token) {
+  const release = await fetchGithubRelease(repository, VOICE_RUNTIME_TAG, token)
+  if (!release.draft) throw new Error(`${VOICE_RUNTIME_TAG} must remain draft until verification passes`)
+
+  const manifestBytes = await readFile(manifestPath)
+  const manifest = JSON.parse(manifestBytes.toString('utf8'))
+  await assertVoiceRuntimeManifestIdentity(manifest, { repository })
+
+  const expectedNames = new Set(['voice-runtime-manifest.json'])
+  for (const platform of VOICE_RUNTIME_CONFIG.platforms) {
+    expectedNames.add(platform.asset)
+    expectedNames.add(`${platform.asset}.sha256`)
+  }
+  const voiceAssets = (release.assets || []).filter((asset) =>
+    asset.name === 'voice-runtime-manifest.json' || asset.name.startsWith('whisper-server-'))
+  const unexpected = voiceAssets.filter((asset) => !expectedNames.has(asset.name))
+  if (unexpected.length > 0) {
+    throw new Error(`release has unexpected voice assets: ${unexpected.map((asset) => asset.name).join(', ')}`)
+  }
+  for (const name of expectedNames) {
+    if (!voiceAssets.some((asset) => asset.name === name)) {
+      throw new Error(`release is missing required asset ${name}`)
+    }
+  }
+
+  const generatedPlatforms = buildVoiceRuntimePlatforms(release.assets, {
+    repository,
+    tag: VOICE_RUNTIME_TAG,
+  })
+  if (JSON.stringify(generatedPlatforms) !== JSON.stringify(manifest.platforms)) {
+    throw new Error('released runtime assets do not match the generated manifest')
+  }
+
+  const manifestAsset = voiceAssets.find((asset) => asset.name === 'voice-runtime-manifest.json')
+  const localManifestHash = createHash('sha256').update(manifestBytes).digest('hex')
+  const localManifestSize = (await stat(manifestPath)).size
+  if (manifestAsset.size !== localManifestSize || releaseAssetSha256(manifestAsset) !== localManifestHash) {
+    throw new Error('uploaded voice-runtime-manifest.json does not match the verified local manifest')
+  }
+
+  for (const platform of VOICE_RUNTIME_CONFIG.platforms) {
+    const archive = voiceAssets.find((asset) => asset.name === platform.asset)
+    const sidecar = voiceAssets.find((asset) => asset.name === `${platform.asset}.sha256`)
+    const sidecarText = (await downloadReleaseAsset(sidecar, token)).toString('utf8').trim()
+    const declaredHash = /^([a-f0-9]{64})\s+/i.exec(sidecarText)?.[1]?.toLowerCase()
+    const archiveHash = releaseAssetSha256(archive)
+    if (declaredHash !== archiveHash) {
+      throw new Error(`${sidecar.name} does not match ${archive.name}`)
+    }
+  }
+}
+
+async function main() {
+  const manifestPath = resolve(process.argv[2] || 'src/runtime/channels/data/voice-runtime-manifest.json')
+  const repository = String(process.env.GITHUB_REPOSITORY || 'tribgames/mixdog')
+  let lastError
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    try {
+      await verifyOnce(manifestPath, repository, process.env.GITHUB_TOKEN)
+      console.log(`verified complete draft release ${VOICE_RUNTIME_TAG}`)
+      return
+    } catch (error) {
+      lastError = error
+      if (attempt < 5) await delay(attempt * 2_000)
+    }
+  }
+  throw lastError
+}
+
+main().catch((error) => {
+  console.error(error?.stack || error)
+  process.exitCode = 1
+})

package/scripts/voice-runtime-config.json

@@ -0,0 +1,52 @@
+{
+  "runtimeVersion": "1.9.2",
+  "whisperCommit": "306c88f4d1286aec1bf96e544632897886af5501",
+  "vulkanSdkVersion": "1.4.309.0",
+  "platforms": [
+    {
+      "key": "win32-x64",
+      "os": "win32",
+      "arch": "x64",
+      "backend": "vulkan",
+      "runner": "windows-2022",
+      "asset": "whisper-server-win32-x64-vulkan.zip",
+      "executable": "whisper-server.exe"
+    },
+    {
+      "key": "linux-x64",
+      "os": "linux",
+      "arch": "x64",
+      "backend": "vulkan",
+      "runner": "ubuntu-24.04",
+      "asset": "whisper-server-linux-x64-vulkan.zip",
+      "executable": "whisper-server"
+    },
+    {
+      "key": "linux-arm64",
+      "os": "linux",
+      "arch": "arm64",
+      "backend": "vulkan",
+      "runner": "ubuntu-24.04-arm",
+      "asset": "whisper-server-linux-arm64-vulkan.zip",
+      "executable": "whisper-server"
+    },
+    {
+      "key": "darwin-arm64",
+      "os": "darwin",
+      "arch": "arm64",
+      "backend": "metal",
+      "runner": "macos-14",
+      "asset": "whisper-server-darwin-arm64-metal.zip",
+      "executable": "whisper-server"
+    },
+    {
+      "key": "darwin-x64",
+      "os": "darwin",
+      "arch": "x64",
+      "backend": "cpu",
+      "runner": "macos-15-intel",
+      "asset": "whisper-server-darwin-x64-cpu.zip",
+      "executable": "whisper-server"
+    }
+  ]
+}

package/src/app.mjs

@@ -120,17 +120,54 @@ export async function run(argv = [], classifiedInvocation = null) {
   // in src. Sample a few hot files — a newer source than the bundle means the
   // running behavior will NOT match the tree, so warn loudly.
   try {
-    const { statSync } = await import('node:fs');
+    const { readdirSync, statSync } = await import('node:fs');
     const bundleMtime = statSync(bundle).mtimeMs;
     const hotSources = [
       join(__dirname, 'runtime', 'agent', 'orchestrator', 'session', 'agent-loop.mjs'),
       join(__dirname, 'runtime', 'agent', 'orchestrator', 'session', 'loop', 'stored-tool-args.mjs'),
-      join(__dirname, 'tui', 'engine', 'session-api-ext.mjs'),
       join(__dirname, 'standalone', 'agent-tool.mjs'),
     ];
-    const stale = hotSources.some((file) => {
-      try { return statSync(file).mtimeMs > bundleMtime + 1_000; } catch { return false; }
-    });
+    // The TUI half of the guard used to sample ONE path that does not exist
+    // (tui/engine/session-api-ext.mjs), so every real src/tui edit ran silently
+    // against an old bundle. Walk the actual bundled tree instead — dist (the
+    // build output) and dev (excluded from the package) are not inputs.
+    const tuiSourceNewestMtime = (() => {
+      const skipDirs = new Set(['dist', 'dev', 'node_modules']);
+      // Ceilings, not expectations: the bundled tree is currently 2 levels
+      // deep with ~150 files, so depth 12 reaches every source that can end up
+      // in the bundle (the old depth-6 cut would have started missing files as
+      // soon as the tree grew), while the visit budget keeps this boot-time
+      // walk bounded on any pathological tree. The guard is advisory, so a
+      // budget-truncated walk still reports the newest mtime it did see.
+      const MAX_DEPTH = 12;
+      const MAX_VISITS = 5000;
+      let visits = 0;
+      let newest = 0;
+      const walk = (dir, depth) => {
+        if (depth > MAX_DEPTH || visits >= MAX_VISITS) return;
+        let entries;
+        try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const entry of entries) {
+          if (visits >= MAX_VISITS) return;
+          visits += 1;
+          if (entry.isDirectory()) {
+            if (!skipDirs.has(entry.name)) walk(join(dir, entry.name), depth + 1);
+            continue;
+          }
+          if (!/\.(mjs|jsx|js)$/.test(entry.name)) continue;
+          try {
+            const mtime = statSync(join(dir, entry.name)).mtimeMs;
+            if (mtime > newest) newest = mtime;
+          } catch { /* unreadable file is not evidence of staleness */ }
+        }
+      };
+      walk(join(__dirname, 'tui'), 0);
+      return newest;
+    })();
+    const stale = tuiSourceNewestMtime > bundleMtime + 1_000
+      || hotSources.some((file) => {
+        try { return statSync(file).mtimeMs > bundleMtime + 1_000; } catch { return false; }
+      });
     if (stale) {
       process.stderr.write(
         'mixdog: TUI bundle is OLDER than runtime sources — behavior will not match the tree.\n'

package/src/headless-exec.mjs

@@ -13,7 +13,6 @@ import {
 } from './runtime/shared/pristine-execution.mjs';
 import { hasActiveBackgroundTasks } from './runtime/shared/background-tasks.mjs';
 import { installProcessSignalCleanup } from './runtime/shared/process-shutdown.mjs';
-import { sleep } from './runtime/shared/sleep.mjs';
 import { stopStandaloneMemoryRuntimesForProcess } from './standalone/memory-runtime-proxy.mjs';
 import { applyUsageDelta, createSessionStats } from './ui/session-stats.mjs';
 
@@ -21,6 +20,21 @@ function clean(value) {
   return String(value ?? '').trim();
 }
 
+export async function prewarmHeadlessSearch(cwd, {
+  loadNativeSearch = () => import('./runtime/agent/orchestrator/tools/builtin/native-search-client.mjs'),
+  loadListTool = () => import('./runtime/agent/orchestrator/tools/builtin/list-tool.mjs'),
+} = {}) {
+  const root = clean(cwd) || process.cwd();
+  const [nativeSearch, listTool] = await Promise.all([
+    loadNativeSearch(),
+    loadListTool(),
+  ]);
+  await Promise.all([
+    nativeSearch.warmNativeSearchServer(),
+    listTool.prewarmFindEnumeration(root),
+  ]);
+}
+
 function nonNegativeNumber(value) {
   const number = Number(value);
   return Number.isFinite(number) ? Math.max(0, number) : 0;
@@ -424,6 +438,8 @@ function createJsonLifecycle({
       }
       const durationMs = Math.max(0, completedAt - turnStartedAt);
       const usage = usageSummary(stats, toolCallCount);
+      const terminationReason = clean(result?.terminationReason) || null;
+      const isApiError = terminationReason === 'refusal';
       emit({
         type: 'turn.completed',
         thread_id: threadId,
@@ -441,7 +457,7 @@ function createJsonLifecycle({
         turn_id: turnId,
         session_id: threadId,
         model: resolvedModel,
-        is_error: false,
+        is_error: isApiError,
         duration_ms: durationMs,
         duration_api_ms: providerDurationMs,
         num_turns: 1,
@@ -449,6 +465,7 @@ function createJsonLifecycle({
         tool_calls: toolCallCount,
         result: finalText,
         stop_reason: result?.stopReason ?? result?.stop_reason ?? null,
+        termination_reason: terminationReason,
         usage,
       }, completedAt);
     },
@@ -491,28 +508,17 @@ function createJsonLifecycle({
   };
 }
 
-export async function waitForTrackedTasks({
-  sessionId,
-  clientHostPid = process.pid,
-  hasActiveTasks = hasActiveBackgroundTasks,
-  pollMs = 100,
-} = {}) {
-  const scope = {
-    ...(clean(sessionId) ? { callerSessionId: clean(sessionId) } : {}),
-    clientHostPid,
-  };
-  while (hasActiveTasks(scope)) {
-    await sleep(Math.max(10, Number(pollMs) || 100));
-  }
-}
-
-function writeUsageDocument(path, stats, runtime, toolCallCount = 0) {
+function writeUsageDocument(path, stats, runtime, toolCallCount = 0, observedModels = []) {
   const target = clean(path);
   if (!target) return;
+  const models = [
+    clean(runtime?.model),
+    ...Array.from(observedModels || [], clean),
+  ].filter((value, index, values) => value && values.indexOf(value) === index);
   const session = {
     sessionId: clean(runtime?.id),
     agentRole: 'primary',
-    models: [clean(runtime?.model)].filter(Boolean),
+    models,
     inputTokens: stats.inputTokens,
     cacheTokens: stats.cachedTokens,
     cacheWriteTokens: stats.cacheWriteTokens,
@@ -554,7 +560,6 @@ export async function runHeadlessExec({
   memoryRuntimeCleanup = stopStandaloneMemoryRuntimesForProcess,
   hasActiveTasks = hasActiveBackgroundTasks,
   installSignalCleanupFn = installProcessSignalCleanup,
-  idlePollMs = 100,
 } = {}) {
   const prompt = clean(message);
   if (!prompt) {
@@ -568,6 +573,7 @@ export async function runHeadlessExec({
   }
 
   const stats = createSessionStats();
+  const observedModels = new Set();
   const lifecycle = json ? createJsonLifecycle({
     write,
     stats,
@@ -589,11 +595,24 @@ export async function runHeadlessExec({
   let resultText = '';
   let executionError = null;
   let code = 1;
+  const taskScopeFor = (session) => ({
+    ...(clean(session?.id) ? { callerSessionId: clean(session.id) } : {}),
+    clientHostPid: session?.clientHostPid,
+  });
   const cleanup = (reason = 'exec-exit') => {
     cleanupPromise ??= (async () => {
       const errors = [];
       try {
-        if (runtime) await runtime.close(reason);
+        // Background jobs the model left running ON PURPOSE (a task's required
+        // server) must outlive this process: reaping them at exit destroys the
+        // very artifact the caller asked for. Detach instead of reap. cli.mjs
+        // exits explicitly, so surviving children cannot hold the process open.
+        if (runtime) {
+          await runtime.close(
+            reason,
+            hasActiveTasks(taskScopeFor(runtime)) ? { keepBackgroundWork: true } : {},
+          );
+        }
       } catch (error) {
         errors.push(error);
       }
@@ -624,6 +643,13 @@ export async function runHeadlessExec({
 
   try {
     boundary = boundaryFactory({ provider, model, effort, fast });
+    // Fire-and-forget search prewarm, matching the long-lived host. Warm both
+    // the resident server and this Project's complete path inventory so the
+    // first normal find/glob does real indexed work instead of paying startup
+    // or a cold tree walk. Non-fatal by construction.
+    if (!/^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_DISABLE_TOOL_PREWARM || '').trim())) {
+      void prewarmHeadlessSearch(cwd).catch(() => {});
+    }
     signalCleanup = installSignalCleanupFn({
       name: 'mixdog-exec',
       timeoutMs: 20_000,
@@ -666,6 +692,8 @@ export async function runHeadlessExec({
     const askOptions = {
       onTextReset: () => true,
       onUsageDelta: (delta) => {
+        const observedModel = clean(delta?.model);
+        if (observedModel) observedModels.add(observedModel);
         applyUsageDelta(stats, delta);
         lifecycle?.onUsageDelta(delta);
       },
@@ -682,17 +710,14 @@ export async function runHeadlessExec({
       } : {}),
     };
     ({ result } = await runtime.ask(prompt, askOptions));
-    const taskScope = {
-      ...(clean(runtime.id) ? { callerSessionId: clean(runtime.id) } : {}),
-      clientHostPid: runtime.clientHostPid,
-    };
-    while (completionPending || hasActiveTasks(taskScope)) {
-      await waitForTrackedTasks({
-        sessionId: runtime.id,
-        clientHostPid: runtime.clientHostPid,
-        hasActiveTasks,
-        pollMs: idlePollMs,
-      });
+    // Exit NEVER waits on running background work. A job the model left
+    // running on purpose (a task's server) has no end, so waiting for it spent
+    // the whole remaining budget on an already-finished turn — 2026-08-23 full
+    // run: two trials, ~85s of real work each, 900s burned. Claude Code and
+    // Codex both leave the moment the turn ends. Completions that ALREADY
+    // arrived still get their follow-up turn below: that is a queued message,
+    // not a wait, so no result the model can act on is dropped.
+    while (completionPending) {
       completionPending = false;
       ({ result } = await runtime.ask('', askOptions));
     }
@@ -716,6 +741,7 @@ export async function runHeadlessExec({
         stats,
         runtime,
         lifecycle?.toolCallCount || 0,
+        observedModels,
       );
     } catch (error) {
       writeErr(`mixdog: usage log write failed: ${error?.message || error}\n`);