mixdog 0.9.166 → 0.9.167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.166",
+  "version": "0.9.167",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/audit-usage-ledger.mjs

@@ -0,0 +1,86 @@
+import assert from 'node:assert/strict';
+import { copyFileSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { DatabaseSync, backup } from 'node:sqlite';
+import { UsageLedger } from '../src/runtime/shared/llm/usage-ledger.mjs';
+import { repairUsageLedger, usageLedgerIntegrity } from '../src/runtime/shared/llm/usage-ledger-repair.mjs';
+import { usageStatsSnapshot } from '../src/standalone/usage-stats-model.mjs';
+
+// Usage: node scripts/audit-usage-ledger.mjs --ledger=<absolute file>
+//        [--reattribute-xai-to-grok] [--apply]
+// Raw files and a consistent SQLite snapshot survive both dry runs and apply.
+const options = process.argv.slice(2);
+const ledgerArg = options.find((arg) => arg.startsWith('--ledger='))?.slice(9);
+if (!ledgerArg || !isAbsolute(ledgerArg) || !/\.sqlite$/i.test(ledgerArg)) {
+    throw new Error('Supply an exact absolute --ledger=<file.sqlite> path');
+}
+for (const arg of options) {
+    if (!arg.startsWith('--ledger=') && !['--reattribute-xai-to-grok', '--apply'].includes(arg)) {
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+}
+const source = resolve(ledgerArg);
+const auditRoot = join(dirname(source), 'audits');
+mkdirSync(auditRoot, { recursive: true });
+const workspace = mkdtempSync(join(auditRoot, 'usage-'));
+const raw = join(workspace, 'original-files');
+mkdirSync(raw);
+for (const suffix of ['', '-wal', '-shm']) {
+    try { copyFileSync(source + suffix, join(raw, basename(source) + suffix)); }
+    catch (error) { if (!suffix || error.code !== 'ENOENT') throw error; }
+}
+const snapshotPath = join(workspace, 'backup.sqlite');
+const original = new DatabaseSync(source, { readOnly: true });
+try { await backup(original, snapshotPath); } finally { original.close(); }
+const workingPath = join(workspace, 'working.sqlite');
+copyFileSync(snapshotPath, workingPath);
+const throughTs = Date.now();
+const providerOverrides = options.includes('--reattribute-xai-to-grok') ? { xai: 'grok-oauth' } : {};
+const summarize = (ledger) => {
+    const stats = usageStatsSnapshot({ rollup: ledger.rollup(), now: throughTs, source: 'all' });
+    const sum = (rows, key) => rows.reduce((n, row) => n + Number(row[key] || 0), 0);
+    for (const key of ['turns', 'input', 'output', 'cacheRead', 'cacheWrite', 'costKnownTurns']) {
+        assert.equal(sum(stats.providers, key), stats.totals[key], `provider sum: ${key}`);
+    }
+    for (const rows of [stats.providers, stats.daily]) {
+        assert.ok(Math.abs(sum(rows, 'costUsd') - stats.totals.costUsd) <= rows.length * 0.000001 + 0.000001, 'cost sum');
+        assert.equal(sum(rows, 'tokens'), stats.totals.tokens, 'token sum');
+        assert.equal(sum(rows, 'turns'), stats.totals.turns, 'record sum');
+    }
+    assert.ok(Math.abs(stats.totals.costBilled + stats.totals.costEstimated - stats.totals.costUsd) < 0.000002, 'cost categories');
+    assert.ok(stats.totals.costKnownTurns <= stats.totals.turns, 'price coverage');
+    for (const p of stats.providers) {
+        assert.equal(sum(p.models, 'turns'), p.turns, `model sum: ${p.provider}`);
+    }
+    return {
+        integrity: usageLedgerIntegrity(ledger.db), totals: stats.totals,
+        providers: stats.providers.map(({ provider, providerKind, turns, tokens, costUsd, costUnpricedTurns }) =>
+            ({ provider, providerKind, turns, tokens, costUsd, costUnpricedTurns })),
+    };
+};
+const working = new UsageLedger(workingPath);
+let before, preview, after;
+try {
+    assert.deepEqual(working.db.prepare('PRAGMA quick_check').all().map((r) => r.quick_check), ['ok']);
+    before = summarize(working);
+    preview = repairUsageLedger(working, { throughTs, providerOverrides });
+    after = summarize(working);
+    assert.deepEqual(before.integrity, after.integrity);
+} finally { working.close(); }
+const report = { source, workspace, backup: snapshotPath, throughTs, providerOverrides, before, preview, after, applied: false };
+writeFileSync(join(workspace, 'report.json'), JSON.stringify(report, null, 2));
+if (options.includes('--apply')) {
+    const live = new UsageLedger(source);
+    try {
+        // The transaction repairs only the bounded history. Concurrent new
+        // requests are retained and indexed too; no database file is replaced.
+        report.appliedRepair = repairUsageLedger(live, { throughTs, providerOverrides });
+        report.live = summarize(live);
+        assert.deepEqual(live.db.prepare('PRAGMA quick_check').all().map((r) => r.quick_check), ['ok']);
+        report.applied = true;
+    } finally { live.close(); }
+    writeFileSync(join(workspace, 'report.json'), JSON.stringify(report, null, 2));
+}
+console.log(JSON.stringify({ workspace, backup: snapshotPath, applied: report.applied,
+    preview, ...(report.appliedRepair ? { appliedRepair: report.appliedRepair } : {}),
+    totals: (report.live || after).totals, providers: (report.live || after).providers }, null, 2));

package/scripts/generate-voice-runtime-manifest.mjs

@@ -82,6 +82,24 @@ export function compareSemver(left, right) {
   return 0
 }
 
+export function isHiddenDraftReleaseUrl(sourceUrl, { repository, asset }) {
+  try {
+    const parsed = new URL(sourceUrl)
+    const prefix = `/${repository}/releases/download/`
+    const parts = parsed.pathname.startsWith(prefix)
+      ? parsed.pathname.slice(prefix.length).split('/')
+      : []
+    return parsed.origin === 'https://github.com'
+      && !parsed.search
+      && !parsed.hash
+      && parts.length === 2
+      && parts[0].startsWith('untagged-')
+      && parts[1] === asset
+  } catch {
+    return false
+  }
+}
+
 export function buildVoiceRuntimePlatforms(
   releaseAssets,
   { repository = 'tribgames/mixdog', tag = VOICE_RUNTIME_TAG } = {},
@@ -103,23 +121,10 @@ export function buildVoiceRuntimePlatforms(
     }
     const sourceUrl = String(asset.browser_download_url || '')
     const url = `https://github.com/${repository}/releases/download/${tag}/${spec.asset}`
-    let validDraftUrl = false
-    try {
-      const parsed = new URL(sourceUrl)
-      const prefix = `/${repository}/releases/download/`
-      const parts = parsed.pathname.startsWith(prefix)
-        ? parsed.pathname.slice(prefix.length).split('/')
-        : []
-      validDraftUrl = parsed.origin === 'https://github.com'
-        && !parsed.search
-        && !parsed.hash
-        && parts.length === 2
-        && parts[0].startsWith('untagged-')
-        && parts[1] === spec.asset
-    } catch {
-      validDraftUrl = false
-    }
-    if (sourceUrl !== url && !validDraftUrl) {
+    if (sourceUrl !== url && !isHiddenDraftReleaseUrl(sourceUrl, {
+      repository,
+      asset: spec.asset,
+    })) {
       throw new Error(`release asset ${spec.asset} has invalid download URL`)
     }
     platforms[spec.key] = {

package/scripts/memory-chunk-quality.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// Audit/simulate on a separate snapshot. This command NEVER updates the
+// live DB, starts PG, migrates a schema or replaces the supplied input file.
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parseArgs } from 'node:util'
+import { auditChunkEntries, collectChunkRoots } from '../src/runtime/memory/lib/memory-chunk-audit.mjs'
+import {
+  generateCycle1Chunks,
+} from '../src/runtime/memory/lib/memory-chunk-quality.mjs'
+import { compactHandoffRows } from '../src/runtime/memory/lib/compact-handoff.mjs'
+import { renderEntryLines } from '../src/runtime/memory/lib/recall-format.mjs'
+import { readServiceAdvert } from '../src/runtime/shared/service-discovery.mjs'
+
+const { values } = parseArgs({
+  options: {
+    input: { type: 'string' },
+    'simulate-limit': { type: 'string', default: '0' },
+  },
+})
+const simulationLimit = Number(values['simulate-limit'])
+if (!Number.isSafeInteger(simulationLimit) || simulationLimit < 0) throw new Error('simulate-limit must be a nonnegative integer')
+const directory = await mkdtemp(join(tmpdir(), 'mixdog-chunk-quality-'))
+console.log(`Artifacts: ${directory}`)
+let snapshot
+if (values.input) {
+  snapshot = JSON.parse(await readFile(values.input, 'utf8'))
+} else {
+  const advert = readServiceAdvert('pg')
+  if (!Number.isInteger(Number(advert?.pg_port)) || Number(advert.pg_port) < 1) throw new Error('No advertised PG port; live audit blocked')
+  const { default: pg } = await import('pg')
+  const client = new pg.Client({
+    host: '127.0.0.1', port: Number(advert.pg_port), user: 'postgres',
+    database: 'mixdog', password: '', connectionTimeoutMillis: 10000,
+  })
+  await client.connect()
+  try {
+    await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
+    const { rows } = await client.query(`
+      SELECT id, ts, role, content, source_ref, session_id, source_turn, time_source,
+             project_id, chunk_root, is_root, element, category, summary, status, error_count,
+             to_jsonb(e)->'chunk_quality' AS chunk_quality
+      FROM memory.entries e ORDER BY id`)
+    snapshot = { capturedAt: new Date().toISOString(), entries: rows }
+    await client.query('COMMIT')
+  } catch (error) {
+    await client.query('ROLLBACK')
+    throw error
+  } finally {
+    await client.end()
+  }
+}
+assert.ok(Array.isArray(snapshot.entries), 'snapshot.entries must be an array')
+const sourceBytes = JSON.stringify(snapshot)
+const sourceHash = createHash('sha256').update(sourceBytes).digest('hex')
+await writeFile(join(directory, 'snapshot.json'), sourceBytes, { flag: 'wx' })
+const working = structuredClone(snapshot)
+const before = auditChunkEntries(snapshot.entries)
+const outcomes = []
+let blocked = false
+const renderOptions = { chronologicalOrder: true, compactTimestamps: true, pendingMarks: false, maxBodyChars: null }
+function assertCoverage(projection, expectedRows) {
+  const represented = new Set()
+  for (const row of projection) {
+    const ids = row._compactBody ? row._compactMemberIds : [String(row.id)]
+    for (const id of ids) {
+      assert.equal(represented.has(String(id)), false, `duplicate projected source ${id}`)
+      represented.add(String(id))
+    }
+  }
+  assert.deepEqual([...represented].sort(), expectedRows.map(entry => String(entry.id)).sort())
+  return represented.size
+}
+if (simulationLimit) {
+  const { callAgentDispatch } = await import('../src/runtime/memory/lib/agent-ipc.mjs')
+  const { resolveMaintenancePreset } = await import('../src/runtime/shared/llm/index.mjs')
+  const options = {
+    callLlm: callAgentDispatch,
+    request: { agent: 'cycle1-agent', taskType: 'maintenance', preset: resolveMaintenancePreset('memory'), timeout: 180000, cwd: null },
+  }
+  for (const root of collectChunkRoots(working.entries).slice(0, simulationLimit)) {
+    const generated = await generateCycle1Chunks(root.members, options)
+    const rawIds = new Set(generated.rawRowIds.map(String))
+    const projected = compactHandoffRows([
+      ...generated.chunks.map(chunk => ({
+        ...chunk.members[0], is_root: 1, members: chunk.members,
+        summary: chunk.summary, element: chunk.element, chunk_quality: chunk.quality,
+      })),
+      ...root.members.filter(member => rawIds.has(String(member.id))).map(member => ({ ...member, is_root: 0 })),
+    ])
+    const outcome = {
+      id: root.id, inputRows: root.members.length,
+      stats: generated.stats, chunks: generated.chunks.length, rawRowIds: generated.rawRowIds,
+      errors: generated.invalidChunks, projectionCoverage: assertCoverage(projected, root.members),
+      text: renderEntryLines(projected, renderOptions),
+    }
+    if (generated.invalidChunks.some(invalid => invalid.reason === 'llm_error')) blocked = true
+    outcomes.push(outcome)
+    if (blocked) break
+  }
+}
+// Independent integrity checks: the source snapshot is unchanged; no source
+// identity, content, chronology, membership or status is rewritten in the copy.
+assert.equal(createHash('sha256').update(JSON.stringify(snapshot)).digest('hex'), sourceHash)
+assert.deepEqual(working.entries.map(({ id, content, ts, role, chunk_root, status }) => [id, content, ts, role, chunk_root, status]),
+  snapshot.entries.map(({ id, content, ts, role, chunk_root, status }) => [id, content, ts, role, chunk_root, status]))
+const after = auditChunkEntries(working.entries)
+const roots = collectChunkRoots(working.entries)
+const rootIds = new Set(roots.map(root => String(root.id)))
+const standalone = working.entries.filter(entry => !rootIds.has(String(entry.chunk_root)))
+const projection = compactHandoffRows([...roots, ...standalone])
+const projectionCoverage = assertCoverage(projection, working.entries)
+const report = {
+  capturedAt: snapshot.capturedAt, sourceHash, before, after, outcomes, blocked,
+  integrity: { sourceUnchanged: true, sourceRowsUnchanged: true, projectionCoverage },
+}
+working.simulations = outcomes
+await writeFile(join(directory, 'working.json'), JSON.stringify(working), { flag: 'wx' })
+await writeFile(join(directory, 'report.json'), JSON.stringify(report, null, 2), { flag: 'wx' })
+console.log(JSON.stringify({
+  directory, audit: { ...before, chunks: undefined },
+  outcomes: outcomes.map(outcome => ({ ...outcome, text: undefined })),
+  integrity: report.integrity, blocked,
+}, null, 2))
+if (blocked) process.exitCode = 1

package/scripts/memory-layer2-check.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// Real-AI second-layer simulation on immutable, prepared first-layer cases.
+// Input: { cases: [{ name, rows: [{id,ts,role,session_id,content,sourceIds}],
+//                   preservedRawIds?, reviewCriteria? }] }.
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parseArgs } from 'node:util'
+import { generateCycle1Chunks } from '../src/runtime/memory/lib/memory-chunk-quality.mjs'
+import { estimateTokens } from '../src/runtime/agent/orchestrator/session/token-estimate.mjs'
+import { makeAgentDispatch } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs'
+import { loadConfig } from '../src/runtime/agent/orchestrator/config.mjs'
+import { resolveMaintenanceRoute } from '../src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs'
+import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs'
+import { loadScopedRoleInstructions } from '../src/runtime/agent/orchestrator/context/collect.mjs'
+import { resolveMaintenancePreset } from '../src/runtime/shared/llm/index.mjs'
+
+const { values } = parseArgs({ options: {
+  input: { type: 'string' }, case: { type: 'string', multiple: true },
+} })
+if (!values.input) throw new Error('--input must name a prepared first-layer case file')
+const bytes = await readFile(values.input, 'utf8')
+const sourceHash = createHash('sha256').update(bytes).digest('hex')
+const source = JSON.parse(bytes)
+assert.ok(Array.isArray(source.cases) && source.cases.length, 'cases must be nonempty')
+const selectedCases = values.case ? new Set(values.case) : null
+if (selectedCases) {
+  for (const name of selectedCases) assert.ok(source.cases.some(item => item.name === name), `unknown case: ${name}`)
+}
+const directory = await mkdtemp(join(tmpdir(), 'mixdog-layer2-once-'))
+await writeFile(join(directory, 'input.json'), bytes, { flag: 'wx' })
+await writeFile(join(directory, 'working.json'), bytes, { flag: 'wx' })
+console.log(`Artifacts: ${directory}`)
+const working = structuredClone(source)
+const config = loadConfig()
+const configuredRoute = resolveMaintenancePreset('memory')
+  || resolveMaintenanceRoute({ agent: 'cycle1-agent', config })
+const preset = typeof configuredRoute === 'object' ? configuredRoute
+  : config.presets.find(item => item.id === configuredRoute || item.name === configuredRoute)
+assert.ok(preset?.provider && preset?.model, 'second-layer model route is unresolved')
+const request = {
+  agent: 'cycle1-agent', taskType: 'maintenance', preset: { ...preset, effort: 'low' },
+  timeout: 180000, cwd: null,
+}
+// The installed broker can carry an older, first-layer-only system policy.
+// A source-code benchmark must use the worktree's actual scoped role rules,
+// not a new user prompt under that incompatible old system instruction.
+const roleInstructions = loadScopedRoleInstructions(request.agent, request.preset?.provider)
+assert.ok(roleInstructions.includes('SECOND_LAYER'), 'source runtime did not load the second-layer role policy')
+const rolePolicyHash = createHash('sha256').update(roleInstructions).digest('hex')
+await initProviders(config.providers)
+const dispatch = makeAgentDispatch({
+  agent: request.agent, taskType: request.taskType, preset: request.preset,
+  cwd: null, brief: false, config,
+})
+const outcomes = []
+let blocked = false
+for (const item of working.cases) {
+  if (selectedCases && !selectedCases.has(item.name)) continue
+  if (blocked) {
+    outcomes.push({ name: item.name, status: 'not_run_after_provider_failure' })
+    continue
+  }
+  const original = JSON.stringify(item)
+  const inputText = item.rows.map(row => row.content).join('\n')
+  const inputTokens = estimateTokens(inputText)
+  assert.ok(inputTokens >= 2)
+  assert.equal(new Set(item.rows.map(row => String(row.id))).size, item.rows.length)
+  assert.equal(new Set(item.rows.map(row => row.session_id)).size, 1)
+  const calls = []
+  const result = await generateCycle1Chunks(item.rows, {
+    // Prepared cases have no measured live-context budget. Report the writing
+    // target separately instead of inventing a hard half-size context limit.
+    layer: 2,
+    request,
+    callLlm: async (options, prompt) => {
+      const response = await dispatch({
+        prompt, preset: options.preset, cwd: null, parentSignal: options.signal,
+        idleTimeoutMs: options.timeout,
+      })
+      calls.push({ mode: options.mode, response })
+      return response
+    },
+  })
+  assert.equal(JSON.stringify(item), original, 'source input mutated')
+  assert.ok(result)
+  assert.ok(result.stats.groupingCalls <= 1, 'second layer must not make multiple AI calls')
+  const fallback = new Set(result.rawRowIds.map(String))
+  const units = [
+    ...result.chunks.map(chunk => ({
+      position: Math.min(...chunk._idxList) - 1, text: chunk.summary,
+      parentIds: chunk.members.map(row => String(row.id)),
+    })),
+    ...item.rows.flatMap((row, position) => fallback.has(String(row.id))
+      ? [{ position, text: row.content, parentIds: [String(row.id)] }] : []),
+  ].sort((a, b) => a.position - b.position)
+  const parentIds = units.flatMap(unit => unit.parentIds)
+  assert.equal(new Set(parentIds).size, parentIds.length)
+  assert.deepEqual(parentIds.slice().sort(), item.rows.map(row => String(row.id)).sort())
+  const text = units.map(unit => unit.text).join('\n')
+  const outputTokens = estimateTokens(text)
+  if (result.compression.used) assert.ok(outputTokens < inputTokens)
+  const sourceIds = item.rows.flatMap(row => row.sourceIds || [String(row.id)])
+  assert.equal(new Set(sourceIds).size, sourceIds.length)
+  assert.equal(result.stats.verificationCalls, 0)
+  assert.equal(result.stats.retries, 0)
+  outcomes.push({
+    name: item.name, applied: result.compression.used, targetMet: result.compression.targetMet,
+    inputChunks: item.rows.length, outputChunks: result.chunks.length, fallbackChunks: fallback.size,
+    inputTokens, outputTokens, reductionPercent: 100 * (inputTokens - outputTokens) / inputTokens,
+    stats: result.stats, compression: result.compression, errors: result.invalidChunks,
+    parentCoverage: parentIds.length, sourceRowCoverage: sourceIds.length,
+    preservedRawIds: item.preservedRawIds || [], reviewCriteria: item.reviewCriteria || [],
+    text, calls,
+  })
+  if (result.invalidChunks.some(error => error.reason === 'llm_error')) blocked = true
+}
+assert.equal(createHash('sha256').update(await readFile(values.input, 'utf8')).digest('hex'), sourceHash)
+assert.deepEqual(working, source)
+const report = {
+  sourceHash, sourceUnchanged: true, runtime: 'source', route: request.preset, rolePolicyHash, outcomes, blocked,
+  allSizeTargetsMet: outcomes.length > 0 && outcomes.every(outcome => outcome.targetMet === true),
+  scope: 'Single-call lossy second-layer compression with a soft half-size writing target. Reports time and approximate savings, not semantic equivalence. No AI verification, quality rejection, retry, live DB update or automatic compaction deployment.',
+}
+await writeFile(join(directory, 'report.json'), JSON.stringify(report, null, 2), { flag: 'wx' })
+console.log(JSON.stringify({
+  directory, sourceUnchanged: report.sourceUnchanged, route: report.route,
+  allSizeTargetsMet: report.allSizeTargetsMet, blocked,
+  outcomes: outcomes.map(({ calls, reviewCriteria, ...outcome }) => outcome),
+}, null, 2))
+process.exitCode = blocked ? 1 : 0

package/scripts/model-catalog-audit.mjs

@@ -4,6 +4,7 @@ import { initProviders, getAllProviders } from '../src/runtime/agent/orchestrato
 import {
   loadModelsDevCatalog,
   warmModelMetadataCatalogs,
+  auditModelPricing,
 } from '../src/runtime/agent/orchestrator/providers/model-catalog.mjs';
 import { QUICK_WEB_SEARCH_MODELS } from '../src/session-runtime/quick-web-search-models.mjs';
 
@@ -151,6 +152,7 @@ for (const [name, provider] of getAllProviders()) {
     error: listed.error,
     count: listed.models.length,
     rows,
+    pricing: auditModelPricing(listed.models, name),
   });
 }
 
@@ -178,6 +180,7 @@ const report = {
   generatedAt: new Date().toISOString(),
   enabledProviders: Object.entries(cfg.providers || {}).filter(([, v]) => v?.enabled).map(([k]) => k),
   providerResults,
+  unpricedRoutes: providerResults.flatMap((p) => p.pricing.filter((row) => !row.priced)),
   mismatches,
   exactOneM,
   nearOneM,
@@ -198,6 +201,9 @@ if (json) {
       ].filter(Boolean).join('; ');
       console.log(`  ${r.id}: ${r.liveContextLabel} ctx, out=${r.liveOutput ?? '-'}${flags ? `  [${flags}]` : ''}`);
     }
+    for (const row of p.pricing.filter((r) => !r.priced)) {
+      console.log(`  UNPRICED ${row.model} -> ${row.pricingProvider}/${row.pricingModel}: ${row.missingRates.join(', ')}`);
+    }
   }
   console.log(`\nsummary: mismatches=${mismatches.length}, exact1M=${exactOneM.length}, near1MNotExact=${nearOneM.length}, staticContextRows=${quickRows.length}`);
   if (mismatches.length) {

package/scripts/native-tool-download.mjs

@@ -27,6 +27,13 @@ const RELEASE_ROOT = 'https://github.com/tribgames/mixdog/releases/download'
 const TOOLS_DIR = new URL('../src/runtime/agent/orchestrator/tools/', import.meta.url)
 
 export const NATIVE_TOOL_KINDS = Object.freeze(['graph', 'patch', 'spawn'])
+export const NATIVE_TOOL_PLATFORM_KEYS = Object.freeze([
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'win32-x64',
+])
 
 /** Released asset name. */
 export function nativeToolAssetName(kind, target) {
@@ -43,6 +50,13 @@ export function nativeToolInstalledName(kind, target) {
   return target.platform === 'win32' ? `mixdog-${kind}.exe` : `mixdog-${kind}`
 }
 
+export function nativeToolPlatformAssets(kind) {
+  return Object.fromEntries(NATIVE_TOOL_PLATFORM_KEYS.map((key) => {
+    const [platform, arch] = key.split('-')
+    return [key, nativeToolAssetName(kind, { platform, arch })]
+  }))
+}
+
 async function sha256File(path) {
   return createHash('sha256').update(await readFile(path)).digest('hex')
 }

package/scripts/prepare-native-assets.mjs

@@ -18,16 +18,11 @@ import {
 import { ensureGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
 import { ensurePatchBinary } from '../src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs';
 import { ensureSpawnBinary } from '../src/runtime/agent/orchestrator/tools/spawn-binary-fetcher.mjs';
+import { NATIVE_TOOL_PLATFORM_KEYS } from './native-tool-download.mjs';
 
 const DEFAULT_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
-export const NATIVE_ASSET_PLATFORMS = Object.freeze([
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-x64',
-  'win32-x64',
-]);
+export const NATIVE_ASSET_PLATFORMS = NATIVE_TOOL_PLATFORM_KEYS;
 
 export const REQUIRED_NATIVE_INSTALLERS = Object.freeze({
   graph: ensureGraphBinary,

package/scripts/tool-failures.mjs

@@ -104,8 +104,13 @@ function normalizeRowCategory(row) {
   let category = storedCategory;
   if (isKnownTestFixture(row)) {
     category = 'expected-test';
-  } else if (rowTool(row) === 'apply_patch') {
-    const derived = classifyToolFailure(rowErrorText(row), 'apply_patch');
+  } else {
+    const derived = classifyToolFailure(rowErrorText(row), rowTool(row));
+    // The shell classifier's generic command-exit fallback cannot recover
+    // execution metadata from a short historical preview such as "SIGKILL".
+    // Keep recorded signals, timeouts and capture failures instead of hiding
+    // them among ordinary command exits.
+    if (derived === 'command-exit' && storedCategory !== 'command-exit') return row;
     // Failure previews are bounded and may end before the nested cause. Never
     // downgrade a stored specific category to the generic fallback merely
     // because the historical preview lacks that tail.