company-skill 4.6.6 → 4.6.7

package/README.md

@@ -33,12 +33,15 @@ Optionally define your team first in `COMPANY.md` (skip it and a minimal company
 
 Every criterion starts failing. Workers run in dependency waves under delegation contracts. At the end of each cycle, the Internal Reviewer re-runs every VERIFY-WITH command and the Devil's Advocate attacks everything marked passing. The stop guard physically blocks exit until every criterion has `passes: true` with reproduced evidence. Once done, `STATUS.md` and a `playbook.md` update are written for the next session.
 
-```
-GOAL -> THINK -> EXECUTE (parallel waves) -> VERIFY -> Done?
-                                                 |         |
-                                               COMPRESS  STATUS.md
-                                                 |
-                                               THINK (next cycle)
+```mermaid
+flowchart TD
+    GOAL --> THINK
+    THINK --> EXECUTE["EXECUTE (parallel waves)"]
+    EXECUTE --> VERIFY
+    VERIFY -->|all criteria pass| DONE["Done (STATUS.md + playbook)"]
+    VERIFY -->|not done| COMPRESS
+    COMPRESS --> NEXT["THINK (next cycle)"]
+    NEXT --> EXECUTE
 ```
 
 **Roles:** CEO orchestrator, Internal Reviewer, Devil's Advocate, Digest Writer. The orchestrator reads `COMPANY.md`, activates only the roles the goal needs, and writes delegation contracts in dependency order. Workers append FINDING + SOURCE lines to findings files. The Digest Writer compresses each finished cycle into the next cycle's briefing so the orchestrator never carries raw worker output in its own context.
@@ -65,6 +68,29 @@ What you see, panel by panel:
 The dashboard binds 127.0.0.1 only, reads local files, and sends nothing anywhere. Override the port with `COMPANY_DASHBOARD_PORT`.
 
 
+## Unattended auto-restart loop
+
+`scripts/company-autoloop.js` runs `/company` unattended across many sessions. It restarts into a fresh context automatically when a work session approaches the context threshold, so a long goal keeps going without a human pasting the restart prompt each time.
+
+A script is needed because a fully unattended fresh-context restart cannot be done with Claude Code native features alone. Hooks cannot run `/clear` or start a fresh turn, a Stop-hook block keeps the same context, and auto-compaction only summarizes. The supervisor is the external driver that owns the restart decision. This is the validated finding.
+
+Each turn runs a headless `claude -p` session while the supervisor watches the session context fill. At the threshold it drives `/company restart` to emit the `NEXT.md` continuation, then launches a fresh session seeded from it.
+
+```bash
+node scripts/company-autoloop.js --max-turns 100 "/company GOAL: <your goal>"
+```
+
+Key flags and env:
+
+- `--project-dir <path>` the project the run targets (default: current dir)
+- `--company-dir <path>` override the `.company` dir (default: `<project-dir>/.company`)
+- `--max-turns <n>` hard cap on work turns across all sessions (default: 100)
+- `--restart-timeout-secs <n>` max wait for the restart markers (default: 420)
+- `COMPANY_CONTEXT_THRESHOLD` fill fraction or percent that triggers a restart (default: 0.50, set a low value for testing)
+
+It runs with `--permission-mode bypassPermissions` for the autonomy an unattended loop needs. The threshold is configurable, so you can drop it low to exercise the restart path during testing.
+
+
 ## Cost and quality
 
 Multi-agent orchestration buys quality with tokens. /company's answer to the token cost: spend strong-model tokens only where they buy quality, and report the bill every cycle.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "company-skill",
-  "version": "4.6.6",
+  "version": "4.6.7",
   "description": "Goal-driven multi-employee company for Claude Code. Give it a goal, it runs until done.",
   "bin": {
     "company-skill": "./bin/install.js"
@@ -22,6 +22,7 @@
     "scripts/check-contracts.js",
     "scripts/check-findings.js",
     "scripts/restart-debate.js",
+    "scripts/company-autoloop.js",
     "scripts/dashboard.js",
     "scripts/secret-scan.js",
     "scripts/reset-company-guard.js",
@@ -35,7 +36,22 @@
     "README.md",
     "LICENSE"
   ],
-  "keywords": ["claude-code", "skill", "multi-agent", "company", "orchestration", "model-agnostic", "autonomous-agents", "stop-hook", "agent-orchestration", "ai-agents", "fable", "claude-fable", "mythos", "claude-mythos"],
+  "keywords": [
+    "claude-code",
+    "skill",
+    "multi-agent",
+    "company",
+    "orchestration",
+    "model-agnostic",
+    "autonomous-agents",
+    "stop-hook",
+    "agent-orchestration",
+    "ai-agents",
+    "fable",
+    "claude-fable",
+    "mythos",
+    "claude-mythos"
+  ],
   "author": "jagmarques",
   "license": "MIT",
   "repository": {

package/scripts/company-autoloop.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+// company-autoloop.js - External supervisor for /company auto-restart cycles.
+//
+// WHY THIS IS A SEPARATE SCRIPT (not native hooks):
+//   A fully unattended detect->restart->fresh-context loop is IMPOSSIBLE with
+//   Claude Code native features alone. Stop-hook decision:block keeps the SAME
+//   context (does not reset). /clear is interactive-only. Auto-compaction
+//   summarizes in-session, never resets. Fresh context requires a NEW process
+//   invocation - i.e. this external script. See auto-restart-research.md.
+//
+// VALIDATED HEADLESS REALITY (orchestrator real 1% runs, 2026-06-13):
+//   A headless `claude -p` session does NOT self-trigger /company restart. The
+//   company Stop guards (stop-guard, context-guard) are effectively INTERACTIVE
+//   ONLY: a -p session completes its turn and EXITS regardless of decision:block,
+//   so it never writes NEXT.md / RESTART_DEBATE_CONFIRMED on its own. The earlier
+//   "wait for the child to self-restart" premise was therefore WRONG for headless.
+//   THE FIX, PROVEN LIVE: the supervisor must DRIVE the restart. Running
+//   `claude -p --resume <sessionId> "/company restart"` executes restart mode
+//   headlessly and writes NEXT.md (+ RESTART_DEBATE_CONFIRMED after the full
+//   3-role debate). So the supervisor owns the threshold decision itself.
+//
+// HOW IT WORKS (threshold-driven, restart-via-resume):
+//   One logical run is MANY sessions. The supervisor tracks the work session's
+//   context FILL itself (the guards do not fire headless) and drives turns until
+//   the threshold is crossed, then drives a /company restart for fresh context.
+//     1. Fresh session: spawn `claude -p --session-id <uuid> ... "<goal-or-NEXT>"`.
+//        Continuation of the SAME session under threshold: `--resume <uuid>`.
+//        Each -p call runs to completion and exits (expected headless behavior).
+//     2. After a turn: CANCEL -> exit 0. Goal done (criteria all pass) -> exit 0.
+//     3. Compute fill from the transcript jsonl (last assistant usage block) and
+//        the model window. Log it.
+//     4. fill >= threshold: DRIVE `claude -p --resume <uuid> "/company restart"`
+//        ASYNC (do not await its exit - the company stop-guard blocks its stop so
+//        a headless restart invocation does NOT exit on its own), CONCURRENTLY
+//        poll for RESTART_DEBATE_CONFIRMED + a fresh NEXT.md, then KILL the restart
+//        process group and seed a NEW --session-id from NEXT.md. THIS is the
+//        fresh-context handoff.
+//     5. fill < threshold: continue the SAME session another turn via --resume.
+//
+//   --resume is used in exactly two legitimate places: continuing the same work
+//   session under threshold, and driving /company restart on that session. The
+//   fresh continuation AFTER a restart is ALWAYS a brand-new --session-id seeded
+//   from NEXT.md. --continue is NEVER used, and --resume NEVER carries work into a
+//   new logical cycle - that handoff is always a new session id.
+//
+// USAGE:
+//   node scripts/company-autoloop.js [options] "<goal>"
+//   node scripts/company-autoloop.js [options] --prompt-file /path/to/goal.txt
+//
+// OPTIONS:
+//   --project-dir <path>   Project dir the /company run targets (default: cwd)
+//   --company-dir <path>   Override .company dir (default: <project-dir>/.company)
+//   --max-turns <n>        Hard cap on work turns across all sessions (default: 100)
+//   --permission-mode <m>  claude --permission-mode value (default: bypassPermissions)
+//   --prompt-file <path>   Read initial goal from file instead of CLI arg
+//   --restart-timeout-secs <n>  Max wait for restart markers after driving it (default: 420)
+//   --turn-timeout-secs <n>  Wall-clock backstop kill for a single work turn (default: 900)
+//   --projects-dir <path>  Override the ~/.claude/projects transcript root (testing)
+//   --help                 Show this message
+//
+// ENV:
+//   CLAUDE_BIN                 Path to the claude binary (default: claude)
+//   COMPANY_DIR                Overrides --company-dir
+//   COMPANY_TRANSCRIPT_DIR     Overrides the transcript projects root (testing)
+//   COMPANY_CONTEXT_THRESHOLD  Fill fraction or percent that triggers restart (default: 0.50)
+//   COMPANY_CONTEXT_WINDOW     Force the context window size (overrides model detection)
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { randomUUID } = require('node:crypto');
+const { spawn } = require('node:child_process');
+
+// ---------- arg parsing ----------
+const argv = process.argv.slice(2);
+
+function argValue(flag) {
+  const i = argv.indexOf(flag);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : null;
+}
+
+function hasFlag(flag) {
+  return argv.indexOf(flag) !== -1;
+}
+
+if (hasFlag('--help') || hasFlag('-h')) {
+  process.stdout.write(fs.readFileSync(__filename, 'utf8').split('\n')
+    .filter(l => l.startsWith('//'))
+    .map(l => l.slice(3))
+    .join('\n') + '\n');
+  process.exit(0);
+}
+
+const projectDir = path.resolve(argValue('--project-dir') || process.cwd());
+const companyDirArg = argValue('--company-dir');
+// COMPANY_DIR env wins, then --company-dir, then <projectDir>/.company
+const companyDir = path.resolve(
+  process.env.COMPANY_DIR || companyDirArg || path.join(projectDir, '.company')
+);
+
+const maxTurns = parseInt(argValue('--max-turns') || '100', 10);
+const permissionMode = argValue('--permission-mode') || 'bypassPermissions';
+const promptFile = argValue('--prompt-file');
+const restartTimeoutSecs = parseInt(argValue('--restart-timeout-secs') || '420', 10);
+// Generous wall-clock backstop: kills a work turn that never exits (model looping
+// on a blocked stop). Tuned NOT to kill legitimate long work - natural exit is the
+// primary end of a turn, this is only a last resort.
+const turnTimeoutSecs = parseInt(argValue('--turn-timeout-secs') || '900', 10);
+const claudeBin = process.env.CLAUDE_BIN || 'claude';
+
+// Transcript projects root: env wins, then --projects-dir, then ~/.claude/projects.
+const projectsDir = process.env.COMPANY_TRANSCRIPT_DIR ||
+  argValue('--projects-dir') ||
+  path.join(os.homedir(), '.claude', 'projects');
+
+// Positional goal: last non-flag arg that is not a flag value
+let goalArg = null;
+const flagsWithValues = new Set([
+  '--project-dir', '--company-dir', '--max-turns',
+  '--permission-mode', '--prompt-file', '--restart-timeout-secs',
+  '--turn-timeout-secs', '--projects-dir',
+]);
+for (let i = 0; i < argv.length; i++) {
+  if (flagsWithValues.has(argv[i])) { i++; continue; }
+  if (argv[i].startsWith('--')) continue;
+  goalArg = argv[i];
+}
+
+function readInitialPrompt() {
+  if (promptFile) {
+    try {
+      return fs.readFileSync(promptFile, 'utf8').trim();
+    } catch (e) {
+      die('Cannot read --prompt-file ' + promptFile + ': ' + e.message);
+    }
+  }
+  if (goalArg) return goalArg.trim();
+  die('No goal provided. Pass a goal string or --prompt-file <path>.');
+}
+
+// ---------- helpers ----------
+function log(msg) {
+  const ts = new Date().toISOString();
+  process.stderr.write('[autoloop ' + ts + '] ' + msg + '\n');
+}
+
+function die(msg) {
+  process.stderr.write('ERROR: ' + msg + '\n');
+  process.exit(1);
+}
+
+function sleep(ms) {
+  return new Promise(function (resolve) { setTimeout(resolve, ms); });
+}
+
+// ---------- state file paths ----------
+const nextMdPath = path.join(companyDir, 'NEXT.md');
+const cancelPath = path.join(companyDir, 'CANCEL');
+const criteriaPath = path.join(companyDir, 'criteria.json');
+const debateConfirmedPath = path.join(companyDir, 'RESTART_DEBATE_CONFIRMED');
+
+// ---------- goal-done check ----------
+// Real criteria.json is an object {goal, criteria:[{passes:bool,...}]}.
+// Accept both shapes: parsed.criteria array, or a bare top-level array.
+// An entry is done when passes === true (primary) or status done/pass (legacy).
+// Empty/missing criteria, or a parse error: not done.
+function isGoalDone() {
+  try {
+    const raw = fs.readFileSync(criteriaPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    let list;
+    if (parsed && Array.isArray(parsed.criteria)) {
+      list = parsed.criteria;
+    } else if (Array.isArray(parsed)) {
+      list = parsed;
+    } else {
+      return false;
+    }
+    if (list.length === 0) return false;
+    return list.every(function (c) {
+      if (c && c.passes === true) return true;
+      const s = (c && c.status ? String(c.status) : '').toLowerCase();
+      return s === 'done' || s === 'pass';
+    });
+  } catch (e) {
+    return false;
+  }
+}
+
+// ---------- context-window detection (mirrors hooks/context-guard.js) ----------
+// Known 1M-context model id substrings. Unknown/null defaults to 1M (fail-open),
+// matching the guard so the supervisor never false-fires a restart on an unknown id.
+const KNOWN_1M_SUBSTRINGS = [
+  '[1m]',
+  'claude-opus-4',
+  'claude-opus-4-5',
+  'claude-opus-4-8',
+];
+const DEFAULT_WINDOW = 1000000;
+const WINDOW_200K = 200000;
+
+function is1MModel(modelId) {
+  if (!modelId) return true; // unknown defaults to 1M (fail-open)
+  const lower = modelId.toLowerCase();
+  for (let i = 0; i < KNOWN_1M_SUBSTRINGS.length; i++) {
+    if (lower.indexOf(KNOWN_1M_SUBSTRINGS[i]) !== -1) return true;
+  }
+  return false;
+}
+
+function detectWindow(modelId) {
+  const envVal = process.env.COMPANY_CONTEXT_WINDOW;
+  if (envVal) {
+    const n = parseInt(envVal, 10);
+    if (n > 0) return n;
+  }
+  return is1MModel(modelId) ? DEFAULT_WINDOW : WINDOW_200K;
+}
+
+function parseThreshold() {
+  const raw = process.env.COMPANY_CONTEXT_THRESHOLD;
+  if (!raw) return 0.50;
+  const v = parseFloat(raw);
+  if (isNaN(v)) return 0.50;
+  // accept either fraction (0.5) or percent (50)
+  return v > 1 ? v / 100 : v;
+}
+
+// Sum every token field that counts against the context window.
+// Matches the Claude Code status line: input + cache_read + cache_creation + output.
+function usedTokens(usage) {
+  return (usage.input_tokens || 0) +
+    (usage.cache_read_input_tokens || 0) +
+    (usage.cache_creation_input_tokens || 0) +
+    (usage.output_tokens || 0);
+}
+
+// ---------- locate a session transcript jsonl ----------
+// Sessions persist at ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl. The
+// encoded-cwd segment is not worth reconstructing by hand, so glob every project
+// dir for <sessionId>.jsonl and take the newest match. Returns null if missing.
+function findTranscript(sessionId) {
+  let entries;
+  try {
+    entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+  } catch (e) {
+    return null;
+  }
+  let best = null;
+  let bestMtime = -1;
+  for (let i = 0; i < entries.length; i++) {
+    if (!entries[i].isDirectory()) continue;
+    const candidate = path.join(projectsDir, entries[i].name, sessionId + '.jsonl');
+    let st;
+    try { st = fs.statSync(candidate); } catch (e) { continue; }
+    if (st.mtimeMs > bestMtime) { bestMtime = st.mtimeMs; best = candidate; }
+  }
+  return best;
+}
+
+// ---------- compute the work session's context fill ----------
+// Read the LAST assistant usage block from the session transcript, sum the token
+// fields, divide by the detected window. A missing transcript is not a crash: log
+// a warning and treat fill as 0 so the loop keeps making progress.
+function computeFill(sessionId) {
+  const transcript = findTranscript(sessionId);
+  if (!transcript) {
+    log('WARN no transcript found for session ' + sessionId + ' under ' + projectsDir +
+        ' - treating fill as 0');
+    return { fill: 0, used: 0, window: DEFAULT_WINDOW, modelId: null, transcript: null };
+  }
+  let lastUsage = null;
+  let lastModelId = null;
+  try {
+    const raw = fs.readFileSync(transcript, 'utf8');
+    const lines = raw.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch (e) { continue; }
+      const inner = msg.message || msg;
+      if (inner && inner.role === 'assistant' && inner.usage) {
+        lastUsage = inner.usage;
+        if (typeof inner.model === 'string') lastModelId = inner.model;
+        else if (typeof msg.model === 'string') lastModelId = msg.model;
+        break;
+      }
+    }
+  } catch (e) {
+    log('WARN could not read transcript ' + transcript + ': ' + e.message + ' - fill 0');
+    return { fill: 0, used: 0, window: DEFAULT_WINDOW, modelId: null, transcript };
+  }
+  if (!lastUsage) {
+    return { fill: 0, used: 0, window: DEFAULT_WINDOW, modelId: lastModelId, transcript };
+  }
+  const used = usedTokens(lastUsage);
+  const window = detectWindow(lastModelId);
+  return { fill: used / window, used, window, modelId: lastModelId, transcript };
+}
+
+// ---------- kill a child's whole process group (SIGTERM then SIGKILL) ----------
+// Children are spawned detached so each has its own process group (pgid === pid).
+// Signalling the negative pid hits the whole tree (e.g. restart's 3 debate
+// sub-agents), not just the top claude process. Best-effort: a gone group is fine.
+function killChildGroup(child, graceMs) {
+  if (!child || child.pid == null) return Promise.resolve();
+  const pgid = child.pid;
+  function signal(sig) {
+    try { process.kill(-pgid, sig); } catch (e) {
+      // Group already gone or never a group leader: fall back to the bare pid.
+      try { process.kill(pgid, sig); } catch (e2) {}
+    }
+  }
+  signal('SIGTERM');
+  return new Promise(function (resolve) {
+    let done = false;
+    function finish() { if (!done) { done = true; resolve(); } }
+    child.once('exit', finish);
+    setTimeout(function () { signal('SIGKILL'); finish(); }, graceMs || 1500);
+  });
+}
+
+// ---------- spawn one claude -p turn (async, caller owns the handle) ----------
+// freshSession=true seeds a NEW --session-id. Otherwise --resume the same id.
+// The prompt argument is the goal/NEXT on a fresh session, the continue nudge on
+// a resume, or "/company restart" for restart mode. Spawned DETACHED so the child
+// leads its own process group and the whole tree can be killed via killChildGroup.
+// stdout/stderr are drained so a full pipe never blocks the child. Returns the
+// child handle plus a `done` promise resolving with the exit result.
+function spawnTurn(opts) {
+  const spawnArgs = ['-p'];
+  if (opts.freshSession) spawnArgs.push('--session-id', opts.sessionId);
+  else spawnArgs.push('--resume', opts.sessionId);
+  spawnArgs.push(
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--include-hook-events',
+    '--permission-mode', permissionMode,
+    opts.prompt
+  );
+
+  const spawnEnv = Object.assign({}, process.env, { COMPANY_DIR: companyDir });
+  const mode = opts.freshSession ? '--session-id' : '--resume';
+  log('spawning: ' + claudeBin + ' -p ' + mode + ' ' + opts.sessionId +
+      (opts.label ? ' [' + opts.label + ']' : '') + ' ...');
+
+  const child = spawn(claudeBin, spawnArgs, {
+    cwd: projectDir,
+    env: spawnEnv,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  });
+
+  let stderrTail = '';
+  let stdoutBytes = 0;
+  child.stdout.on('data', function (d) { stdoutBytes += d.length; });
+  child.stderr.on('data', function (d) { stderrTail = (stderrTail + d.toString()).slice(-2000); });
+  child.stdout.on('error', function () {});
+  child.stderr.on('error', function () {});
+
+  const done = new Promise(function (resolve) {
+    child.on('error', function (e) {
+      log('turn spawn error: ' + e.message);
+      resolve({ code: 127, stdoutBytes: 0, stderrTail: e.message, killed: false });
+    });
+    child.on('exit', function (code, signalName) {
+      resolve({ code: code, stdoutBytes: stdoutBytes, stderrTail: stderrTail,
+        killed: signalName != null });
+    });
+  });
+
+  return { child: child, done: done };
+}
+
+// ---------- run one work turn with a wall-clock backstop ----------
+// Awaits natural exit (the expected headless behavior). If the turn never exits
+// within turnTimeoutSecs (model looping on a blocked stop, or a sub-agent holding
+// a pipe open), kill its process group and resolve a timed-out result. Once the
+// timer fires we mark this run as timed-out FIRST, so whichever settle wins (the
+// group-kill resolver OR the child exit event that the kill triggers) reports
+// timedOut:true. Without that flag the kill makes the child exit, handle.done
+// resolves with a plain code=143 result, that settle wins the race, and the main
+// loop misclassifies a killed-on-timeout turn as an error (real9 evidence). So the
+// flag is the source of truth for the timeout, not whichever exit path lands first.
+function runTurn(opts) {
+  const handle = spawnTurn(opts);
+  return new Promise(function (resolve) {
+    let settled = false;
+    let timedOut = false;
+    function settle(res) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      // The backstop owns the timeout classification: if the timer fired, this run
+      // is timed-out regardless of which exit path resolved it.
+      if (timedOut) res = Object.assign({}, res, { timedOut: true, killed: true });
+      resolve(res);
+    }
+    const timer = setTimeout(function () {
+      if (settled) return;
+      timedOut = true;
+      log('WARN work turn exceeded ' + turnTimeoutSecs + 's wall clock - killing it');
+      // Kill the detached process group (the work child AND its sub-agents), then
+      // resolve a timed-out result so the main loop proceeds to the fill check on
+      // the partial transcript. Do not wait on handle.done: resolve on our own.
+      killChildGroup(handle.child, 1500).then(function () {
+        settle({ code: null, stdoutBytes: 0, stderrTail: '', killed: true, timedOut: true });
+      });
+    }, turnTimeoutSecs * 1000);
+    handle.done.then(function (res) { settle(res); });
+  });
+}
+
+// ---------- drive a /company restart and wait for the handoff markers ----------
+// MONITOR-AND-KILL: the restart invocation is spawned ASYNC and NOT awaited. A
+// headless `claude -p "/company restart"` does NOT exit on its own (the company
+// stop-guard blocks its stop), so awaiting it would hang and the marker poll below
+// would never run (the real-world bug). Instead we poll CONCURRENTLY for
+// RESTART_DEBATE_CONFIRMED present AND a NEXT.md whose mtime is newer than the
+// restart start, then KILL the restart process group (its 3 debate sub-agents
+// included) and return NEXT.md. If the invocation exits on its own first (e.g. a
+// done goal), the markers are still evaluated. On timeout with no markers: kill
+// the invocation and return null.
+async function driveRestart(sessionId) {
+  const restartStart = Date.now();
+  // Clear any stale confirmed marker so we only react to THIS restart.
+  try { fs.unlinkSync(debateConfirmedPath); } catch (e) {}
+
+  const handle = spawnTurn({ sessionId: sessionId, freshSession: false,
+    prompt: '/company restart', label: 'company restart' });
+
+  // Track natural exit without awaiting it (a done goal can exit cleanly).
+  let exited = false;
+  handle.done.then(function () { exited = true; });
+
+  function readMarkers() {
+    let confirmed = false;
+    try { confirmed = fs.existsSync(debateConfirmedPath); } catch (e) {}
+    if (!confirmed) return null;
+    let freshNext = false;
+    try { freshNext = fs.statSync(nextMdPath).mtimeMs > restartStart; } catch (e) {}
+    if (!freshNext) return null;
+    let next = '';
+    try { next = fs.readFileSync(nextMdPath, 'utf8').trim(); } catch (e) {}
+    return next || null;
+  }
+
+  const deadline = restartStart + restartTimeoutSecs * 1000;
+  while (Date.now() < deadline) {
+    const next = readMarkers();
+    if (next) {
+      log('restart markers present - killing the restart invocation');
+      await killChildGroup(handle.child, 1500);
+      return next;
+    }
+    if (exited) {
+      // The invocation exited on its own and the markers never appeared.
+      return readMarkers();
+    }
+    await sleep(2000);
+  }
+  // Timeout with no markers: kill the (likely hung) invocation, signal failure.
+  await killChildGroup(handle.child, 1500);
+  return null;
+}
+
+// ---------- main loop ----------
+async function main() {
+  const initialPrompt = readInitialPrompt();
+
+  log('supervisor start | project=' + projectDir + ' company=' + companyDir +
+      ' max-turns=' + maxTurns + ' permission-mode=' + permissionMode +
+      ' threshold=' + parseThreshold() + ' restart-timeout-secs=' + restartTimeoutSecs +
+      ' turn-timeout-secs=' + turnTimeoutSecs);
+  log('initial prompt length=' + initialPrompt.length + ' chars');
+
+  // A logical run = many sessions. sessionId is the current work session.
+  let sessionId = randomUUID();
+  let prompt = initialPrompt;
+  let freshSession = true;
+
+  const threshold = parseThreshold();
+  let errorStreak = 0;
+  const MAX_ERROR_STREAK = 3;
+
+  for (let turn = 1; turn <= maxTurns; turn++) {
+    // Exit-before-work: a CANCEL or an already-done goal short-circuits the turn.
+    if (fs.existsSync(cancelPath)) {
+      log('CANCEL file present - exiting 0');
+      process.exit(0);
+    }
+    if (isGoalDone()) {
+      log('goal DONE (all criteria pass) before turn ' + turn + ' - exiting 0');
+      process.exit(0);
+    }
+
+    log('turn ' + turn + '/' + maxTurns + ' | session-id=' + sessionId +
+        ' | mode=' + (freshSession ? 'fresh' : 'resume'));
+
+    const continuePrompt = freshSession ? prompt
+      : 'Continue the /company goal. Keep working the THINK-EXECUTE-VERIFY loop ' +
+        'until every criterion passes.';
+    const turnResult = await runTurn({
+      sessionId: sessionId,
+      freshSession: freshSession,
+      prompt: continuePrompt,
+    });
+
+    // The turn ran. CANCEL and goal-done both win over fill.
+    if (fs.existsSync(cancelPath)) {
+      log('CANCEL file present after turn ' + turn + ' - exiting 0');
+      process.exit(0);
+    }
+    if (isGoalDone()) {
+      log('goal DONE after turn ' + turn + ' - exiting 0');
+      process.exit(0);
+    }
+
+    // A timed-out turn is NOT an error: the backstop killed a hung/over-long turn,
+    // so proceed to the fill check on the partial transcript (skip the error path).
+    if (turnResult.timedOut) {
+      log('turn ' + turn + ' hit the ' + turnTimeoutSecs +
+          's backstop - proceeding to fill on the partial transcript');
+    } else if (turnResult.code !== 0) {
+      // A turn that errored out (bad binary, crash) counts toward the error streak.
+      errorStreak += 1;
+      log('WARN turn ' + turn + ' exited ' + turnResult.code +
+          ' (error streak ' + errorStreak + '/' + MAX_ERROR_STREAK + ')' +
+          (turnResult.stderrTail ? ' stderr: ' + turnResult.stderrTail.slice(-300) : ''));
+      if (errorStreak >= MAX_ERROR_STREAK) {
+        process.stderr.write(
+          'ERROR: ' + MAX_ERROR_STREAK + ' consecutive failed turns.\n' +
+          'Last exit code: ' + turnResult.code + '\n' +
+          'Check: ' + companyDir + '/NEXT.md + criteria.json + CANCEL\n'
+        );
+        process.exit(2);
+      }
+      // Retry the same session, same prompt.
+      freshSession = false;
+      continue;
+    }
+    errorStreak = 0;
+
+    // The supervisor owns the threshold decision (the guards do not fire headless).
+    const f = computeFill(sessionId);
+    const pct = (f.fill * 100).toFixed(1);
+    log('turn ' + turn + ' fill=' + pct + '% (' + f.used + '/' + f.window +
+        ' tokens, model=' + (f.modelId || 'unknown') + ', threshold=' +
+        (threshold * 100).toFixed(0) + '%)');
+
+    if (f.fill >= threshold) {
+      // DRIVE the restart on this session, then seed a FRESH session from NEXT.md.
+      log('fill >= threshold - driving /company restart on session ' + sessionId);
+      const next = await driveRestart(sessionId);
+      if (!next) {
+        errorStreak += 1;
+        log('WARN restart markers did not appear within ' + restartTimeoutSecs +
+            's (error streak ' + errorStreak + '/' + MAX_ERROR_STREAK + ')');
+        if (errorStreak >= MAX_ERROR_STREAK) {
+          process.stderr.write(
+            'ERROR: ' + MAX_ERROR_STREAK + ' consecutive restart-drive failures.\n' +
+            'The /company restart did not write NEXT.md + RESTART_DEBATE_CONFIRMED.\n'
+          );
+          process.exit(2);
+        }
+        // Retry the same session another turn rather than seeding a blank cycle.
+        freshSession = false;
+        continue;
+      }
+      log('restart confirmed - fresh-context handoff (NEXT.md ' + next.length + ' chars)');
+      sessionId = randomUUID();
+      prompt = next;
+      freshSession = true;
+      errorStreak = 0;
+      // Clean the marker so the next restart starts from a clean slate.
+      try { fs.unlinkSync(debateConfirmedPath); } catch (e) {}
+      continue;
+    }
+
+    // Under threshold: continue the SAME session another turn.
+    freshSession = false;
+  }
+
+  process.stderr.write(
+    'ERROR: max-turns (' + maxTurns + ') reached without goal completion.\n' +
+    'Increase --max-turns or verify criteria.json.\n'
+  );
+  process.exit(3);
+}
+
+main().catch(function (e) {
+  process.stderr.write('FATAL: ' + (e && e.stack ? e.stack : e) + '\n');
+  process.exit(1);
+});

package/scripts/dashboard.js

@@ -606,6 +606,15 @@ function parseContextThreshold() {
   return v > 1 ? v / 100 : v;
 }
 
+// Sum all token fields that count against the context window.
+// Matches the Claude Code status line: input + cache_read + cache_creation + output.
+function usedTokens(usage) {
+  return (usage.input_tokens || 0) +
+    (usage.cache_read_input_tokens || 0) +
+    (usage.cache_creation_input_tokens || 0) +
+    (usage.output_tokens || 0);
+}
+
 function computeContextFill(transcriptFile, overrideModel) {
   const threshold = parseContextThreshold();
   if (!transcriptFile) return { used: 0, window: DEFAULT_WINDOW, fill: 0, threshold, modelId: null };
@@ -634,9 +643,7 @@ function computeContextFill(transcriptFile, overrideModel) {
     return { used: 0, window: DEFAULT_WINDOW, fill: 0, threshold, modelId: null };
   }
   if (!lastUsage) return { used: 0, window: DEFAULT_WINDOW, fill: 0, threshold, modelId: lastModelId };
-  const used = (lastUsage.input_tokens || 0) +
-    (lastUsage.cache_read_input_tokens || 0) +
-    (lastUsage.cache_creation_input_tokens || 0);
+  const used = usedTokens(lastUsage);
   const contextWindow = detectWindow(lastModelId);
   const fill = used / contextWindow;
   return { used, window: contextWindow, fill, threshold, modelId: lastModelId };
@@ -1290,7 +1297,7 @@ footer { margin-top: 2rem; font-size: 12.5px; color: var(--dim); border-top: 1px
         <button class="tree-btn" id="zoom-in">+</button>
         <button class="tree-btn" id="zoom-out">-</button>
         <button class="tree-btn" id="zoom-reset">reset</button>
-        <button class="tree-btn" id="tree-fullscreen">fullscreen</button>
+        <button class="tree-btn" id="tree-fullscreen" aria-label="Expand" title="Expand"><svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><polyline points="1,5 1,1 5,1"/><polyline points="9,1 13,1 13,5"/><polyline points="13,9 13,13 9,13"/><polyline points="5,13 1,13 1,9"/></svg></button>
       </div>
     </div>
     <div class="tree-container" id="tree-container">
@@ -1356,6 +1363,28 @@ const fmtBytes = (n) => {
   return n + ' B';
 };
 const shortModel = (m) => m ? String(m).replace(/^claude-/, '') : '?';
+// Human-readable model label: "Opus 4.8 (1M context)" style.
+// Keep in sync with the server-side humanizeModel() in dashboard.js.
+function humanizeModel(modelId) {
+  if (!modelId) return '?';
+  const m = String(modelId).toLowerCase();
+  let name;
+  if (m.includes('fable') || m.includes('mythos')) name = 'Fable 5';
+  else if (m.includes('opus-4-8')) name = 'Opus 4.8';
+  else if (m.includes('opus-4-5')) name = 'Opus 4.5';
+  else if (m.includes('opus-4')) name = 'Opus 4';
+  else if (m.includes('sonnet-4')) name = 'Sonnet 4';
+  else if (m.includes('sonnet-3-7')) name = 'Sonnet 3.7';
+  else if (m.includes('sonnet-3-5')) name = 'Sonnet 3.5';
+  else if (m.includes('sonnet')) name = 'Sonnet';
+  else if (m.includes('haiku')) name = 'Haiku';
+  else name = modelId.replace(/^claude-/, '');
+  // 1M window: ids containing [1m] or known opus-4 family
+  const is1M = m.includes('[1m]') || m.includes('claude-opus-4') ||
+    m.includes('fable') || m.includes('mythos');
+  const win = is1M ? '1M context' : '200K context';
+  return name + ' (' + win + ')';
+}
 
 function renderHeader(s) {
   const stats = $('stats');
@@ -1375,8 +1404,8 @@ function renderHeader(s) {
     const su = t.session && t.session.usage;
     add('session cost', su ? fmtUsd(su.cost) : '?', su ? fmtTok(su.total) + ' tokens' : 'session ' + (t.session && t.session.id || '?'));
     if (s.savings && s.savings.tieringSaved !== null) {
-      add('saved by model tiering', fmtUsd(s.savings.tieringSaved) + (s.savings.estimated ? ' est.' : ''), 'vs all-' + shortModel(s.savings.topTierModel) + ' (current top tier)');
-      add('saved by prompt caching', fmtUsd(s.savings.cacheSaved) + (s.savings.estimated ? ' est.' : ''), 'cache reads vs full input price');
+      add('saved by model tiering', fmtUsd(s.savings.tieringSaved) + (s.savings.estimated ? ' est.' : ''), 'approx - vs all-' + shortModel(s.savings.topTierModel) + ' (current top tier)');
+      add('saved by prompt caching', fmtUsd(s.savings.cacheSaved) + (s.savings.estimated ? ' est.' : ''), 'approx - cache reads vs full input price');
     }
   }
   const bar = $('splitbar'), legend = $('legend');
@@ -1408,7 +1437,7 @@ function renderBand(s) {
     band.appendChild(d);
   };
   add('policy', p.policy || '?');
-  add('session model', shortModel(p.sessionModel));
+  add('session model', humanizeModel(p.sessionModel));
   add('owners', String(p.ownerCount ?? '?'));
   if (p.halt) band.appendChild(el('span', 'halt', 'HALT REQUESTED'));
   if (s.warning) {
@@ -1489,7 +1518,7 @@ function renderContextFill(s) {
   const row = el('div', 'ctx-row');
   row.appendChild(el('span', 'ctx-pct ' + colorClass, pct + '%'));
   row.appendChild(el('span', 'muted', fmtTok(ctx.used) + ' / ' + fmtTok(ctx.window) + ' tokens'));
-  if (ctx.modelId) row.appendChild(el('span', 'muted', shortModel(ctx.modelId)));
+  if (ctx.modelId) row.appendChild(el('span', 'muted', humanizeModel(ctx.modelId)));
   if (ctx.fill >= ctx.threshold && ctx.enforceRestart !== false) row.appendChild(el('span', 'pill warn', 'restart due'));
   root.appendChild(row);
 }
@@ -1585,61 +1614,86 @@ function nodeFill(status, tier) {
   return 'rgba(89,99,110,0.06)';
 }
 
-// Compute x/y positions for each node
+// Compute x/y positions for each node with no overlapping rectangles.
+// Strategy: compute each tier-1 subtree width, pack left-to-right with a gap,
+// center each lead over its children, grow total canvas to fit.
 function layoutTree(org) {
   const nodes = org.nodes || [];
   if (!nodes.length) return { placed: {}, W: 400, H: 100 };
-  const W = 900;
   const nodeW = 140, nodeH = 36;
-  const tierY = { 0: 40, 1: 130, 2: 240 };
+  const colGap = 12;  // horizontal gap between node columns
+  const rowGap = 14;  // vertical gap between rows within a subtree
+  const leadGap = 24; // horizontal gap between adjacent subtrees
+  const tierY = { 0: 40, 1: 140, 2: 256 };
   const placed = {};
 
   const tier0 = nodes.filter(n => n.tier === 0);
   const tier1 = nodes.filter(n => n.tier === 1);
   const tier2 = nodes.filter(n => n.tier === 2);
 
-  if (tier0.length) placed[tier0[0].id] = { x: W / 2 - nodeW / 2, y: tierY[0] };
-
-  const t1Step = tier1.length > 0 ? Math.max(nodeW + 16, W / tier1.length) : W;
-  tier1.forEach((n, i) => {
-    placed[n.id] = { x: Math.max(0, t1Step * i + (t1Step - nodeW) / 2), y: tierY[1] };
-  });
-
-  // Group tier-2 under their lead
+  // Build tier-2 children list per tier-1 lead (only direct edges)
   const byLead = {};
   for (const e of (org.edges || [])) {
     if (!byLead[e.from]) byLead[e.from] = [];
     byLead[e.from].push(e.to);
   }
-  let totalH = 320;
-  for (const [leadId, childIds] of Object.entries(byLead)) {
-    const leadPos = placed[leadId];
-    if (!leadPos) continue;
-    const lead = nodes.find(n => n.id === leadId);
-    if (!lead || lead.tier !== 1) continue;
-    const t2children = childIds.filter(cid => {
+
+  // Subtree width for a tier-1 node = max(nodeW, cols*nodeW + (cols-1)*colGap)
+  // where cols = min(3, childCount)
+  function subtreeWidth(leadId) {
+    const children = (byLead[leadId] || []).filter(cid => {
+      const cn = nodes.find(n => n.id === cid);
+      return cn && cn.tier === 2;
+    });
+    if (!children.length) return nodeW;
+    const cols = Math.min(3, children.length);
+    return cols * nodeW + (cols - 1) * colGap;
+  }
+
+  // Place tier-1 subtrees left to right, each subtree occupying its full width.
+  let cursor = 0;
+  let totalH = tierY[2] + nodeH + 20;
+
+  tier1.forEach((lead) => {
+    const sw = subtreeWidth(lead.id);
+    // Center the lead node over its subtree band
+    placed[lead.id] = { x: cursor + (sw - nodeW) / 2, y: tierY[1] };
+
+    // Place tier-2 children under this lead, left-aligned within the band
+    const children = (byLead[lead.id] || []).filter(cid => {
       const cn = nodes.find(n => n.id === cid);
       return cn && cn.tier === 2;
     });
-    const cols = Math.min(3, t2children.length);
-    const slotW = Math.max(nodeW + 8, t1Step);
-    const groupW = cols * slotW;
-    const startX = leadPos.x + nodeW / 2 - groupW / 2;
-    t2children.forEach((cid, i) => {
-      const col = i % 3;
-      const row = Math.floor(i / 3);
-      const y = tierY[2] + row * (nodeH + 14);
-      const x = startX + col * slotW;
+    const cols = Math.min(3, children.length);
+    children.forEach((cid, i) => {
+      const col = i % cols;
+      const row = Math.floor(i / cols);
+      const x = cursor + col * (nodeW + colGap);
+      const y = tierY[2] + row * (nodeH + rowGap);
       placed[cid] = { x, y };
       if (y + nodeH + 20 > totalH) totalH = y + nodeH + 20;
     });
-  }
+
+    cursor += sw + leadGap;
+  });
+
+  // Orphan tier-2 nodes (no lead parent placed): append at the right edge
   for (const n of tier2) {
     if (!placed[n.id]) {
-      placed[n.id] = { x: 10, y: tierY[2] };
+      placed[n.id] = { x: cursor, y: tierY[2] };
+      cursor += nodeW + colGap;
     }
   }
-  return { placed, W, H: Math.max(320, totalH) };
+
+  // Total canvas width: max of cursor (after all subtrees) and a minimum
+  const totalW = Math.max(400, cursor - leadGap);
+
+  // Center tier-0 (CEO) over the whole canvas
+  if (tier0.length) {
+    placed[tier0[0].id] = { x: totalW / 2 - nodeW / 2, y: tierY[0] };
+  }
+
+  return { placed, W: totalW, H: Math.max(320, totalH) };
 }
 
 function renderTree(s) {
@@ -1892,6 +1946,17 @@ function setupTreeInteractions() {
     if (!document.fullscreenElement) card.requestFullscreen().catch(() => {});
     else document.exitFullscreen().catch(() => {});
   });
+  // SVG icons for expand (two arrows out) and contract (two arrows in)
+  const ICON_EXPAND = '<svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><polyline points="1,5 1,1 5,1"/><polyline points="9,1 13,1 13,5"/><polyline points="13,9 13,13 9,13"/><polyline points="5,13 1,13 1,9"/></svg>';
+  const ICON_CONTRACT = '<svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><polyline points="5,1 5,5 1,5"/><polyline points="13,5 9,5 9,1"/><polyline points="9,13 9,9 13,9"/><polyline points="1,9 5,9 5,13"/></svg>';
+  document.addEventListener('fullscreenchange', () => {
+    const btn = $('tree-fullscreen');
+    if (!btn) return;
+    const active = !!document.fullscreenElement;
+    btn.innerHTML = active ? ICON_CONTRACT : ICON_EXPAND;
+    btn.setAttribute('aria-label', active ? 'Exit fullscreen' : 'Expand');
+    btn.setAttribute('title', active ? 'Exit fullscreen' : 'Expand');
+  });
 }
 
 // Per-feed-item expand: sessionStorage set of expanded item keys, keyed per session
@@ -2019,7 +2084,7 @@ function renderCriteria(s) {
     dot.style.flexShrink = '0';
     header.appendChild(dot);
     const titleSpan = el('span');
-    titleSpan.style.cssText = 'flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
+    titleSpan.style.cssText = 'flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
     titleSpan.textContent = itemId + '. ' + item.description;
     header.appendChild(titleSpan);
     const caret = el('span', 'muted');
@@ -2071,11 +2136,10 @@ function renderCycles(s) {
   thead.appendChild(hr);
   table.appendChild(thead);
   const tbody = el('tbody');
+  // Show counts and dates as headlines; drop bare byte sizes as primary values.
   const rows = [
-    ['cycle dirs', String(c.cycleDirs ?? '?')],
-    ['briefings', (c.briefingCount ?? '?') + ' (' + fmtBytes(c.briefingBytes) + ')'],
-    ['playbook', fmtBytes(c.playbookBytes) + (c.playbookGrowthBytes ? ' (+' + fmtBytes(c.playbookGrowthBytes) + ')' : '')],
-    ['active tasks', fmtBytes(c.activeTasksBytes)],
+    ['cycles run', String(c.cycleDirs ?? '?')],
+    ['briefings logged', String(c.briefingCount ?? '?')],
     ['last compaction', c.lastCompaction ? new Date(c.lastCompaction).toLocaleString() : 'none seen'],
     ['compactions observed', String(c.compactionsObserved ?? 0)],
   ];
@@ -2239,4 +2303,91 @@ server.on('error', (err) => {
   process.exit(1);
 });
 
-startListening();
+// Guard: only bind the port when run directly, not when require()'d for tests.
+if (require.main === module) startListening();
+
+// Map a raw model id to a human-readable label with context-window note.
+// Mirrors the client-side copy inside PAGE for testability.
+function humanizeModel(modelId) {
+  if (!modelId) return '?';
+  const m = String(modelId).toLowerCase();
+  let name;
+  if (m.includes('fable') || m.includes('mythos')) name = 'Fable 5';
+  else if (m.includes('opus-4-8')) name = 'Opus 4.8';
+  else if (m.includes('opus-4-5')) name = 'Opus 4.5';
+  else if (m.includes('opus-4')) name = 'Opus 4';
+  else if (m.includes('sonnet-4')) name = 'Sonnet 4';
+  else if (m.includes('sonnet-3-7')) name = 'Sonnet 3.7';
+  else if (m.includes('sonnet-3-5')) name = 'Sonnet 3.5';
+  else if (m.includes('sonnet')) name = 'Sonnet';
+  else if (m.includes('haiku')) name = 'Haiku';
+  else name = modelId.replace(/^claude-/, '');
+  const win = is1MModel(modelId) ? '1M context' : '200K context';
+  return name + ' (' + win + ')';
+}
+
+// Server-side copy of layoutTree (mirrors the client-side copy in PAGE) for test export.
+// Keep in sync with the client-side definition inside the PAGE template.
+function layoutTree(org) {
+  const nodes = org.nodes || [];
+  if (!nodes.length) return { placed: {}, W: 400, H: 100 };
+  const nodeW = 140, nodeH = 36;
+  const colGap = 12;
+  const rowGap = 14;
+  const leadGap = 24;
+  const tierY = { 0: 40, 1: 140, 2: 256 };
+  const placed = {};
+  const tier0 = nodes.filter(n => n.tier === 0);
+  const tier1 = nodes.filter(n => n.tier === 1);
+  const tier2 = nodes.filter(n => n.tier === 2);
+  const byLead = {};
+  for (const e of (org.edges || [])) {
+    if (!byLead[e.from]) byLead[e.from] = [];
+    byLead[e.from].push(e.to);
+  }
+  function subtreeWidth(leadId) {
+    const children = (byLead[leadId] || []).filter(cid => {
+      const cn = nodes.find(n => n.id === cid);
+      return cn && cn.tier === 2;
+    });
+    if (!children.length) return nodeW;
+    const cols = Math.min(3, children.length);
+    return cols * nodeW + (cols - 1) * colGap;
+  }
+  let cursor = 0;
+  let totalH = tierY[2] + nodeH + 20;
+  tier1.forEach((lead) => {
+    const sw = subtreeWidth(lead.id);
+    placed[lead.id] = { x: cursor + (sw - nodeW) / 2, y: tierY[1] };
+    const children = (byLead[lead.id] || []).filter(cid => {
+      const cn = nodes.find(n => n.id === cid);
+      return cn && cn.tier === 2;
+    });
+    const cols = Math.min(3, children.length);
+    children.forEach((cid, i) => {
+      const col = i % cols;
+      const row = Math.floor(i / cols);
+      const x = cursor + col * (nodeW + colGap);
+      const y = tierY[2] + row * (nodeH + rowGap);
+      placed[cid] = { x, y };
+      if (y + nodeH + 20 > totalH) totalH = y + nodeH + 20;
+    });
+    cursor += sw + leadGap;
+  });
+  for (const n of tier2) {
+    if (!placed[n.id]) {
+      placed[n.id] = { x: cursor, y: tierY[2] };
+      cursor += nodeW + colGap;
+    }
+  }
+  const totalW = Math.max(400, cursor - leadGap);
+  if (tier0.length) {
+    placed[tier0[0].id] = { x: totalW / 2 - nodeW / 2, y: tierY[0] };
+  }
+  return { placed, W: totalW, H: Math.max(320, totalH) };
+}
+
+// Test-only exports; the server path never calls require() on itself.
+if (typeof module !== 'undefined') {
+  module.exports = { usedTokens, humanizeModel, layoutTree };
+}