create-byan-agent 2.39.0 → 2.42.0

package/install/lib/project-handoff.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const FORMAT = 'byan-project-handoff';
+const VERSION = '1.0';
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function slugify(s) {
+  return String(s || 'handoff')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80) || 'handoff';
+}
+
+function timestampForFile(d = new Date()) {
+  return d.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+}
+
+function handoffDir(root) {
+  return path.join(root, '_byan-output', 'handoffs');
+}
+
+function defaultHandoffPath(root, handoff, date = new Date()) {
+  const from = slugify(handoff.from || 'unknown');
+  const to = slugify(handoff.to || 'next');
+  const task = slugify(handoff.currentTask || handoff.project || 'project');
+  return path.join(handoffDir(root), `${timestampForFile(date)}-${from}-to-${to}-${task}.md`);
+}
+
+function arrayify(value) {
+  if (Array.isArray(value)) return value.filter((v) => String(v || '').trim()).map(String);
+  if (value == null || value === '') return [];
+  return [String(value)];
+}
+
+function readJsonFile(file) {
+  try {
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function safeRun(cmd, { cwd, maxBuffer = 1024 * 1024 } = {}) {
+  try {
+    return String(execSync(cmd, { cwd, stdio: 'pipe', encoding: 'utf8', maxBuffer })).trim();
+  } catch {
+    return '';
+  }
+}
+
+function collectGitSnapshot(root, { run = safeRun } = {}) {
+  const status = run('git status --short', { cwd: root });
+  const branch = run('git branch --show-current', { cwd: root }) || run('git rev-parse --abbrev-ref HEAD', { cwd: root });
+  const head = run('git rev-parse --short HEAD', { cwd: root });
+  const changedFiles = status
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.replace(/^.. /, '').replace(/^..\s+/, ''));
+  return { branch: branch || null, head: head || null, status, changedFiles };
+}
+
+function collectFdState(root) {
+  const state = readJsonFile(path.join(root, '_byan-output', 'fd-state.json'));
+  if (!state) return null;
+  return {
+    fd_id: state.fd_id || null,
+    feature_name: state.feature_name || null,
+    phase: state.phase || null,
+    strict_mode: Boolean(state.strict_mode),
+    backlog: Array.isArray(state.backlog) ? state.backlog : [],
+    validate_verdict: state.validate_verdict || null,
+  };
+}
+
+function buildHandoff(input = {}) {
+  const root = path.resolve(input.root || process.cwd());
+  const git = input.git || collectGitSnapshot(root, input);
+  const fd = input.fd === undefined ? collectFdState(root) : input.fd;
+  const project = input.project || path.basename(root);
+  const from = input.from || process.env.BYAN_HANDOFF_FROM || 'unknown';
+  const to = input.to || process.env.BYAN_HANDOFF_TO || 'next-assistant';
+  const currentTask = input.currentTask || input.task || (fd && fd.feature_name) || 'Resume project work';
+  const filesTouched = arrayify(input.filesTouched || input.files || git.changedFiles);
+  const decisions = arrayify(input.decisions);
+  const blockers = arrayify(input.blockers);
+  const nextActions = arrayify(input.nextActions || input.next);
+  const commands = arrayify(input.commands);
+  const notes = arrayify(input.notes || input.note);
+
+  return {
+    format: FORMAT,
+    version: VERSION,
+    project,
+    root,
+    from,
+    to,
+    createdAt: input.createdAt || nowIso(),
+    currentTask,
+    summary: input.summary || '',
+    decisions,
+    filesTouched,
+    commands,
+    blockers,
+    nextActions,
+    notes,
+    git,
+    fd,
+  };
+}
+
+function renderList(items, empty = '- (none recorded)') {
+  const arr = arrayify(items);
+  if (!arr.length) return empty;
+  return arr.map((item) => `- ${item}`).join('\n');
+}
+
+function renderJsonBlock(handoff) {
+  return [
+    '```json byan-handoff',
+    JSON.stringify(handoff, null, 2),
+    '```',
+  ].join('\n');
+}
+
+function renderMarkdown(handoff) {
+  const h = buildHandoff(handoff);
+  const lines = [];
+  lines.push(`# BYAN Project Handoff: ${h.from} -> ${h.to}`);
+  lines.push('');
+  lines.push('> Portable Markdown handoff for switching between Claude Code and Codex. This file is the source of truth for the next assistant; native assistant memory is optional context only.');
+  lines.push('');
+  lines.push('## Machine Data');
+  lines.push('');
+  lines.push(renderJsonBlock(h));
+  lines.push('');
+  lines.push('## Resume Prompt');
+  lines.push('');
+  lines.push(renderResumePrompt(h));
+  lines.push('');
+  lines.push('## Human Summary');
+  lines.push('');
+  lines.push(h.summary || '_A completer avant le passage si le resume automatique est insuffisant._');
+  lines.push('');
+  lines.push('## Current Task');
+  lines.push('');
+  lines.push(h.currentTask);
+  lines.push('');
+  lines.push('## Decisions');
+  lines.push('');
+  lines.push(renderList(h.decisions));
+  lines.push('');
+  lines.push('## Files Touched');
+  lines.push('');
+  lines.push(renderList(h.filesTouched));
+  lines.push('');
+  lines.push('## Commands And Tests');
+  lines.push('');
+  lines.push(renderList(h.commands));
+  lines.push('');
+  lines.push('## Blockers And Risks');
+  lines.push('');
+  lines.push(renderList(h.blockers));
+  lines.push('');
+  lines.push('## Next Actions');
+  lines.push('');
+  lines.push(renderList(h.nextActions, '- Re-read this handoff, inspect the listed files, then continue the current task.'));
+  lines.push('');
+  lines.push('## Notes');
+  lines.push('');
+  lines.push(renderList(h.notes));
+  lines.push('');
+  lines.push('## Git Snapshot');
+  lines.push('');
+  lines.push(`- Branch: ${h.git && h.git.branch ? h.git.branch : 'unknown'}`);
+  lines.push(`- Head: ${h.git && h.git.head ? h.git.head : 'unknown'}`);
+  lines.push('');
+  lines.push('```text');
+  lines.push((h.git && h.git.status) || '(clean or unavailable)');
+  lines.push('```');
+  lines.push('');
+  if (h.fd) {
+    lines.push('## FD Snapshot');
+    lines.push('');
+    lines.push(`- FD: ${h.fd.fd_id || 'unknown'}`);
+    lines.push(`- Feature: ${h.fd.feature_name || 'unknown'}`);
+    lines.push(`- Phase: ${h.fd.phase || 'unknown'}`);
+    lines.push(`- Strict: ${h.fd.strict_mode ? 'yes' : 'no'}`);
+    lines.push('');
+    lines.push('### Backlog');
+    lines.push('');
+    lines.push(renderList((h.fd.backlog || []).map((b) => `${b.id || '-'} [${b.status || '?'}] ${b.title || ''}`)));
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function extractJsonBlock(markdown) {
+  const text = String(markdown || '');
+  const re = /```json\s+byan-handoff\s*\n([\s\S]*?)\n```/m;
+  const m = text.match(re);
+  if (!m) throw new Error('Missing ```json byan-handoff block');
+  try {
+    return JSON.parse(m[1]);
+  } catch (err) {
+    throw new Error(`Invalid byan-handoff JSON: ${err.message}`);
+  }
+}
+
+function parseMarkdown(markdown) {
+  const h = extractJsonBlock(markdown);
+  if (h.format !== FORMAT) throw new Error(`Invalid handoff format: ${h.format || 'missing'}`);
+  if (!h.version) throw new Error('Missing handoff version');
+  return h;
+}
+
+function normalizeProvider(value) {
+  return slugify(value || '');
+}
+
+function providerMatches(actual, expected) {
+  const a = normalizeProvider(actual);
+  const e = normalizeProvider(expected);
+  if (!e) return true;
+  return a === e || a.startsWith(`${e}-`);
+}
+
+function renderResumePrompt(handoff) {
+  const h = buildHandoff(handoff);
+  const lines = [];
+  lines.push(`Continue this BYAN project from a portable handoff created by ${h.from} for ${h.to}.`);
+  lines.push(`Project: ${h.project}`);
+  lines.push(`Task: ${h.currentTask}`);
+  if (h.summary) lines.push(`Summary: ${h.summary}`);
+  if (h.decisions.length) lines.push(`Decisions: ${h.decisions.join(' | ')}`);
+  if (h.filesTouched.length) lines.push(`Files to inspect first: ${h.filesTouched.join(', ')}`);
+  if (h.commands.length) lines.push(`Known commands/tests: ${h.commands.join(' | ')}`);
+  if (h.blockers.length) lines.push(`Blockers/risks: ${h.blockers.join(' | ')}`);
+  if (h.nextActions.length) lines.push(`Next actions: ${h.nextActions.join(' | ')}`);
+  if (h.fd && h.fd.phase) lines.push(`FD state: ${h.fd.feature_name || h.fd.fd_id || 'unknown'} is in phase ${h.fd.phase}.`);
+  lines.push('Use repo files and BYAN portable state as source of truth; do not rely on native assistant memory.');
+  return lines.join('\n');
+}
+
+function writeHandoff(root, handoff, { outPath, mkdirp = fs.mkdirSync, writeFile = fs.writeFileSync } = {}) {
+  const h = buildHandoff({ ...handoff, root });
+  const target = path.resolve(outPath || defaultHandoffPath(path.resolve(root), h));
+  mkdirp(path.dirname(target), { recursive: true });
+  writeFile(target, renderMarkdown(h), 'utf8');
+  return { path: target, handoff: h };
+}
+
+function latestHandoff(root, { from = null, exists = fs.existsSync, readdir = fs.readdirSync, readFile = fs.readFileSync } = {}) {
+  const dir = handoffDir(path.resolve(root));
+  if (!exists(dir)) return null;
+  const files = readdir(dir)
+    .filter((f) => /\.md$/i.test(f))
+    .sort()
+    .reverse();
+  if (!files.length) return null;
+  if (!from) return path.join(dir, files[0]);
+
+  for (const file of files) {
+    const full = path.join(dir, file);
+    try {
+      const handoff = parseMarkdown(readFile(full, 'utf8'));
+      if (providerMatches(handoff.from, from)) return full;
+    } catch {
+      // Ignore non-handoff markdown files in the handoff directory.
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  FORMAT,
+  VERSION,
+  buildHandoff,
+  collectFdState,
+  collectGitSnapshot,
+  defaultHandoffPath,
+  extractJsonBlock,
+  handoffDir,
+  latestHandoff,
+  parseMarkdown,
+  providerMatches,
+  renderMarkdown,
+  renderResumePrompt,
+  writeHandoff,
+};

package/install/lib/rtk-integration.js

@@ -5,16 +5,20 @@
  *
  * RTK ("Rust Token Killer", Apache-2.0) is a single zero-dependency binary that
  * filters/compresses dev-command output before it reaches the LLM context
- * (-60/90% tokens). It wires into Claude Code through its OWN hook installer.
+ * (-60/90% tokens). It wires into Claude Code through its OWN hook installer;
+ * for Codex installs BYAN can make the native binary available, but does not
+ * claim a transparent hook layer where Codex has no BYAN hook adapter.
  *
  * MAINTAINABILITY by design (the whole point of choosing this shape):
  *  - We do NOT reimplement per-OS download / checksum / version pinning. We
  *    DELEGATE the install to rtk's own canonical installer (brew / the official
  *    install.sh / cargo), and DELEGATE the Claude Code hook wiring to rtk's own
  *    `rtk init -g --auto-patch` (the `--auto-patch` is what makes it non-
- *    interactive — see wireHook). BYAN maintains only "pick the available
- *    installer, run it bounded + visible, locate the binary, ask rtk to wire its
- *    hook" — a tiny surface, bumped via one constant.
+ *    interactive — see wireHook). For Codex, BYAN stops at verified native
+ *    binary availability and reports that honestly. BYAN maintains only "pick
+ *    the available installer, run it bounded + visible, locate the binary, ask
+ *    rtk to wire its hook when Claude is targeted" — a tiny surface, bumped via
+ *    one constant.
  *  - SUPPLY-CHAIN: we pin to a TAG, never a moving branch. cargo builds the
  *    tagged source (`--tag`), and install.sh is fetched from the IMMUTABLE tag ref.
  *    That script verifies a SHA-256 of the downloaded binary against a published
@@ -39,8 +43,8 @@
  *
  * Mirrors the ENTRY-POINT shape of byan-web-integration.js / byan-leantime-
  * integration.js (one `setup*Integration`); the return contract is { ok, synced,
- * reason, ... } because persistence is owned by rtk's own `rtk init -g --auto-patch`, not by
- * byan-platform-config.
+ * reason, ... } because persistence is owned by rtk's own `rtk init -g
+ * --auto-patch`, not by byan-platform-config.
  */
 
 const { execSync } = require('child_process');
@@ -128,6 +132,48 @@ function pathHintFor(bin, { env = process.env, platform = process.platform } = {
   return `export PATH="${dir}:$PATH"`;
 }
 
+function normalizeTargetPlatforms(targetPlatforms = ['claude']) {
+  const raw = Array.isArray(targetPlatforms) ? targetPlatforms : [targetPlatforms];
+  const set = new Set();
+  for (const p of raw) {
+    const key = String(p || '').trim().toLowerCase();
+    if (key === 'claude' || key === 'claude-code') set.add('claude');
+    if (key === 'codex') set.add('codex');
+  }
+  if (!set.size) set.add('claude');
+  return set;
+}
+
+function codexReady({
+  log,
+  installedVia,
+  version,
+  bin = 'rtk',
+  env = process.env,
+  platform = process.platform,
+  claudeHook = false,
+} = {}) {
+  const offPath = bin !== 'rtk';
+  log(`rtk: ready for Codex (${installedVia}, v${version || '?'}) — native binary available; no transparent Codex hook is wired.`);
+  const r = {
+    ok: true,
+    synced: true,
+    reason: 'codex-binary-ready',
+    installed: true,
+    installedVia,
+    version,
+    hook: Boolean(claudeHook),
+    claudeHook: Boolean(claudeHook),
+    codexReady: true,
+    bin,
+  };
+  if (offPath) {
+    r.pathHint = pathHintFor(bin, { env, platform });
+    log(`rtk: note — installed at ${bin}, not on your PATH. Add it: ${r.pathHint}`);
+  }
+  return r;
+}
+
 /**
  * rtkStatus() -> { installed, version, bin }. Never throws. Probes `<bin>
  * --version` ("rtk 0.42.4"), default bin "rtk" (on PATH). An installed-but-
@@ -209,7 +255,7 @@ function wireHook({ run, log, installedVia, version, bin = 'rtk', env = process.
   try {
     run(initCmd, { stdio: 'pipe' });
     log(`rtk: ready (${installedVia}, v${version || '?'}) — hook wired via '${initCmd}'. Restart Claude Code to activate.`);
-    const r = { ok: true, synced: true, reason: 'wired', installed: true, installedVia, version, hook: true, bin };
+    const r = { ok: true, synced: true, reason: 'wired', installed: true, installedVia, version, hook: true, claudeHook: true, bin };
     if (offPath) {
       r.pathHint = pathHintFor(bin, { env, platform });
       log(`rtk: note — installed at ${bin}, not on your PATH. Add it: ${r.pathHint}`);
@@ -217,7 +263,7 @@ function wireHook({ run, log, installedVia, version, bin = 'rtk', env = process.
     return r;
   } catch (err) {
     log(`rtk: installed (${installedVia}) but '${initCmd}' failed (${oneLine(err)}) — run it manually, BYAN unaffected.`);
-    const r = { ok: true, synced: false, reason: 'hook-failed', installed: true, installedVia, version, hook: false, bin };
+    const r = { ok: true, synced: false, reason: 'hook-failed', installed: true, installedVia, version, hook: false, claudeHook: false, bin };
     if (offPath) r.pathHint = pathHintFor(bin, { env, platform });
     return r;
   }
@@ -240,6 +286,9 @@ function wireHook({ run, log, installedVia, version, bin = 'rtk', env = process.
  * @param {Function} [o.resolve]  binary resolver (default resolveBinary) — injected in tests
  * @param {Function} [o.log]      one-line breadcrumb sink (default no-op)
  * @param {object}   [o.env]      environment (default process.env) — for the timeout override
+ * @param {string[]|string} [o.targetPlatforms] platforms to prepare:
+ *                    claude wires RTK's Claude Code hook; codex verifies the
+ *                    native binary and reports no transparent hook.
  */
 function setupRtkIntegration({
   run = execSync,
@@ -248,16 +297,33 @@ function setupRtkIntegration({
   log = () => {},
   env = process.env,
   platform = process.platform,
+  targetPlatforms = ['claude'],
 } = {}) {
+  const targets = normalizeTargetPlatforms(targetPlatforms);
+  const wantsClaude = targets.has('claude');
+  const wantsCodex = targets.has('codex');
+  const finishReady = ({ installedVia, version, bin }) => {
+    if (!wantsClaude && wantsCodex) {
+      return codexReady({ log, installedVia, version, bin, env, platform });
+    }
+    const r = wireHook({ run, log, installedVia, version, bin, env, platform });
+    if (wantsCodex && r.installed) {
+      r.codexReady = true;
+      if (r.reason === 'wired') r.reason = 'wired+codex-binary-ready';
+      log('rtk: also ready for Codex — native binary available; no transparent Codex hook is wired.');
+    }
+    return r;
+  };
+
   const before = locateRtk({ run, has, resolve, env });
   if (before.installed) {
-    return wireHook({ run, log, installedVia: 'already-present', version: before.version, bin: before.bin, env, platform });
+    return finishReady({ installedVia: 'already-present', version: before.version, bin: before.bin });
   }
 
   const strat = pickStrategy({ has });
   if (!strat) {
     log('rtk: no installer found (brew / curl / cargo) — skipped. BYAN install unaffected.');
-    return { ok: true, synced: false, reason: 'no-installer', installed: false, hook: false };
+    return { ok: true, synced: false, reason: 'no-installer', installed: false, hook: false, claudeHook: false, codexReady: false };
   }
 
   // Breadcrumb BEFORE the delegated install. stdio is INHERITED so the installer's
@@ -269,10 +335,10 @@ function setupRtkIntegration({
   } catch (err) {
     if (isTimeout(err)) {
       log(`rtk: install via ${strat.id} exceeded ${Math.round(timeoutMs / MIN)}min — stopped (a background build may still continue). Retry with 'npm run setup-rtk' (or widen BYAN_RTK_TIMEOUT_MS). BYAN unaffected.`);
-      return { ok: true, synced: false, reason: `install-timeout:${strat.id}`, installed: false, hook: false };
+      return { ok: true, synced: false, reason: `install-timeout:${strat.id}`, installed: false, hook: false, claudeHook: false, codexReady: false };
     }
     log(`rtk: install via ${strat.id} failed (${oneLine(err)}) — skipped gracefully.`);
-    return { ok: true, synced: false, reason: `install-failed:${strat.id}`, installed: false, hook: false };
+    return { ok: true, synced: false, reason: `install-failed:${strat.id}`, installed: false, hook: false, claudeHook: false, codexReady: false };
   }
 
   // The binary may be installed but OFF PATH (cargo -> ~/.cargo/bin). Resolve it
@@ -280,10 +346,10 @@ function setupRtkIntegration({
   const after = locateRtk({ run, has, resolve, env });
   if (!after.installed) {
     log(`rtk: install via ${strat.id} ran but 'rtk --version' did not confirm — skipped.`);
-    return { ok: true, synced: false, reason: 'install-unverified', installed: false, hook: false };
+    return { ok: true, synced: false, reason: 'install-unverified', installed: false, hook: false, claudeHook: false, codexReady: false };
   }
 
-  return wireHook({ run, log, installedVia: strat.id, version: after.version, bin: after.bin, env, platform });
+  return finishReady({ installedVia: strat.id, version: after.version, bin: after.bin });
 }
 
 /**
@@ -307,6 +373,7 @@ module.exports = {
   timeoutFor,
   isTimeout,
   pathHintFor,
+  normalizeTargetPlatforms,
   doctor,
   shouldOfferRtk,
   RTK_VERSION,

package/install/templates/.claude/CLAUDE.md

@@ -67,6 +67,22 @@ Doctrine d'equipe complete (template role-in-team, analogie orchestre, principes
 - Architecture portable (noyau portable, projection native): voir .claude/rules/portable-core.md (charge a la demande)
 - Systeme API byan_web: voir @.claude/rules/byan-api.md
 
+## Handoff Claude/Codex
+
+Quand l'utilisateur demande `importe depuis claude` ou `importe depuis codex`,
+ne demande pas de precision si un handoff depuis cette source existe. Lance:
+
+```bash
+byan-handoff latest --from <source demandee> --prompt
+```
+
+Utilise le prompt produit comme contexte de reprise, inspecte les fichiers listes,
+puis continue le travail. Si aucun fichier ne correspond, signale simplement
+qu'aucun handoff depuis cette source n'a ete trouve et propose
+`byan-handoff latest --prompt` comme fallback seulement si l'utilisateur accepte
+de reprendre depuis le dernier handoff toutes sources confondues. Ne t'appuie
+pas sur les memoires natives Claude/Codex comme source de verite.
+
 ## API byan_web
 
 BYAN expose une API REST via `$BYAN_API_URL` avec authentification par token (`ApiKey` ou `Bearer`).

package/install/templates/.claude/hooks/codex-autodelegate.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook — Codex auto-delegation nudge (F5).
+ *
+ * Every turn, estimates Claude's rolling-5h consumption (F1 usage-estimator) and
+ * asks the pure decision core (F5 autodelegate-decision) whether to nudge BYAN to
+ * hand delegable work to Codex — on the ChatGPT subscription, no API credit. The
+ * nudge is ADVISORY context only: it proposes, never forces, and always names the
+ * red line (delegable work only; judgment/soul/verify stay on Claude).
+ *
+ * DISARMED BY DEFAULT. The hook no-ops unless `_byan/_config/autodelegate.json`
+ * exists with `enabled: true` (written by the yanstaller F4 when the user opts
+ * into a Codex backup). No config file -> silence. This keeps it from nagging on
+ * machines where Codex is not set up, and honors "only once the user chose it at
+ * install".
+ *
+ * Escape hatch: a `.byan-codex-autodelegate/off` file in the project root forces
+ * silence even when enabled. Always exits 0; never blocks prompt submission.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { readStdin, parseJson } = require('./lib/strict-runtime');
+const { decideAutodelegation, renderNudge } = require('./lib/autodelegate-decision');
+const { estimateClaudeUsage } = require('./lib/usage-estimator');
+
+// Load the opt-in config; absent/invalid -> disarmed ({ enabled: false }).
+function loadConfig(projectRoot) {
+  try {
+    const p = path.join(projectRoot, '_byan', '_config', 'autodelegate.json');
+    if (!fs.existsSync(p)) return { enabled: false };
+    const cfg = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return cfg && typeof cfg === 'object' ? cfg : { enabled: false };
+  } catch {
+    return { enabled: false };
+  }
+}
+
+function toggledOff(projectRoot) {
+  try {
+    return fs.existsSync(path.join(projectRoot, '.byan-codex-autodelegate', 'off'));
+  } catch {
+    return false;
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    let additionalContext = '';
+    try {
+      const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+      const config = loadConfig(projectRoot);
+      if (config.enabled === true && !toggledOff(projectRoot)) {
+        const payload = parseJson(await readStdin());
+        const prompt = payload.prompt || payload.user_prompt || payload.userPrompt || '';
+        // Estimate usage only when a budget is configured; else pct stays null and
+        // the decision falls back to nature-based delegation (still useful).
+        const usage = estimateClaudeUsage({ budget: config.budget || null });
+        const decision = decideAutodelegation({ requestText: prompt, usage, config });
+        additionalContext = renderNudge(decision);
+      }
+    } catch {
+      additionalContext = ''; // never block prompt submission
+    }
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+      })
+    );
+    process.exit(0);
+  })();
+}
+
+module.exports = { loadConfig, toggledOff };