atris 3.46.1 → 3.48.0

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"}

package/scripts/det/date.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// det/date.js — deterministic date/time conversion. Epoch<->ISO and weekday are
+// the asks LLMs fumble most (seconds vs ms, and timezone guesses). Everything is
+// UTC so the answer is the same on every machine. Reads stdin, writes stdout.
+//
+// Usage:
+//   echo 1700000000    | node date.js iso       # epoch (s or ms) -> ISO 8601 UTC
+//   echo 2026-07-07    | node date.js epoch      # date/ISO -> epoch seconds
+//   echo 2026-07-07    | node date.js epochms    # -> epoch milliseconds
+//   echo 2026-07-07    | node date.js weekday    # -> Monday..Sunday (UTC)
+//
+// Modes: iso | epoch | epochms | weekday
+// Bare date strings (no timezone) are read as UTC. Exit 2 on bad mode/input.
+
+'use strict';
+
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+// Parse stdin into a Date, deterministically. A pure-digit string is an epoch
+// (>=13 digits = ms, else seconds). Otherwise a date string; if it carries no
+// timezone we pin it to UTC by appending 'Z' so machines don't disagree.
+function toDate(s) {
+  const t = s.trim();
+  if (t === '') return { error: 'empty input' };
+  if (/^-?\d+$/.test(t)) {
+    const n = Number(t);
+    const ms = t.replace('-', '').length >= 13 ? n : n * 1000;
+    return { date: new Date(ms) };
+  }
+  // ISO-ish without an explicit zone/offset -> treat as UTC.
+  let str = t;
+  const hasZone = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(t);
+  if (!hasZone) {
+    str = /\d{4}-\d{2}-\d{2}$/.test(t) ? t + 'T00:00:00Z' : t + 'Z';
+  }
+  const d = new Date(str);
+  if (Number.isNaN(d.getTime())) return { error: `cannot parse date: ${t}` };
+  return { date: d };
+}
+
+// Pure core: returns { text } or { error }.
+function run(mode, input) {
+  const p = toDate(input);
+  if (p.error) return { error: p.error };
+  const d = p.date;
+  switch (mode) {
+    case 'iso':
+      return { text: d.toISOString() };
+    case 'epoch':
+      return { text: String(Math.floor(d.getTime() / 1000)) };
+    case 'epochms':
+      return { text: String(d.getTime()) };
+    case 'weekday':
+      return { text: DAYS[d.getUTCDay()] };
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['iso', 'epoch', 'epochms', 'weekday'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, toDate, MODES };

package/scripts/det/det.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+// det/det.js — one entrypoint for the deterministic task scripts. A cheap model
+// runs `node det.js` to see the whole catalog, then `node det.js <script> <mode>`
+// to route its stdin through the right one. No need to know the file layout.
+//
+//   node det.js                      # print the catalog (task -> script -> modes)
+//   node det.js --json               # same, machine-readable
+//   node det.js extract urls < f     # route stdin through extract.js in urls mode
+//   node det.js json csv < arr.json  # route stdin through json.js in csv mode
+//
+// The catalog is derived from the scripts themselves (their exported MODES /
+// EXTRACTORS), so it can never drift from what actually runs.
+
+'use strict';
+
+const extract = require('./extract');
+const json = require('./json');
+const text = require('./text');
+const hash = require('./hash');
+const date = require('./date');
+const voice = require('./voice');
+
+// git-facing scripts: they read the repo, not stdin, so they aren't routable
+// through det.js. Listed here only so the front door surfaces all the tools —
+// a cheap model running `det.js` sees these too and knows to run them directly.
+const GIT_SCRIPTS = [
+  {
+    name: 'commit-msg',
+    ask: 'draft a Conventional-Commits message from the staged diff',
+    usage: 'git add -A && node scripts/det/commit-msg.js',
+  },
+  {
+    name: 'changelog',
+    ask: 'group commits since a ref/tag into a changelog',
+    usage: 'node scripts/det/changelog.js [ref]',
+  },
+  {
+    name: 'pr-description',
+    ask: 'draft a PR title + area summary + test-plan from the branch diff',
+    usage: 'node scripts/det/pr-description.js [base]',
+  },
+];
+
+// script -> { ask, modes, run(mode, input) -> {text}|{error} }
+const CATALOG = {
+  extract: {
+    ask: 'pull links / emails / code / numbers out of text',
+    modes: Object.keys(extract.EXTRACTORS),
+    run: (mode, input) => {
+      const items = extract.extract(mode, input);
+      return items === null ? { error: `unknown mode: ${mode}` } : { text: items.join('\n') };
+    },
+  },
+  json: {
+    ask: 'reformat / validate / flatten JSON (incl. JSON->CSV)',
+    modes: json.MODES,
+    run: json.run,
+  },
+  text: {
+    ask: 'dedupe / sort / count / slugify / trim lines',
+    modes: text.MODES,
+    run: text.run,
+  },
+  hash: {
+    ask: 'base64 / hex encode-decode, sha256 / sha1 / md5',
+    modes: hash.MODES,
+    run: hash.run,
+  },
+  date: {
+    ask: 'epoch <-> ISO, weekday (all UTC)',
+    modes: date.MODES,
+    run: date.run,
+  },
+  voice: {
+    ask: 'score a chat reply against the way of talking (PASS or findings)',
+    modes: voice.MODES,
+    run: voice.run,
+  },
+};
+
+function catalogText() {
+  const rows = Object.entries(CATALOG).map(
+    ([name, s]) => `  ${name.padEnd(9)} ${s.modes.join(' ')}\n    ${s.ask}`
+  );
+  const gitRows = GIT_SCRIPTS.map((g) => `  ${g.name.padEnd(15)} ${g.usage}\n    ${g.ask}`);
+  return (
+    'deterministic task scripts — run: node det.js <script> <mode> < input\n\n' +
+    rows.join('\n\n') +
+    '\n\ngit-facing (read the repo, run the script directly; not via det.js):\n\n' +
+    gitRows.join('\n\n') +
+    '\n'
+  );
+}
+
+function catalogJson() {
+  const out = {};
+  for (const [name, s] of Object.entries(CATALOG)) out[name] = { ask: s.ask, modes: s.modes };
+  const git = {};
+  for (const g of GIT_SCRIPTS) git[g.name] = { ask: g.ask, usage: g.usage };
+  return JSON.stringify({ ...out, git }, null, 2);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2).filter((a) => a !== '--json');
+  const wantJson = process.argv.includes('--json');
+  const [script, mode] = args;
+
+  if (!script) {
+    process.stdout.write((wantJson ? catalogJson() : catalogText()) + '\n');
+    return;
+  }
+  const git = GIT_SCRIPTS.find((g) => g.name === script);
+  if (git) {
+    process.stdout.write(`${git.name} reads the repo, not stdin — run it directly:\n  ${git.usage}\n`);
+    return;
+  }
+  const entry = CATALOG[script];
+  if (!entry) {
+    process.stderr.write(`unknown script: ${script}\nscripts: ${Object.keys(CATALOG).join(' | ')}\n`);
+    process.exit(2);
+  }
+  if (!mode || !entry.modes.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${entry.modes.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = entry.run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { CATALOG, catalogJson, catalogText, GIT_SCRIPTS };

package/scripts/det/extract.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// det/extract.js — deterministically pull structured items out of text.
+// Replaces the "extract all the X from this" ask that a cheap LLM does slowly
+// and sometimes wrong. Reads stdin, writes one item per line to stdout.
+//
+// Usage:
+//   cat file.txt | node extract.js urls
+//   node extract.js emails < file.txt
+//   node extract.js code < README.md        # fenced ```code blocks
+//   node extract.js numbers < report.txt
+//   node extract.js --json urls < file.txt   # JSON array instead of lines
+//
+// Kinds: urls | emails | code | numbers | ipv4 | hashtags
+// Exit 0 with output, exit 2 on bad/unknown kind. Duplicates removed, order preserved.
+
+'use strict';
+
+const EXTRACTORS = {
+  urls: (t) => match(t, /\bhttps?:\/\/[^\s<>"')\]]+/g).map(stripTrailingPunct),
+  emails: (t) => match(t, /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g),
+  ipv4: (t) => match(t, /\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b/g),
+  hashtags: (t) => match(t, /(?:^|\s)(#[A-Za-z0-9_]+)/g).map((m) => m.trim()),
+  numbers: (t) => match(t, /-?\b\d[\d,]*(?:\.\d+)?\b/g),
+  code: (t) => {
+    // Fenced blocks: ```lang\n...\n```  — return block contents (not fences).
+    const blocks = [];
+    const re = /```[^\n]*\n([\s\S]*?)```/g;
+    let m;
+    while ((m = re.exec(t)) !== null) blocks.push(m[1].replace(/\n$/, ''));
+    return blocks;
+  },
+};
+
+function match(text, re) {
+  return text.match(re) || [];
+}
+
+function stripTrailingPunct(s) {
+  return s.replace(/[.,;:!?]+$/, '');
+}
+
+function dedupePreserveOrder(items) {
+  const seen = new Set();
+  const out = [];
+  for (const it of items) {
+    if (!seen.has(it)) {
+      seen.add(it);
+      out.push(it);
+    }
+  }
+  return out;
+}
+
+function extract(kind, text) {
+  const fn = EXTRACTORS[kind];
+  if (!fn) return null;
+  return dedupePreserveOrder(fn(text));
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const kind = args.find((a) => !a.startsWith('-'));
+  if (!kind || !EXTRACTORS[kind]) {
+    process.stderr.write(
+      `unknown kind: ${kind || '(none)'}\nkinds: ${Object.keys(EXTRACTORS).join(' | ')}\n`
+    );
+    process.exit(2);
+  }
+  const text = await readStdin();
+  const items = extract(kind, text);
+  if (json) {
+    process.stdout.write(JSON.stringify(items) + '\n');
+  } else if (items.length) {
+    process.stdout.write(items.join('\n') + '\n');
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { extract, EXTRACTORS };

package/scripts/det/hash.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// det/hash.js — deterministic encode / hash. The "base64 this" and "give me the
+// sha256" asks an LLM fakes or does wrong. Reads stdin, writes stdout.
+//
+// Usage:
+//   printf 'hi' | node hash.js b64          # base64 encode
+//   node hash.js b64d   < encoded.txt        # base64 decode
+//   node hash.js sha256 < file.txt           # hex sha256 of the bytes
+//   node hash.js sha1   < file.txt
+//   node hash.js md5    < file.txt
+//   node hash.js hexenc < file.txt           # raw -> hex
+//   node hash.js hexdec < hex.txt            # hex -> raw
+//
+// Modes: b64 | b64d | sha256 | sha1 | md5 | hexenc | hexdec
+// Input's trailing newline is stripped before encoding/hashing so
+// `printf 'hi'` and `echo hi` give the same result. Exit 2 on bad mode/input.
+
+'use strict';
+
+const crypto = require('crypto');
+
+const DIGESTS = { sha256: 'sha256', sha1: 'sha1', md5: 'md5' };
+
+// Pure core: returns { text } or { error }. Unit-testable.
+function run(mode, input) {
+  // Strip a single trailing newline so shell echo vs printf agree.
+  const raw = input.replace(/\n$/, '');
+  if (DIGESTS[mode]) {
+    return { text: crypto.createHash(DIGESTS[mode]).update(raw, 'utf8').digest('hex') };
+  }
+  switch (mode) {
+    case 'b64':
+      return { text: Buffer.from(raw, 'utf8').toString('base64') };
+    case 'b64d':
+      return { text: Buffer.from(raw, 'base64').toString('utf8') };
+    case 'hexenc':
+      return { text: Buffer.from(raw, 'utf8').toString('hex') };
+    case 'hexdec':
+      if (!/^[0-9a-fA-F]*$/.test(raw) || raw.length % 2 !== 0) {
+        return { error: 'hexdec needs an even-length hex string' };
+      }
+      return { text: Buffer.from(raw, 'hex').toString('utf8') };
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['b64', 'b64d', 'sha256', 'sha1', 'md5', 'hexenc', 'hexdec'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, MODES };

package/scripts/det/hunk-filter.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// det/hunk-filter.js - keep only unified-diff hunks whose lines match a regex.
+// For concurrent-editor workspaces: stage YOUR hunk of a shared file without
+// sweeping in other agents' churn (git apply --cached the filtered patch).
+//
+// Usage:
+//   git diff -U1 -- path/file | node scripts/det/hunk-filter.js "<regex>"
+//   git diff -U1 -- path/file | node scripts/det/hunk-filter.js "Horizon" | git apply --cached --unidiff-zero -
+//
+// A file section is printed only when at least one of its hunks matches.
+// Exit 0 on success (even if nothing matched), 2 on missing pattern.
+'use strict';
+
+function filterHunks(diffText, pattern) {
+  const re = new RegExp(pattern);
+  const lines = String(diffText).split('\n');
+  const out = [];
+  let header = [];
+  let hunk = null;
+  let fileHasMatch = false;
+  let fileHunks = [];
+
+  const flushFile = () => {
+    if (fileHasMatch && fileHunks.length) {
+      out.push(...header, ...fileHunks);
+    }
+    header = [];
+    fileHunks = [];
+    fileHasMatch = false;
+  };
+  const flushHunk = () => {
+    if (!hunk) return;
+    if (hunk.some((l) => re.test(l))) {
+      fileHunks.push(...hunk);
+      fileHasMatch = true;
+    }
+    hunk = null;
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      flushHunk();
+      flushFile();
+      header = [line];
+    } else if (line.startsWith('@@')) {
+      flushHunk();
+      hunk = [line];
+    } else if (hunk) {
+      hunk.push(line);
+    } else {
+      header.push(line);
+    }
+  }
+  flushHunk();
+  flushFile();
+  const text = out.join('\n');
+  return text && !text.endsWith('\n') ? `${text}\n` : text;
+}
+
+module.exports = { filterHunks };
+
+if (require.main === module) {
+  const pattern = process.argv[2];
+  if (!pattern) {
+    console.error('usage: git diff -U1 -- file | hunk-filter.js "<regex>"');
+    process.exit(2);
+  }
+  let input = '';
+  process.stdin.on('data', (c) => { input += c; });
+  process.stdin.on('end', () => {
+    process.stdout.write(filterHunks(input, pattern));
+  });
+}