mixdog 1.4.2 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",
@@ -144,7 +144,7 @@
     "arm64"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.135.0",
+    "@anthropic-ai/sdk": "^0.137.0",
     "@formulajs/formulajs": "^4.6.1",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/transformers": "^4.3.1",

package/scripts/build-shipped-history.mjs

@@ -92,11 +92,19 @@ function parseTree(body) {
 const treeCache = new Map();
 const blobCache = new Map();
 const treeOf = async (sha) => {
-  if (!treeCache.has(sha)) treeCache.set(sha, read(sha).then(({ body }) => parseTree(body)));
+  if (!treeCache.has(sha))
+    treeCache.set(
+      sha,
+      read(sha).then(({ body }) => parseTree(body))
+    );
   return treeCache.get(sha);
 };
 const blobOf = async (sha) => {
-  if (!blobCache.has(sha)) blobCache.set(sha, read(sha).then(({ body }) => body));
+  if (!blobCache.has(sha))
+    blobCache.set(
+      sha,
+      read(sha).then(({ body }) => body)
+    );
   return blobCache.get(sha);
 };
 
@@ -163,9 +171,10 @@ async function packHistory(dir, entry) {
   return out;
 }
 
-async function outputStyleHistory() {
+// Single-file definitions (output styles, orchestration modes): file name -> hashes.
+async function fileHistory(prefix) {
   const out = {};
-  for (const [name, versions] of await everVersions('src/output-styles')) {
+  for (const [name, versions] of await everVersions(prefix)) {
     const hashes = [];
     for (const files of versions) hashes.push(hashText(await blobOf([...files.values()][0])));
     if (hashes.length) out[name] = unique(hashes);
@@ -188,7 +197,8 @@ async function skillHistory() {
 const history = {
   agents: await packHistory('src/agents', 'AGENT.md'),
   workflows: await packHistory('src/workflows', 'WORKFLOW.md'),
-  outputStyles: await outputStyleHistory(),
+  outputStyles: await fileHistory('src/output-styles'),
+  orchestration: await fileHistory('src/orchestration'),
   skills: await skillHistory(),
 };
 catFile.stdin.end();

package/scripts/gate-local.mjs

@@ -36,7 +36,9 @@ import {
   runPool,
   saveTimingHistory,
 } from './lib/gate-scheduler.mjs';
+import { FULL_LOG_LABEL } from './lib/run-node-tests.mjs';
 import { pruneStaleTempDirs, removeTempDirSync } from './lib/stale-temp.mjs';
+import { SUMMARY_TAG } from './lib/test-failure-summary.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const started = Date.now();
@@ -81,8 +83,7 @@ const commonDir = spawnSync('git', ['rev-parse', '--path-format=absolute', '--gi
   cwd: root,
   encoding: 'utf8',
 });
-const historyPath =
-  commonDir.status === 0 ? path.join(commonDir.stdout.trim(), 'mixdog-gate-timings.json') : null;
+const historyPath = commonDir.status === 0 ? path.join(commonDir.stdout.trim(), 'mixdog-gate-timings.json') : null;
 if (!historyPath) console.warn(`[gate:local] warning: no git common dir, timings not kept: ${commonDir.stderr}`);
 const history = historyPath ? readTimingHistory(historyPath) : {};
 const measured = {};
@@ -99,7 +100,8 @@ const testLanes = [
   const dir = path.join(root, lane.pkg);
   const command = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).scripts[lane.script];
   const [program, ...args] = command.split(/\s+/);
-  if (program !== 'node') throw new Error(`${lane.pkg}/package.json "${lane.script}" must be a node command: ${command}`);
+  if (program !== 'node')
+    throw new Error(`${lane.pkg}/package.json "${lane.script}" must be a node command: ${command}`);
   const list = spawnSync(process.execPath, [...args, '--list'], { cwd: dir, encoding: 'utf8' });
   if (list.status !== 0) throw new Error(`${command} --list failed: ${list.stderr}`);
   const files = list.stdout
@@ -107,7 +109,14 @@ const testLanes = [
     .filter(Boolean)
     .map((line) => line.replace(/^\S+\s+/, ''));
   const key = (file) => path.posix.join(lane.pkg, file);
-  return { ...lane, dir, args, files, key, estimateOf: (file) => history[key(file)] ?? DEFAULT_ESTIMATE_MS[lane.speed] };
+  return {
+    ...lane,
+    dir,
+    args,
+    files,
+    key,
+    estimateOf: (file) => history[key(file)] ?? DEFAULT_ESTIMATE_MS[lane.speed],
+  };
 });
 const lanesByName = new Map(testLanes.map((lane) => [lane.name, lane]));
 const commandUnits = [
@@ -136,11 +145,37 @@ function run(command, args, options, fd) {
     const child = spawn(command, args, { ...options, env, windowsHide: true, stdio: ['ignore', fd, fd] });
     child.on('error', (error) => {
       fs.writeSync(fd, `${error.stack}\n`);
-      resolve(1);
+      resolve({ code: 1, signal: null });
     });
-    child.on('close', (code) => resolve(code ?? 1));
+    child.on('close', (code, signal) => resolve({ code, signal }));
   });
 }
+const passed = (exit) => exit.code === 0;
+const ending = (exit) => (exit.signal ? `signal ${exit.signal}` : `exit code ${exit.code}`);
+
+// A shard's runner ends every run with its failure summary
+// (scripts/lib/run-node-tests.mjs). One killed from outside (TerminateProcess,
+// SIGKILL) or crashed prints nothing more, and Windows ends its node --test
+// batch and test processes with it, so no reporter flushes either: name how it
+// ended and what its full test log last recorded.
+const DEAD_TAIL_LINES = 12;
+function deadShardReport(unit, exit, output) {
+  if (passed(exit) || output.includes(SUMMARY_TAG)) return '';
+  const fullLog = output
+    .split(/\r?\n/)
+    .find((line) => line.startsWith(FULL_LOG_LABEL))
+    ?.slice(FULL_LOG_LABEL.length);
+  const tail =
+    fullLog && fs.existsSync(fullLog)
+      ? fs.readFileSync(fullLog, 'utf8').trimEnd().split(/\r?\n/).slice(-DEAD_TAIL_LINES)
+      : [];
+  return [
+    `${SUMMARY_TAG} RUN FAILED: ${unit.id} runner ended by ${ending(exit)} before its failure summary (killed from outside or crashed)`,
+    `${SUMMARY_TAG} last ${tail.length} line(s) of ${fullLog ?? 'its full test log (never named)'}:`,
+    ...tail.map((line) => `    ${line}`),
+    '',
+  ].join('\n');
+}
 
 const TIMING_REPORTER = new URL('./lib/gate-timing-reporter.mjs', import.meta.url).href;
 async function runShard(unit, fd) {
@@ -148,7 +183,7 @@ async function runShard(unit, fd) {
   const timings = path.join(logDir, `${unit.id}.timings.jsonl`);
   const args = [...lane.args, `--test-reporter=${TIMING_REPORTER}`, `--test-reporter-destination=${timings}`];
   fs.writeSync(fd, `\n$ (${lane.pkg}) node ${[...args, ...unit.files].join(' ')}\n`);
-  const code = await run(process.execPath, [...args, ...unit.files], { cwd: lane.dir }, fd);
+  const exit = await run(process.execPath, [...args, ...unit.files], { cwd: lane.dir }, fd);
   const reported = Object.fromEntries(
     (fs.existsSync(timings) ? fs.readFileSync(timings, 'utf8') : '')
       .split('\n')
@@ -162,20 +197,19 @@ async function runShard(unit, fd) {
   for (const [file, ms] of Object.entries(measuredFileTimes(unit.files, reported, Date.now() - unit.start))) {
     measured[lane.key(file)] = Math.round(ms);
   }
-  return code === 0;
+  return exit;
 }
 
+// The exit of the first command that failed, else of the last one.
 async function runCommands(unit, fd) {
-  let ok = true;
+  let exit = { code: 0, signal: null };
   for (const cmd of unit.cmds) {
     fs.writeSync(fd, `\n$ ${cmd}\n`);
-    if ((await run(cmd, [], { cwd: root, shell: true }, fd)) !== 0) {
-      ok = false;
-      break;
-    }
+    exit = await run(cmd, [], { cwd: root, shell: true }, fd);
+    if (!passed(exit)) break;
   }
   measured[unit.key] = Date.now() - unit.start;
-  return ok;
+  return exit;
 }
 
 let finished = 0;
@@ -183,18 +217,25 @@ async function runUnit(unit) {
   const part = path.join(logDir, `${unit.id}.part.log`);
   const fd = fs.openSync(part, 'w');
   unit.start = Date.now();
-  let ok = false;
+  let exit = { code: 1, signal: null };
+  let dead = '';
   try {
-    ok = await (unit.files ? runShard(unit, fd) : runCommands(unit, fd));
+    exit = await (unit.files ? runShard(unit, fd) : runCommands(unit, fd));
+    if (unit.files) {
+      dead = deadShardReport(unit, exit, fs.readFileSync(part, 'utf8'));
+      if (dead) fs.writeSync(fd, `\n${dead}`);
+    }
   } finally {
     fs.closeSync(fd);
     unit.end = Date.now();
     fs.appendFileSync(laneLog(unit.lane), fs.readFileSync(part));
     fs.rmSync(part);
   }
+  const ok = passed(exit);
   console.log(
-    `[gate:local] ${ok ? 'ok  ' : 'FAIL'} ${unit.id} ${((unit.end - unit.start) / 1000).toFixed(1)}s (${++finished}/${units.length})`
+    `[gate:local] ${ok ? 'ok  ' : 'FAIL'} ${unit.id} ${((unit.end - unit.start) / 1000).toFixed(1)}s (${++finished}/${units.length})${ok ? '' : ` ${ending(exit)}`}`
   );
+  if (dead) process.stdout.write(dead);
   return ok;
 }
 
@@ -209,7 +250,9 @@ try {
   // The next run plans from these; work this run did not reach keeps its old time.
   const keys = [...testLanes.flatMap((lane) => lane.files.map(lane.key)), ...commandUnits.map((unit) => unit.key)];
   const next = Object.fromEntries(
-    keys.filter((key) => (measured[key] ?? history[key]) !== undefined).map((key) => [key, measured[key] ?? history[key]])
+    keys
+      .filter((key) => (measured[key] ?? history[key]) !== undefined)
+      .map((key) => [key, measured[key] ?? history[key]])
   );
   const saveError = historyPath && saveTimingHistory(historyPath, next);
   if (saveError) console.warn(`[gate:local] warning: timings not saved (${saveError.message})`);
@@ -232,7 +275,10 @@ for (const name of laneNames) {
     .filter((l) => /\[failure-summary\] (?:RUN FAILED|HUNG|FAILED|FLAKY)/.test(l));
   for (const l of lines) console.log(`    ${l}`);
 }
-if (notStarted.length) console.log(`Stopped after a failed ${units.find((u) => u.stopOnFail && u.ok === false).lane} check: ${notStarted.length} unit(s) not run`);
+if (notStarted.length)
+  console.log(
+    `Stopped after a failed ${units.find((u) => u.stopOnFail && u.ok === false).lane} check: ${notStarted.length} unit(s) not run`
+  );
 console.log(
   'Not covered locally: runtime-macos, computer-backend, desktop-tests computer lane (Windows-only), relay, graph, patch, browser-import, mobile-scripts'
 );

package/scripts/graph-parity.mjs

@@ -6,6 +6,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { pathToFileURL } from 'node:url';
+import { spawnTreeKill } from '../src/runtime/agent/orchestrator/mcp/child-tree.mjs';
 import { median, sortedFinite } from './lib/trace-stats.mjs';
 
 const USAGE = `usage: node scripts/graph-parity.mjs --old <binary> --new <binary> [--root <dir>] [--files <rel>...] [--json <out>] [--kind-map <path.json>] [--tokens] [--allow-new-languages <ids>] [--max-symbol-loss N] [--max-import-diff N] [--max-token-loss N] [--max-time-ratio 1.10] [--runs 3]
@@ -925,15 +926,19 @@ function reusedMetaLine(rec) {
   });
 }
 
+// Windows: the shared, bounded creation-checked tree kill finds the
+// descendants while the root still runs; the root, owned and alive, is then
+// killed directly once that pass ends or runs out of time (spawnTreeKill).
 function killProcessTree(proc) {
+  if (process.platform === 'win32' && proc.pid && proc.exitCode === null && proc.signalCode === null) {
+    spawnTreeKill([proc.pid], { root: proc });
+    return;
+  }
   try {
     proc.kill();
   } catch {
     /* ignore */
   }
-  if (process.platform === 'win32' && proc.pid) {
-    spawn('taskkill', ['/pid', String(proc.pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
-  }
 }
 
 export function runProcess(bin, args, { stdinText = null, timeoutMs = SPAWN_TIMEOUT_MS } = {}) {

package/scripts/lib/gate-scheduler.mjs

@@ -31,7 +31,8 @@ export function gateTestBudget(argv = [], env = process.env, parallelism = avail
   if (index >= 0) explicit = argv[index].includes('=') ? argv[index].split('=')[1] : (argv[index + 1] ?? '');
   if (explicit === undefined) return Math.max(1, Math.min(DEFAULT_MAX_WORKERS, Math.floor(parallelism / 2)));
   const budget = Number(explicit);
-  if (!Number.isInteger(budget) || budget < 1) throw new Error(`gate test budget must be a positive integer (got "${explicit}")`);
+  if (!Number.isInteger(budget) || budget < 1)
+    throw new Error(`gate test budget must be a positive integer (got "${explicit}")`);
   return budget;
 }
 

package/scripts/lib/run-node-tests.mjs

@@ -29,6 +29,8 @@ const TEST_LOG_PREFIX = 'mixdog-test-output-';
 const TEST_FAILURES_PREFIX = 'mixdog-test-failures-';
 const TEST_SCRATCH_PREFIX = 'mixdog-test-scratch-';
 export const RUNNER_TEMP_PREFIXES = [TEST_LOG_PREFIX, TEST_FAILURES_PREFIX, TEST_SCRATCH_PREFIX];
+// Printed first by every run; the local gate finds a dead unit's log by it.
+export const FULL_LOG_LABEL = 'Full test log: ';
 
 // Batches keep the file order Node was given; a single path larger than the
 // budget still gets its own batch rather than being dropped. An empty list
@@ -142,11 +144,19 @@ function capture(command, args) {
   });
 }
 
-// Kills a process and every descendant still linked to it. On POSIX a batch
-// leads its own process group (spawned detached), so the group goes with it.
+// Kills a live batch and every descendant still linked to it (on Windows the
+// shared creation-checked tree kill). On POSIX a batch leads its own process
+// group (spawned detached), so the group goes with it.
+// Loaded only when a Windows kill runs, so importers that need just this
+// module's constants (the local gate) do not pull in the runtime.
+async function loadKillProcessTrees() {
+  const { killProcessTrees } = await import('../../src/runtime/agent/orchestrator/mcp/child-tree.mjs');
+  return killProcessTrees;
+}
+
 async function killTree(pid) {
   if (process.platform === 'win32') {
-    await capture('taskkill', ['/T', '/F', '/PID', String(pid)]);
+    await (await loadKillProcessTrees())([pid]);
     return;
   }
   for (const target of [-pid, pid]) {
@@ -284,12 +294,14 @@ async function reapLeftovers(child, { batch, ledger, scratchDir }) {
 }
 
 async function killOwned(anchors, { scratchDir }) {
+  // Every owned process ran when the snapshot was taken.
+  const snapshotAt = Date.now();
   const leftovers = ownedProcesses(await processSnapshot(), anchors, { scratchDir });
   if (leftovers.length === 0) return;
   const pids = leftovers.map((entry) => entry.pid);
   console.error(`Killing ${pids.length} process(es) a test left running: ${pids.join(' ')}`);
   if (process.platform === 'win32') {
-    await capture('taskkill', ['/T', '/F', ...pids.flatMap((pid) => ['/PID', String(pid)])]);
+    await (await loadKillProcessTrees())(pids, { aliveAt: snapshotAt });
     return;
   }
   for (const pid of pids) {
@@ -387,7 +399,7 @@ export async function runNodeTests(nodeArgs, fileArgs, options = {}) {
   pruneStaleTempDirs(RUNNER_TEMP_PREFIXES);
   const outputDir = await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX));
   const logPath = join(outputDir, 'full.log');
-  console.error(`Full test log: ${logPath}`);
+  console.error(`${FULL_LOG_LABEL}${logPath}`);
   // Failure records live outside the log directory: the log directory holds
   // exactly one merged log, and these records are an internal artifact.
   const failureDir = await mkdtemp(join(tmpdir(), TEST_FAILURES_PREFIX));

package/scripts/lib/test-failure-summary.mjs

@@ -50,14 +50,7 @@ export function policyLine(rerunFailed) {
 // never "0 failed". `pids` names the node --test processes that exited
 // non-zero, so a kill can be matched to the "Killing ... <pid>" line of
 // whatever killed them.
-export function formatFailureSummary({
-  failed = [],
-  flaky = [],
-  rerunFailed = 0,
-  hung = [],
-  exitCode = 0,
-  pids = [],
-}) {
+export function formatFailureSummary({ failed = [], flaky = [], rerunFailed = 0, hung = [], exitCode = 0, pids = [] }) {
   const hungCount = hung.length > 0 ? `, ${hung.length} hung batch(es)` : '';
   const unexplained = exitCode !== 0 && failed.length === 0 && hung.length === 0;
   const runner = pids.length > 0 ? `node --test pid ${pids.join(' ')}: ` : '';

package/scripts/lib/test-spawn-ledger.mjs

@@ -5,8 +5,10 @@
 // nothing.
 import { ChildProcess } from 'node:child_process';
 import { appendFileSync, readFileSync } from 'node:fs';
+import { constants } from 'node:os';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { getSystemErrorMap } from 'node:util';
 import { FAILURE_RECORDS_ENV, spawnLedgerPath } from './test-failure-records.mjs';
 
 // --test-force-exit ends a test file's process once every test registered so
@@ -60,14 +62,43 @@ if (ledger) {
   // comes before the child's handle is closed, so the pid is still this
   // child's when the exit is written: from then on another process may hold it.
   const spawn = ChildProcess.prototype.spawn;
+  const exited = new Set();
   ChildProcess.prototype.spawn = function recordedSpawn(...args) {
     const before = Date.now();
     const result = spawn.apply(this, args);
     if (this.pid) {
-      const spawned = `${this.pid} ${before} ${Date.now()}`;
+      const { pid } = this;
+      exited.delete(pid);
+      const spawned = `${pid} ${before} ${Date.now()}`;
       appendFileSync(ledger, `${spawned}\n`);
-      this.once('exit', () => appendFileSync(ledger, `${spawned} ${Date.now()}\n`));
+      this.once('exit', () => {
+        exited.add(pid);
+        appendFileSync(ledger, `${spawned} ${Date.now()}\n`);
+      });
     }
     return result;
   };
+  // Once a child's exit is seen its pid is free, and Windows hands it to the
+  // next process started within moments — on a loaded gate often a parallel
+  // unit's test runner, node --test batch or test file process. A cleanup that
+  // signals every pid it recorded (e.g. `after(() => process.kill(pid))`, or a
+  // kill(pid, 0) liveness poll) then terminates that process instead, and the
+  // whole unit dies without output. Such a signal fails ESRCH here, as for a
+  // gone process, and never reaches whatever holds the pid now. Arguments Node
+  // rejects (a non-integer pid, an unknown signal) still go to Node, which
+  // throws before any signal is sent; this rejects only what it would send.
+  const kill = process.kill;
+  const [ESRCH] = [...getSystemErrorMap()].find(([, [name]]) => name === 'ESRCH');
+  const sendable = (signal) => signal === (signal | 0) || Boolean(constants.signals[signal || 'SIGTERM']);
+  process.kill = function killLiveChildOnly(pid, signal) {
+    // Only a primitive pid is checked: coercing an object would run its
+    // valueOf before Node's own coercion does. Number(pid) === (pid | 0) is
+    // Node's `pid == (pid | 0)` integer check.
+    const primitive = typeof pid === 'number' || typeof pid === 'string';
+    if (primitive && Number(pid) === (pid | 0) && exited.has(pid | 0) && sendable(signal)) {
+      // The shape of Node's own failed kill (an ErrnoException).
+      throw Object.assign(new Error('kill ESRCH'), { errno: ESRCH, code: 'ESRCH', syscall: 'kill' });
+    }
+    return kill.call(process, pid, signal);
+  };
 }

package/scripts/post-release-check.mjs

@@ -87,9 +87,12 @@ export async function checkFeed({ text, label, version, assets, hashAsset, requi
   for (const name of requiredFiles) {
     if (!byUrl.has(name)) problems.push(`${label}: files[] does not list ${name}`);
   }
+  // Every listed asset downloads at once; the problems keep files[] order.
+  const fileAssets = feed.files.map((file) => assets.find((candidate) => candidate.name === file.url));
+  const digests = await Promise.all(fileAssets.map((asset) => (asset ? hashAsset(asset) : null)));
   const hashes = new Map();
-  for (const file of feed.files) {
-    const asset = assets.find((candidate) => candidate.name === file.url);
+  for (const [index, file] of feed.files.entries()) {
+    const asset = fileAssets[index];
     if (!asset) {
       problems.push(`${label}: ${file.url} is not an uploaded asset`);
       continue;
@@ -99,7 +102,7 @@ export async function checkFeed({ text, label, version, assets, hashAsset, requi
       problems.push(`${label}: ${file.url} size ${size} != uploaded ${asset.size}`);
     }
     const sha512 = field(file, 'sha512');
-    const actual = await hashAsset(asset);
+    const actual = digests[index];
     hashes.set(file.url, actual);
     if (sha512 !== actual) problems.push(`${label}: ${file.url} sha512 does not match the uploaded asset`);
   }
@@ -233,6 +236,25 @@ export async function detectPublished({ fetchRelease, sleep = defaultSleep, atte
   }
 }
 
+/**
+ * Run independent `[name, run]` sections concurrently. Results keep the
+ * section order; a thrown section becomes a "check failed" problem.
+ */
+export function runSections(sections) {
+  return Promise.all(
+    sections.map(async ([name, run]) => {
+      try {
+        const outcome = await run();
+        return Array.isArray(outcome)
+          ? { name, problems: outcome, warnings: [] }
+          : { name, problems: outcome.problems, warnings: outcome.warnings };
+      } catch (error) {
+        return { name, problems: [`check failed: ${error.message}`], warnings: [] };
+      }
+    })
+  );
+}
+
 async function sha512Base64(url) {
   const response = await fetch(url, { redirect: 'follow' });
   if (!response.ok) throw new Error(`download ${url} answered ${response.status}`);
@@ -290,19 +312,7 @@ async function main() {
     ],
     ['npm', () => waitForNpm({ name: 'mixdog', version })],
   ];
-  const results = [];
-  for (const [name, run] of sections) {
-    try {
-      const outcome = await run();
-      results.push(
-        Array.isArray(outcome)
-          ? { name, problems: outcome, warnings: [] }
-          : { name, problems: outcome.problems, warnings: outcome.warnings }
-      );
-    } catch (error) {
-      results.push({ name, problems: [`check failed: ${error.message}`], warnings: [] });
-    }
-  }
+  const results = await runSections(sections);
 
   const lines = [`## Post-release check for ${tag}`, ''];
   for (const { name, problems, warnings } of results) {

package/scripts/provider-pingpong-live.mjs

@@ -10,7 +10,7 @@
 // stores. Only the API-key secrets (`secrets/agent.<provider>.apiKey.dpapi`) and the
 // `agent` section of mixdog-config.json are copied in. OAuth providers (`*-oauth`, whose
 // refresh tokens could be rotated) are skipped unless `--real-data` is passed, which
-// restores the old behaviour of running against the real data dir. The isolated dir is
+// runs against the real data dir instead. The isolated dir is
 // deleted at the end, after stopping only processes whose executable lives inside it.
 // Usage: node scripts/provider-pingpong-live.mjs [--suite extended] [--real-data] [case-name ...]
 import fs from 'node:fs';

package/scripts/prune-embedding-runtime.mjs

@@ -118,7 +118,9 @@ export async function pruneEmbeddingRuntime(packageRoot, options = {}) {
       }
     }
   }
-  await removeChildrenExcept(ortRoot, new Set(['package.json', 'dist', 'bin', 'node_modules']));
+  // npm runs onnxruntime-node's own postinstall (node ./script/install)
+  // concurrently with ours, so its script/ helpers must survive the prune.
+  await removeChildrenExcept(ortRoot, new Set(['package.json', 'dist', 'bin', 'node_modules', 'script']));
 
   // The Node bundle marks onnxruntime-web as an ignored webpack external. Keep
   // only its manifest so npm's dependency inventory remains coherent.

package/scripts/release-paths.mjs

@@ -51,7 +51,13 @@ const PATCH_GATE_FILES = [
 // workflow, output-style and bundled-skill trees (scripts/build-shipped-history.mjs)
 // and committed under src/defaults/. Release re-checks it, so the gate checks
 // it first instead of letting a stale file fail the deploy late.
-const HISTORY_GATE_PREFIXES = ['src/agents/', 'src/workflows/', 'src/output-styles/', 'src/defaults/'];
+const HISTORY_GATE_PREFIXES = [
+  'src/agents/',
+  'src/workflows/',
+  'src/output-styles/',
+  'src/orchestration/',
+  'src/defaults/',
+];
 const HISTORY_GATE_FILES = [
   'scripts/build-shipped-history.mjs',
   'src/runtime/shared/shipped-definitions.mjs',

package/src/defaults/shipped-history.json

@@ -179,6 +179,20 @@
       "d5f205f3b57c0b9541b8acc237069287"
     ]
   },
+  "orchestration": {
+    "balanced.md": [
+      "ad1683ff1626ebabd4e027abe03fe29a"
+    ],
+    "focused.md": [
+      "e73b0d71f544900611b2d06f963472d4"
+    ],
+    "none.md": [
+      "9be4bf61f9ba91c4caf53296adff2e8a"
+    ],
+    "swarm.md": [
+      "7fa3e68e0c53d16203384f5ca645765d"
+    ]
+  },
   "skills": {
     "browser-use": [
       "00085086a7649ec6631f5cf0a3bbbf60",
@@ -368,6 +382,7 @@
     ],
     "setup": [
       "0357c6d475ced8ba2446e6bda21899b4",
+      "0bb692f16b03c66f23af06cea06de51f",
       "0be31b379e919420e5b8f74926bdf6e5",
       "0d5c8c6e2349addf71d2ed2b4c1ccb1f",
       "0d6926aaca2890da9347f15a826546e3",
@@ -378,7 +393,9 @@
       "242f11864abdef90fa0cc9cb4599a579",
       "29a347c4d3a2f773fa92c627260301ba",
       "336ced846a9e4f774cbb109417856c3b",
+      "34c5f8fcb6292b8cc5239667d2119e83",
       "3716b2d2c2d973ae022694ed5cb756ad",
+      "398958b6f815bf8ad3f96dd288844333",
       "3dc990c29cdce1aca4b112d735ad5917",
       "3f72247651ad9d777b6754bfd46732aa",
       "50bdf35d06913236855080fdea6b50dc",
@@ -397,6 +414,7 @@
       "8b829db6b0675b62a71a1432dbd25490",
       "99d76213e70c6900d6af48ffa4045886",
       "9a2188ce201e4394bc18182131b7a3e1",
+      "9b10b59b27497a126b212df083ace020",
       "9f90d3872b1ecd312977ce661b770b31",
       "ade615dd0f6ae6ed1601023e5b9cb692",
       "b21681ecfeb523c0d7dd89a299ec05a9",
@@ -417,9 +435,11 @@
       "ff18ac1a9f5961925aec27ffb870bae0"
     ],
     "setup-guide": [
+      "0968139f1aa26f48f03cfea2e94f45e8",
       "633e15b84dbe22f2b578b67cc35853d4",
       "72e474711ecd18cfcae6c8365e08286e",
       "920d5b29ccfe6c88f623cf0892b29285",
+      "dbe3d22991ad4dff6e3906f9101c9b5f",
       "ec88a82ab5e511c0afb1738162150648",
       "fa355d4ea5f1823e4b75219ab842c34a"
     ],

package/src/defaults/skills/setup/SKILL.md

@@ -80,8 +80,8 @@ that a call returned without transport error.
 Setup changes settings; it does not stop work. Use the tool that owns it:
 `session` `cancel` (another session's turn, a routine run in a bot's chat, a
 group room's exchange; a Browser/Computer takeover ends with its turn),
-`agent` `cancel`/`close` (sub-agents), `task` (background shell jobs), `goal`
-`pause` (an active Goal, at the user's request). Setup only prevents more: `set_automation_enabled false`
+`agent` `cancel`/`close` (sub-agents), `task` (background shell jobs); an
+active Goal is paused or stopped by the user from its controls. Setup only prevents more: `set_automation_enabled false`
 (future routine runs), `fallbacks: []` (further hops), `cancel_quota_resume`,
 `set_builtin_enabled` browser/computer off.
 

package/src/defaults/skills/setup/references/actions.md

@@ -79,7 +79,7 @@ Read this when choosing a `setup` mutation.
 | Create a workflow, agent, or machine-global user skill | `create_definition` |
 | Partially edit a workflow, agent, or machine-global user skill | `save_definition` |
 | Delete a user workflow/agent definition or override | `delete_definition` |
-| Save a schedule/webhook; explicitly overwrite to edit. A new one belongs to the calling thread's agent (Mixy = `lead`); `entry.owner` moves it to another agent | `save_automation` |
+| Save a schedule/webhook; explicitly overwrite to edit. A new one belongs to the calling thread's agent (Mixy = `lead`); `entry.owner` moves it to another agent; `entry.executorAgentId` names the workflow sub-agent that carries out each run first (`null`/`""` clears it) | `save_automation` |
 | Delete an existing schedule/webhook | `delete_automation` |
 | Enable/disable (pause/resume) a schedule/webhook | `set_automation_enabled` |
 | Run a schedule once now, or re-run a webhook on its latest received payload; the result posts into the owning agent's thread | `run_automation` |
@@ -377,8 +377,10 @@ markers are read with `status desktop`.
   (an imported theme id from `status appearance` `colorThemes`, or `"builtin"`).
   Also `timeFormat` (system|12h|24h), `sidePanelPosition` (right|bottom|auto),
   `uiScale` (0.85–1.2, step 0.05), `codeSize` (10–20), `codeLigatures`
-  (bool) and `chatTextSize` (small|default|large|extra-large). The UI label
-  "Light" is `theme: "white"`.
+  (bool) and `chatTextSize` (small|default|large|extra-large). Also
+  `composerStyle` (simple|basic|detail; the UI label "Normal" is `basic`) and
+  `questionAnswerConfirm` (bool: a single-choice pick waits for Send/Next).
+  The UI label "Light" is `theme: "white"`.
   Importing, exporting or removing a theme file and choosing a skin picture
   or its plate/accent/photo stay in the UI.
 - `set_desktop_settings` `desktop.botOverlay` takes `enabled`, `position`
@@ -406,6 +408,17 @@ markers are read with `status desktop`.
   active is skipped. In an attended bot conversation (chat, room, or work a
   bot started) the same payment and permanent-delete connectors ask first,
   allow once or deny only; a coding session is not asked.
+- `entry.executorAgentId` (schedule or webhook) is an enabled workflow
+  sub-agent id (Worker, …; never a bot or Mixy; unknown or turned-off ids are
+  refused). With it, each run is first carried out by that sub-agent on its own
+  route, unattended like the bot's own run (never asks, payments and permanent
+  deletes refused, no task sessions), and only its final report reaches the
+  owner bot, which relays it in its own words; a report that is exactly
+  `ROUTINE_QUIET` wakes nobody. If the sub-agent is later removed or turned
+  off, the run fails with that error instead of falling back. Without it the
+  owner bot does the work itself. Set it for recurring work a sub-agent suits;
+  leave it unset for trivial chat-only routines. `overwrite:true` keeps it
+  when omitted.
 - Enabling or creating automation may start its background worker. This is a
   persisted automation change, not permission to run an unrelated task now.
 

package/src/defaults/skills/setup/references/surfaces.md

@@ -121,6 +121,9 @@ The setup tool does not mutate:
   per-device view state;
 - MCP server OAuth sign-in and sign-out (Desktop MCP list/editor, TUI
   `/mcp login` and `/mcp logout`; remote windows paste the redirect address);
+- the Delegation and Output style instruction texts (Settings → Delegation /
+  Output style; revision-checked free text — `set_output_style` only chooses
+  the active style);
 - notification permission and subscription on the receiving device;
 - web-app pairing credentials and OS permission dialogs;
 - TUI-local theme palettes (use `/theme`; Desktop themes are separate);

package/src/defaults/skills/setup-guide/SKILL.md

@@ -171,7 +171,12 @@ step; do not insist.
   addresses one bot; otherwise the Maintainer decides who answers next.
 - Schedules and webhooks: a timed or incoming-event trigger (`save_automation`).
   Each run is one turn in its bot's own chat, with that bot's persona, rules,
-  permissions, memory and model. Without a bot they cannot be used.
+  permissions, memory and model. Without a bot they cannot be used. A routine
+  can also name an executor sub-agent (`executorAgentId`, e.g. Worker): that
+  sub-agent does each run on its own model and the bot only relays its report.
+  In the Schedules/Webhooks editor this is the "Executor" field (Korean UI:
+  "실행 에이전트"); its default "The bot itself" ("직접 처리") means the bot
+  does the run itself.
 - Approval cards: when a tool needs permission it waits in the chat until the
   user approves or declines.
 - Phone remote access: pair a phone under Settings → Connection to follow and