atris 3.47.0 → 3.48.0

package/scripts/det/changelog.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// det/changelog.js — build a grouped changelog from Conventional-Commits history.
+// Replaces the "summarize what changed since the last release" ask: the sections,
+// order, and bullets come straight from the commit subjects, so the changelog is
+// exact and reproducible, not an LLM paraphrase that drops or invents entries.
+//
+// Usage:
+//   node changelog.js                 # since the last tag (or root) -> markdown
+//   node changelog.js v3.34.0         # since a specific ref
+//   node changelog.js v3.34.0 HEAD    # explicit range
+//   node changelog.js --json          # structured {sections,counts,...}
+//
+// Reads `git log` itself; no stdin needed. The pure core build(commits) is
+// exported and unit-tested.
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// --- pure core (no git, no process) ---------------------------------------
+
+// Conventional-Commits types -> human section heading, in display order.
+const SECTIONS = [
+  ['feat', 'Features'],
+  ['fix', 'Fixes'],
+  ['perf', 'Performance'],
+  ['refactor', 'Refactors'],
+  ['docs', 'Docs'],
+  ['test', 'Tests'],
+  ['build', 'Build'],
+  ['ci', 'CI'],
+  ['chore', 'Chores'],
+  ['other', 'Other'],
+];
+const KNOWN = new Set(SECTIONS.map((s) => s[0]));
+
+// "feat(scope): subject" or "fix: subject" -> { type, scope, subject }.
+// Anything that doesn't match the header grammar lands in the "other" bucket
+// with the whole line as the subject, so nothing is silently dropped.
+function parseSubject(line) {
+  const m = /^(\w+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/.exec(line.trim());
+  if (!m) return { type: 'other', scope: '', breaking: false, subject: line.trim() };
+  const type = KNOWN.has(m[1]) ? m[1] : 'other';
+  return { type, scope: m[2] || '', breaking: Boolean(m[3]), subject: m[4].trim() };
+}
+
+// commits: [{ hash, subject }] -> { sections, counts, breaking, total }
+function build(commits) {
+  if (!Array.isArray(commits)) return { error: 'commits must be an array' };
+  const buckets = {};
+  const breaking = [];
+  for (const c of commits) {
+    const p = parseSubject(c.subject || '');
+    const entry = { hash: c.hash || '', scope: p.scope, subject: p.subject };
+    (buckets[p.type] = buckets[p.type] || []).push(entry);
+    if (p.breaking) breaking.push(entry);
+  }
+  const sections = [];
+  const counts = {};
+  for (const [type, title] of SECTIONS) {
+    const items = buckets[type];
+    if (items && items.length) {
+      sections.push({ type, title, items });
+      counts[type] = items.length;
+    }
+  }
+  return { sections, counts, breaking, total: commits.length };
+}
+
+// one bullet: "- subject (scope) [hash]" with the optional bits omitted cleanly.
+function fmtItem(it) {
+  const scope = it.scope ? ` (${it.scope})` : '';
+  const hash = it.hash ? ` [${it.hash}]` : '';
+  return `- ${it.subject}${scope}${hash}`;
+}
+
+function render(res) {
+  const lines = [];
+  if (res.breaking.length) {
+    lines.push('### ⚠ BREAKING CHANGES');
+    for (const it of res.breaking) lines.push(fmtItem(it));
+    lines.push('');
+  }
+  for (const s of res.sections) {
+    lines.push(`### ${s.title}`);
+    for (const it of s.items) lines.push(fmtItem(it));
+    lines.push('');
+  }
+  if (!lines.length) return 'No changes.';
+  return lines.join('\n').trimEnd();
+}
+
+// --- git plumbing (impure, only in main) ----------------------------------
+
+function lastTag() {
+  try {
+    return execFileSync('git', ['describe', '--tags', '--abbrev=0'], {
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return ''; // no tags yet -> changelog from the root commit
+  }
+}
+
+// range like "v3.34.0..HEAD" (or just "HEAD" when there's no start ref).
+function readCommits(range) {
+  const out = execFileSync('git', ['log', '--no-merges', '--pretty=%h%x09%s', range], {
+    encoding: 'utf8',
+  });
+  const commits = [];
+  for (const line of out.split('\n')) {
+    if (!line.trim()) continue;
+    const tab = line.indexOf('\t');
+    commits.push({ hash: line.slice(0, tab), subject: line.slice(tab + 1) });
+  }
+  return commits;
+}
+
+function main() {
+  const args = process.argv.slice(2).filter((a) => a !== '--json');
+  const wantJson = process.argv.includes('--json');
+  const start = args[0] || lastTag();
+  const end = args[1] || 'HEAD';
+  const range = start ? `${start}..${end}` : end;
+  let commits;
+  try {
+    commits = readCommits(range);
+  } catch (e) {
+    process.stderr.write(`git failed: ${e.message}\n`);
+    process.exit(2);
+  }
+  const res = build(commits);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (wantJson) {
+    process.stdout.write(JSON.stringify({ range, ...res }, null, 2) + '\n');
+  } else {
+    process.stdout.write(render(res) + '\n');
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { build, parseSubject, render, SECTIONS };

package/scripts/det/codex-watchdog.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawn, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const DEFAULT_STARTUP_DEADLINE_SECONDS = 90;
+const DEFAULT_MAX_RUNTIME_SECONDS = 3600;
+const USAGE = 'usage: node scripts/det/codex-watchdog.js ' +
+  '[--startup-deadline <sec, default 90>] [--max-runtime <sec, default 3600>] ' +
+  '[--receipt <path>] -- <command...>';
+
+function positiveSeconds(value, flag) {
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error(`${flag} must be a positive number`);
+  }
+  return seconds;
+}
+
+function parseArgs(argv) {
+  let startupDeadlineSeconds = DEFAULT_STARTUP_DEADLINE_SECONDS;
+  let maxRuntimeSeconds = DEFAULT_MAX_RUNTIME_SECONDS;
+  let receiptPath = '';
+  let index = 0;
+
+  while (index < argv.length && argv[index] !== '--') {
+    const flag = argv[index];
+    if (flag !== '--startup-deadline' && flag !== '--max-runtime' && flag !== '--receipt') {
+      throw new Error(`unknown option: ${flag}`);
+    }
+    if (index + 1 >= argv.length || argv[index + 1] === '--') {
+      throw new Error(`${flag} needs a value`);
+    }
+    if (flag === '--startup-deadline') {
+      startupDeadlineSeconds = positiveSeconds(argv[index + 1], flag);
+    } else if (flag === '--max-runtime') {
+      maxRuntimeSeconds = positiveSeconds(argv[index + 1], flag);
+    } else {
+      receiptPath = argv[index + 1];
+    }
+    index += 2;
+  }
+
+  if (argv[index] !== '--' || index + 1 >= argv.length) {
+    throw new Error('missing command after --');
+  }
+
+  return {
+    startupDeadlineSeconds,
+    maxRuntimeSeconds,
+    receiptPath,
+    command: argv[index + 1],
+    commandArgs: argv.slice(index + 2),
+  };
+}
+
+function writeTimeoutReceipt(config, exitCode, startedAt) {
+  if (!config.receiptPath || (exitCode !== 124 && exitCode !== 125)) return;
+  const receiptPath = path.resolve(config.receiptPath);
+  const dir = path.dirname(receiptPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const groupResult = spawnSync('ps', ['-o', 'pgid=', '-p', String(process.pid)], { encoding: 'utf8' });
+  const parsedGroup = groupResult.status === 0 ? Number(String(groupResult.stdout || '').trim()) : null;
+  const receipt = {
+    schema: 'atris.codex_watchdog_receipt.v1',
+    status: 'timed_out',
+    reason: exitCode === 124 ? 'silent_start' : 'max_runtime',
+    exit_code: exitCode,
+    pid: process.pid,
+    pgid: Number.isInteger(parsedGroup) && parsedGroup > 0 ? parsedGroup : null,
+    started_at: startedAt,
+    finished_at: new Date().toISOString(),
+  };
+  const tmpPath = path.join(dir, `.${path.basename(receiptPath)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmpPath, `${JSON.stringify(receipt, null, 2)}\n`);
+    fs.renameSync(tmpPath, receiptPath);
+  } finally {
+    try { fs.unlinkSync(tmpPath); } catch {}
+  }
+}
+
+function killProcessGroup(child) {
+  if (!child.pid) return;
+  try {
+    process.kill(-child.pid, 'SIGKILL');
+  } catch (error) {
+    if (error.code === 'ESRCH') return;
+    try {
+      child.kill('SIGKILL');
+    } catch {}
+  }
+}
+
+function runAttempt(config, remainingRuntimeMs) {
+  return new Promise((resolve) => {
+    let nullFd;
+    let child;
+    try {
+      nullFd = fs.openSync('/dev/null', 'r');
+      child = spawn(config.command, config.commandArgs, {
+        detached: true,
+        stdio: [nullFd, 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      if (nullFd !== undefined) fs.closeSync(nullFd);
+      resolve({ type: 'spawn-error', error });
+      return;
+    }
+    fs.closeSync(nullFd);
+
+    let sawOutput = false;
+    let stopReason = null;
+    let spawnError = null;
+
+    const markStarted = () => {
+      sawOutput = true;
+    };
+    child.stdout.once('data', markStarted);
+    child.stderr.once('data', markStarted);
+    child.stdout.pipe(process.stdout, { end: false });
+    child.stderr.pipe(process.stderr, { end: false });
+
+    const stop = (reason) => {
+      if (stopReason) return;
+      stopReason = reason;
+      killProcessGroup(child);
+    };
+
+    const startupTimer = setTimeout(() => {
+      if (!sawOutput) stop('silent-start');
+    }, Math.ceil(config.startupDeadlineSeconds * 1000));
+    const runtimeTimer = setTimeout(() => {
+      stop('max-runtime');
+    }, remainingRuntimeMs);
+
+    child.once('error', (error) => {
+      spawnError = error;
+      if (!stopReason) stopReason = 'spawn-error';
+    });
+    child.once('close', (code, signal) => {
+      clearTimeout(startupTimer);
+      clearTimeout(runtimeTimer);
+      if (spawnError) {
+        resolve({ type: 'spawn-error', error: spawnError });
+      } else if (stopReason) {
+        resolve({ type: stopReason });
+      } else {
+        resolve({ type: 'exit', code, signal });
+      }
+    });
+  });
+}
+
+async function run(config) {
+  const startedAt = Date.now();
+  const maxRuntimeMs = Math.ceil(config.maxRuntimeSeconds * 1000);
+
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const remainingRuntimeMs = maxRuntimeMs - (Date.now() - startedAt);
+    if (remainingRuntimeMs <= 0) {
+      process.stderr.write(`watchdog: max runtime of ${config.maxRuntimeSeconds}s exceeded\n`);
+      return 125;
+    }
+
+    const result = await runAttempt(config, remainingRuntimeMs);
+    if (result.type === 'silent-start') {
+      if (attempt === 1) {
+        process.stderr.write(
+          `watchdog: silent start after ${config.startupDeadlineSeconds}s, retrying once\n`
+        );
+        continue;
+      }
+      process.stderr.write('watchdog: silent start twice, giving up\n');
+      return 124;
+    }
+    if (result.type === 'max-runtime') {
+      process.stderr.write(`watchdog: max runtime of ${config.maxRuntimeSeconds}s exceeded\n`);
+      return 125;
+    }
+    if (result.type === 'spawn-error') {
+      process.stderr.write(`watchdog: could not start command: ${result.error.message}\n`);
+      return 127;
+    }
+    if (result.code !== null) return result.code;
+    if (result.signal) {
+      process.kill(process.pid, result.signal);
+      return 1;
+    }
+    return 1;
+  }
+
+  return 124;
+}
+
+async function main() {
+  const startedAt = new Date().toISOString();
+  let config;
+  try {
+    config = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`watchdog: ${error.message}\n${USAGE}\n`);
+    process.exitCode = 2;
+    return;
+  }
+  process.exitCode = await run(config);
+  try {
+    writeTimeoutReceipt(config, process.exitCode, startedAt);
+  } catch (error) {
+    process.stderr.write(`watchdog: could not write timeout receipt: ${error.message}\n`);
+  }
+}
+
+main();

package/scripts/det/commit-msg.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+// det/commit-msg.js — draft a Conventional-Commits message from the STAGED diff.
+// Replaces the "write me a commit message" ask: the type/scope come from the
+// file paths and the body from the diff stats, so it is exact and reproducible,
+// not an LLM guess about intent.
+//
+// Usage:
+//   git add -A && node commit-msg.js          # print the drafted message
+//   node commit-msg.js --json                 # structured {type,scope,subject,body,...}
+//
+// Reads `git diff --cached` itself; no stdin needed. Exit 2 if nothing staged.
+// The pure core draft(files) is exported and unit-tested.
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// --- pure core (no git, no process) ---------------------------------------
+
+const VERB = { A: 'add', M: 'update', D: 'remove', R: 'rename', C: 'copy' };
+
+function isMd(p) {
+  return /\.md$/i.test(p);
+}
+function isTest(p) {
+  return /(^|\/)tests?\//.test(p) || /\.test\.[jt]s$/.test(p);
+}
+function isChore(p) {
+  return (
+    /^(scripts|\.github)\//.test(p) ||
+    /(^|\/)(package(-lock)?\.json|\.eslintrc.*|\.gitignore|\.npmignore)$/.test(p) ||
+    /\.ya?ml$/.test(p)
+  );
+}
+
+// scope = basename of the deepest directory common to every changed file.
+function commonDirScope(paths) {
+  if (paths.length === 0) return '';
+  const dirSegs = paths.map((p) => p.split('/').slice(0, -1));
+  let common = dirSegs[0];
+  for (const segs of dirSegs.slice(1)) {
+    let i = 0;
+    while (i < common.length && i < segs.length && common[i] === segs[i]) i += 1;
+    common = common.slice(0, i);
+  }
+  return common.length ? common[common.length - 1] : '';
+}
+
+function pickType(files) {
+  const paths = files.map((f) => f.path);
+  if (paths.every(isMd)) return 'docs';
+  if (paths.every(isTest)) return 'test';
+  if (paths.every(isChore)) return 'chore';
+  if (files.some((f) => f.status === 'A')) return 'feat';
+  return 'fix';
+}
+
+// The one file that best represents the change: prefer an added file, then the
+// biggest churn, tie-broken by path so the pick is stable across runs.
+function leadFile(files) {
+  return [...files].sort((a, b) => {
+    const addedA = a.status === 'A' ? 1 : 0;
+    const addedB = b.status === 'A' ? 1 : 0;
+    if (addedA !== addedB) return addedB - addedA;
+    const churnA = (a.added || 0) + (a.deleted || 0);
+    const churnB = (b.added || 0) + (b.deleted || 0);
+    if (churnA !== churnB) return churnB - churnA;
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+  })[0];
+}
+
+function summarize(files) {
+  const lead = leadFile(files);
+  const verb = VERB[lead.status] || 'update';
+  const name = lead.path.split('/').pop();
+  if (files.length === 1) return `${verb} ${name}`;
+  // name the lead file instead of an anonymous count ("update 3 files"):
+  // that count is the exact slop this script exists to kill.
+  return `${verb} ${name} (+${files.length - 1} more)`;
+}
+
+// files: [{ path, status, added, deleted }] -> { type, scope, summary, subject, body, totals }
+function draft(files) {
+  if (!Array.isArray(files) || files.length === 0) {
+    return { error: 'no staged changes' };
+  }
+  const type = pickType(files);
+  let scope = commonDirScope(files.map((f) => f.path));
+  if (scope === type) scope = ''; // avoid redundant test(test): / docs(docs):
+  const summary = summarize(files);
+  const subject = `${type}${scope ? `(${scope})` : ''}: ${summary}`;
+  const totals = files.reduce(
+    (a, f) => ({ added: a.added + (f.added || 0), deleted: a.deleted + (f.deleted || 0) }),
+    { added: 0, deleted: 0 }
+  );
+  const lines = files.map(
+    (f) => `- ${f.status} ${f.path} (+${f.added || 0}/-${f.deleted || 0})`
+  );
+  const body = `${lines.join('\n')}\n\n${files.length} file${
+    files.length === 1 ? '' : 's'
+  } changed, +${totals.added}/-${totals.deleted}`;
+  return { type, scope, summary, subject, body, totals, files };
+}
+
+// --- git plumbing (impure, only in main) ----------------------------------
+
+// Merge `--numstat` (added/deleted) with `--name-status` (A/M/D) by path.
+function readStaged() {
+  const numstat = execFileSync('git', ['diff', '--cached', '--numstat'], { encoding: 'utf8' });
+  const names = execFileSync('git', ['diff', '--cached', '--name-status'], { encoding: 'utf8' });
+  const stat = {};
+  for (const line of numstat.split('\n')) {
+    if (!line.trim()) continue;
+    const [added, deleted, path] = line.split('\t');
+    stat[path] = { added: added === '-' ? 0 : Number(added), deleted: deleted === '-' ? 0 : Number(deleted) };
+  }
+  const files = [];
+  for (const line of names.split('\n')) {
+    if (!line.trim()) continue;
+    const parts = line.split('\t');
+    const status = parts[0][0]; // R100 -> R
+    const path = parts[parts.length - 1];
+    files.push({ path, status, added: (stat[path] || {}).added || 0, deleted: (stat[path] || {}).deleted || 0 });
+  }
+  return files;
+}
+
+function main() {
+  const wantJson = process.argv.includes('--json');
+  let files;
+  try {
+    files = readStaged();
+  } catch (e) {
+    process.stderr.write(`git failed: ${e.message}\n`);
+    process.exit(2);
+  }
+  const res = draft(files);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(res, null, 2) + '\n');
+  } else {
+    process.stdout.write(`${res.subject}\n\n${res.body}\n`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { draft, commonDirScope, pickType, summarize, leadFile };

package/scripts/det/data/ax-lane-gold.jsonl

@@ -0,0 +1,81 @@
+{"message": "what is the capital of france", "lane": "fast", "why": "short factual lookup"}
+{"message": "list the files in the atris runs folder", "lane": "fast", "why": "simple enumeration"}
+{"message": "who wrote the little prince", "lane": "fast", "why": "single fact"}
+{"message": "define idempotent", "lane": "fast", "why": "definition lookup"}
+{"message": "when was node 22 released", "lane": "fast", "why": "date lookup"}
+{"message": "show me the npm version command", "lane": "fast", "why": "one-liner recall"}
+{"message": "what does http 429 mean", "lane": "fast", "why": "status code lookup"}
+{"message": "where does atris store credentials", "lane": "fast", "why": "single known fact"}
+{"message": "list 5 postgres index types", "lane": "fast", "why": "bounded list recall"}
+{"message": "what port does redis use by default", "lane": "fast", "why": "single fact"}
+{"message": "convert 90 fahrenheit to celsius", "lane": "fast", "why": "single computation"}
+{"message": "what is a monad", "lane": "fast", "why": "definition lookup"}
+{"message": "summarize this in one line: the meeting moved to thursday and derrick will demo the orb", "lane": "fast", "why": "trivial transform"}
+{"message": "write a friendly two line slack message telling the team the deploy is done", "lane": "pro", "why": "light generation with tone"}
+{"message": "explain how our wish loop works to a new hire", "lane": "pro", "why": "explanation needs context and structure"}
+{"message": "draft a short email to a customer asking to reschedule tomorrows call", "lane": "pro", "why": "everyday writing"}
+{"message": "give me three name ideas for a cli that routes work between ai models", "lane": "pro", "why": "light creative generation"}
+{"message": "rewrite this paragraph so it sounds less formal: our organization has determined that the aforementioned initiative shall proceed", "lane": "pro", "why": "mid-weight rewrite"}
+{"message": "whats a good way to onboard a non technical founder to git", "lane": "pro", "why": "advice, some judgment"}
+{"message": "turn these bullet points into a short update for investors: shipped router, closed two deals, hired one engineer", "lane": "pro", "why": "structured writing"}
+{"message": "help me think through whether to charge per seat or per usage", "lane": "pro", "why": "reasoning but conversational scope"}
+{"message": "explain the difference between optimistic and pessimistic locking with an example", "lane": "pro", "why": "explanation with example"}
+{"message": "make this tweet punchier: we launched a thing that picks the right ai model for you", "lane": "pro", "why": "short edit with taste"}
+{"message": "what should i ask in a reference call for a senior engineer", "lane": "pro", "why": "judgment list"}
+{"message": "design a database schema for a multi tenant task system with per org roles, audit history, and soft deletes, and explain the tradeoffs of your choices", "lane": "max", "why": "design plus tradeoff analysis"}
+{"message": "architect a migration plan to move our monolith to services without downtime, including rollout order and rollback points", "lane": "max", "why": "long horizon architecture"}
+{"message": "prove that this retry strategy cannot livelock, or show a counterexample", "lane": "max", "why": "proof style reasoning"}
+{"message": "analyze the tradeoffs between event sourcing and crud for our billing system and recommend one with reasoning", "lane": "max", "why": "deep comparison and recommendation"}
+{"message": "plan a three month roadmap to take the router from heuristic to learned routing, with milestones, risks, and what we measure at each step", "lane": "max", "why": "multi step planning"}
+{"message": "compare the tradeoffs of thompson sampling versus epsilon greedy for picking models when feedback is delayed and noisy, and which fits our receipt data", "lane": "max", "why": "deep technical comparison"}
+{"message": "why might a distributed lock built on redis fail under network partition, and how would you design around each failure mode", "lane": "max", "why": "failure mode analysis"}
+{"message": "design an experiment to test whether our auto router saves money without hurting answer quality, including sample size reasoning", "lane": "max", "why": "experiment design"}
+{"message": "walk through what happens when two mission ticks race on the same task file and design a fix that keeps receipts consistent", "lane": "max", "why": "concurrency analysis and design"}
+{"message": "should atris build its own inference layer or stay on provider apis for the next two years, argue both sides then commit", "lane": "max", "why": "strategic analysis"}
+{"message": "fix this: TypeError: Cannot read properties of undefined (reading 'map')\n    at buildRoster (lib/fleet.js:412)\n    at dispatch (lib/fleet.js:2101)", "lane": "code-fast", "why": "stack trace plus fix verb"}
+{"message": "refactor this function to use early returns:\n```js\nfunction pick(a){ if(a){ if(a.ok){ return a.v } else { return null } } else { return null } }\n```", "lane": "code-fast", "why": "code fence plus refactor verb"}
+{"message": "debug why this test fails:\n```js\nassert.equal(pickLane('what is x').lane, 'fast')\n```\nit returns pro", "lane": "code-fast", "why": "code fence plus debug verb"}
+{"message": "rename the variable cnt to receiptCount in this snippet:\n```js\nlet cnt = rows.length\nreturn cnt\n```", "lane": "code-fast", "why": "bounded mechanical edit"}
+{"message": "fix the off by one in this loop:\n```python\nfor i in range(len(xs) - 1):\n    print(xs[i])\n```", "lane": "code-fast", "why": "small bounded code fix"}
+{"message": "why is this promise never resolving:\n```js\nnew Promise((resolve) => { if (ready) resolve() })\n```", "lane": "code-fast", "why": "bounded code diagnosis"}
+{"message": "what is the difference between let and const", "lane": "fast", "why": "boundary: code topic but pure lookup, no edit"}
+{"message": "prove p equals np", "lane": "max", "why": "boundary: very short but proof depth"}
+{"message": "is rust better than go", "lane": "pro", "why": "boundary: short but needs judgment not a fact"}
+{"message": "summarize the plot of hamlet", "lane": "fast", "why": "boundary: summary of known fact, no reasoning"}
+{"message": "write a haiku about deploy friday", "lane": "pro", "why": "boundary: short creative, taste over recall"}
+{"message": "list the tradeoffs of microservices", "lane": "pro", "why": "boundary: list verb but needs judgment beyond recall"}
+{"message": "should we rewrite the backend in rust, consider team skills, hiring, our latency needs, migration cost, and what we lose by pausing features for two quarters", "lane": "max", "why": "boundary: starts casual but multi factor decision"}
+{"message": "fix my code", "lane": "pro", "why": "boundary: fix verb but no code included, needs clarification not a code lane"}
+{"message": "what are the seven capabilities in our router checklist and which two are unfinished, and for the unfinished ones sketch the implementation approach and the riskiest assumption in each", "lane": "max", "why": "boundary: starts as lookup, second half is analysis"}
+{"message": "hey", "lane": "fast", "why": "boundary: greeting, cheapest lane"}
+{"message": "thanks that worked", "lane": "fast", "why": "boundary: acknowledgment, cheapest lane"}
+{"message": "explain this error in plain words: ENOTEMPTY directory not empty rm", "lane": "fast", "why": "boundary: error text but explanation lookup, no code to edit"}
+{"message": "does postgres support partial indexes", "lane": "fast", "why": "yes/no capability lookup, found in dogfood 7/21"}
+{"message": "my build fails with ELIFECYCLE after npm install, what do i check first", "lane": "pro", "why": "troubleshooting advice not recall, found in dogfood 7/21"}
+{"message": "rank our 5 engines by cost per successful task and tell me which to cancel, consider subscription price, pass rate, and speed", "lane": "max", "why": "multi factor ranking decision, found in dogfood 7/21"}
+{"message": "whos on call this week", "lane": "fast", "why": "contracted lookup word, found in dogfood tick 2"}
+{"message": "whats the git command to undo the last commit but keep changes", "lane": "fast", "why": "command recall, found in dogfood tick 2"}
+{"message": "my mac fan is screaming when i run the test suite, is that normal", "lane": "pro", "why": "lookup word mid sentence is not a lookup, found in dogfood tick 2"}
+{"message": "estimate how much we save per month if fast handles 40% of turns, pro 50%, max 10%, versus everything on max, show your math", "lane": "max", "why": "multi step estimation, found in dogfood tick 2"}
+{"message": "if we double the price and lose a third of customers is that good, walk through the revenue and support load math", "lane": "max", "why": "walk through the math is analysis, found in dogfood tick 2"}
+{"message": "how do i exit vim lol", "lane": "fast", "why": "muscle memory lookup, found in dogfood tick 3"}
+{"message": "so we have 3 pricing ideas, flat 20 a month, usage based, or free with paid packs, think about who each attracts, what support looks like, and which one kills us if we guess wrong", "lane": "max", "why": "multi option strategy weighing, found in dogfood tick 3"}
+{"message": "WHATS THE WIFI PASSWORD FORMAT WE USE FOR GUESTS", "lane": "fast", "why": "caps lookup held in dogfood tick 3"}
+{"message": "im getting 401s from the backend since an hour ago but only on the mac app, web works fine, where do i even start", "lane": "pro", "why": "troubleshooting with mid sentence where, held in dogfood tick 3"}
+{"message": "turn this slack thread into one decision line: derrick: can we ship tmrw? me: tests green. derrick: ok but whats the risk? me: rollback is one command. derrick: send it", "lane": "pro", "why": "pasted thread with internal question marks is a transform, found in dogfood tick 4"}
+{"message": "que significa el error 502 bad gateway", "lane": "fast", "why": "spanish lookup, found in dogfood tick 4"}
+{"message": "why is my regex not matching: /^[a-z]+$/ against the string Hello", "lane": "code-fast", "why": "regex diagnosis without a fence, found in dogfood tick 4"}
+{"message": "summarize what changed in our router this week for the changelog", "lane": "pro", "why": "possessive context work not a paste transform, found in dogfood tick 4"}
+{"message": "is consciousness computable", "lane": "pro", "why": "short but bottomless, yes/no shape is a trap, found in dogfood tick 5"}
+{"message": "settle it once and for all, tabs or spaces", "lane": "pro", "why": "banter judgment, held in dogfood tick 5"}
+{"message": "and the second one?", "lane": "fast", "why": "context fragment, cheapest lane until session stickiness exists, held in dogfood tick 5"}
+{"message": "whats blocking the demo", "lane": "fast", "why": "bounded workspace status lookup, held in dogfood tick 5"}
+{"message": "whens the next stripe payout", "lane": "fast", "why": "contracted when lookup, found in dogfood tick 6"}
+{"message": "este codigo tiene un bug:\n```js\nconst total = items.reduce((a,b) => a + b.price)\n```", "lane": "code-fast", "why": "spanish bug report with fence, found in dogfood tick 6"}
+{"message": "if the router picks wrong lanes 20% of the time but each wrong pick costs 2 cents extra, do we even care, math it out", "lane": "max", "why": "expected value analysis, found in dogfood tick 6"}
+{"message": "is bun faster than node", "lane": "fast", "why": "measurable comparative, held as fast in dogfood tick 6"}
+{"message": "translate our tagline to german and french", "lane": "pro", "why": "possessive needs workspace context, held in dogfood tick 6"}
+{"message": "PROD IS DOWN users cant login everything 500s since 5 min ago", "lane": "max", "why": "live incident, stakes beat size, found in dogfood tick 7"}
+{"message": "do we log ip addresses anywhere, legal is asking", "lane": "pro", "why": "compliance question must not route cheap, found in dogfood tick 7"}
+{"message": "draft terms of service for the router beta, cover liability for wrong lane picks, data retention for the picks log, and how we handle eu users", "lane": "max", "why": "legal drafting with multiple requirements, found in dogfood tick 7"}
+{"message": "urgent: investor asked for our churn number before their 9am, where do i pull it and whats the caveat i should mention", "lane": "pro", "why": "urgent workspace pull with judgment, held in dogfood tick 7"}

package/scripts/det/data/ax-lane-holdout.jsonl

@@ -0,0 +1,20 @@
+{"message": "whats the flag to skip git hooks", "lane": "fast", "why": "single flag lookup"}
+{"message": "how many megabytes in a gigabyte", "lane": "fast", "why": "single fact"}
+{"message": "show the last 5 commits", "lane": "fast", "why": "one command recall"}
+{"message": "define eventual consistency", "lane": "fast", "why": "definition"}
+{"message": "translate good morning to spanish", "lane": "fast", "why": "tiny transform"}
+{"message": "gm", "lane": "fast", "why": "greeting"}
+{"message": "sounds good", "lane": "fast", "why": "acknowledgment"}
+{"message": "write a birthday message for my cofounder who loves espresso", "lane": "pro", "why": "light personal writing"}
+{"message": "make this subject line better: quarterly update for investors q3", "lane": "pro", "why": "short edit with taste"}
+{"message": "how do i tell a customer their feature request is not happening without losing them", "lane": "pro", "why": "delicate wording, judgment"}
+{"message": "give me a checklist for taking the laptop abroad for a month of remote work", "lane": "pro", "why": "practical list with judgment"}
+{"message": "is it worth adding typescript to a 5k line node project", "lane": "pro", "why": "short judgment question"}
+{"message": "explain webhooks to a marketer", "lane": "pro", "why": "audience-shaped explanation"}
+{"message": "design a rate limiter for our public api that is fair across tenants, survives restarts, and degrades gracefully under redis loss, justify each choice", "lane": "max", "why": "design with justification"}
+{"message": "our churn doubled last quarter while nps stayed flat, lay out the possible causes, how you would test each, and what data we need", "lane": "max", "why": "causal analysis plan"}
+{"message": "prove this scheduler never starves a low priority task, or find the case where it does", "lane": "max", "why": "proof style"}
+{"message": "plan how we migrate 40 million rows to a new schema with zero downtime, include batch sizing, verification, and rollback", "lane": "max", "why": "long horizon plan"}
+{"message": "should we open source the router, weigh community growth, competitive risk, maintenance burden, and monetization paths", "lane": "max", "why": "multi factor decision"}
+{"message": "fix this test:\n```js\nassert.equal(sum([1,2]), 4)\n```\nsum works fine elsewhere", "lane": "code-fast", "why": "code fence plus fix"}
+{"message": "why does this throw:\n```python\nx = {}\nprint(x['missing'])\n```", "lane": "code-fast", "why": "code fence plus diagnosis"}