blun-king-cli 9.1.589 → 9.1.595

package/bin/agentspine-king-worker-host.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { appendFile, mkdir, readFile, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import { createGoalHostFactory } from './agentspine-king-host-runner.mjs';
+import { ingestGoalInbox } from './agentspine-king-goal-inbox.mjs';
+import { createGoalStatusReporter, goalResultRejectionCode } from './agentspine-king-status-policy.mjs';
+import snapshotPolicy from './agentspine-king-snapshot-policy.cjs';
+
+const packageRoot = path.resolve(import.meta.dirname, '..');
+const required = ['blunHome', 'profile', 'projectRoot', 'projectId', 'standFile', 'expectedStandSha256',
+  'expectedSnapshotSha256', 'exchangeDirectory', 'telegramQueueFile', 'instructionSenderId', 'instructionChatId',
+  'logicalPersonaId', 'runtimePersonaId', 'groupId', 'ownerSubjectId', 'permission', 'gatewayStateDirectory'];
+
+export async function loadWorkerConfig(file) {
+  const config = JSON.parse(await readFile(path.resolve(file), 'utf8'));
+  if (config?.schema !== 'blun.king-goal-worker-config/v1'
+    || required.some(key => typeof config[key] !== 'string' || !config[key])
+    || (config.instructionThreadId !== null && config.instructionThreadId !== undefined && (typeof config.instructionThreadId !== 'string'
+      || !/^[1-9][0-9]*$/.test(config.instructionThreadId) || !Number.isSafeInteger(Number(config.instructionThreadId))))
+    || !['manual', 'auto', 'yolo'].includes(config.permission)) throw new Error('KING_WORKER_CONFIG_INVALID');
+  for (const key of ['blunHome', 'projectRoot', 'exchangeDirectory', 'telegramQueueFile', 'gatewayStateDirectory']) {
+    if (!path.isAbsolute(config[key])) throw new Error('KING_WORKER_ABSOLUTE_PATH_REQUIRED');
+  }
+  const blunHome = await realpath(config.blunHome);
+  const relative = path.relative(blunHome, path.resolve(config.gatewayStateDirectory));
+  if (path.isAbsolute(relative) || relative === '..' || relative.startsWith('..' + path.sep)) throw new Error('KING_WORKER_STATE_OUTSIDE_APP_HOME');
+  const state = await realpath(config.gatewayStateDirectory);
+  const canonicalRelative = path.relative(blunHome, state);
+  if (path.isAbsolute(canonicalRelative) || canonicalRelative === '..' || canonicalRelative.startsWith('..' + path.sep)) {
+    throw new Error('KING_WORKER_STATE_OUTSIDE_APP_HOME');
+  }
+  return Object.freeze({ ...config, blunHome, gatewayStateDirectory: state, projectRoot: await realpath(config.projectRoot) });
+}
+
+export async function runGuardedWorkerTick(context) {
+  const { config, gateway, hostFactory, env, adapter } = context;
+  const snapshot = snapshotPolicy.verifyWorkspaceSnapshot({ root: config.projectRoot, projectId: config.projectId,
+    standFile: config.standFile, expectedStandSha256: config.expectedStandSha256,
+    expectedSnapshotSha256: config.expectedSnapshotSha256 });
+  const personas = await gateway.loadPersonaRuntime(snapshot.root);
+  const persona = personas.runtime.personas.find(item => item.personaId === config.runtimePersonaId && item.status === 'active');
+  const binding = personas.policy.bindings.find(item => item.id === persona?.bindingId && item.active);
+  if (!binding || binding.profileId !== config.profile || binding.groupId !== config.groupId) {
+    throw new Error('KING_WORKER_IDENTITY_MISMATCH');
+  }
+  const { withOwnedFileLock } = await import(pathToFileURL(path.join(packageRoot,
+    'agent-spine-plugin/src/lib/owned-file-lock.js')).href);
+  const statusReporter = createGoalStatusReporter({
+    stateFile: path.join(config.blunHome, 'worker', 'goal-status-v2.json'),
+    scope: { logicalPersonaId: config.logicalPersonaId, runtimePersonaId: config.runtimePersonaId,
+      projectId: config.projectId, groupId: config.groupId, ownerSubjectId: config.ownerSubjectId,
+      chatId: config.instructionChatId, senderId: config.instructionSenderId,
+      threadId: config.instructionThreadId ?? null },
+    withOwnedFileLock, loadPolicy: () => gateway.loadChannelPolicy(snapshot.root), adapter,
+  });
+  const statusReports = [];
+  const reportCommittedStatus = async () => {
+    const context = await gateway.gatewayContext({ root: snapshot.root, agentId: config.runtimePersonaId });
+    if (!context.enabled || context.killSwitch) return;
+    await statusReporter.reconcile(context);
+    statusReports.push(...await statusReporter.flush());
+  };
+  // Reconcile the saved goal state first: a prior process may have stopped after committing its tick.
+  await reportCommittedStatus();
+  const intake = await ingestGoalInbox({ exchangeDirectory: config.exchangeDirectory,
+    queueFile: config.telegramQueueFile, checkpointFile: path.join(config.blunHome, 'worker', 'goal-queue-checkpoint.json'),
+    instructionSenderId: config.instructionSenderId, instructionChatId: config.instructionChatId,
+    instructionThreadId: config.instructionThreadId,
+    logicalPersonaId: config.logicalPersonaId, runtimePersonaId: config.runtimePersonaId,
+    projectId: config.projectId, groupId: config.groupId, ownerSubjectId: config.ownerSubjectId,
+    snapshot, assignGoal: gateway.assignGoal,
+    recordResult: result => result.status === 'rejected'
+      ? statusReporter.record({ kind: 'intake-rejected', eventId: result.eventId,
+        messageId: result.messageId, error: result.error }) : undefined });
+  const result = await gateway.runWorkerTick({ root: snapshot.root, workerId: 'gateway-worker:blun:' + process.pid,
+    agentId: config.runtimePersonaId, projectId: config.projectId, groupId: config.groupId,
+    goalOnly: true, env,
+    hostFactory: async item => {
+      const host = await hostFactory(item);
+      return { ...host, async run() {
+        try { return await host.run(); }
+        catch (error) {
+          const rejection = goalResultRejectionCode(error);
+          if (rejection) {
+            // Record the concrete parser failure before the gateway replaces it with an execution hold.
+            await statusReporter.record({ kind: 'result-rejected', eventId: `${item.queueId}:${item.attempts}`,
+              goalId: item.goal.goalId, goalStepId: item.goalStep?.stepId ?? null,
+              attempt: item.attempts, error: rejection });
+          }
+          throw error;
+        }
+      } };
+    },
+    adapter: { send: item => adapter.send(item) } });
+  await reportCommittedStatus();
+  return { ...result, intake, statusReports };
+}
+
+export async function runWorkerHost(config, { once = false, signal, onResult = () => {} } = {}) {
+  const gateway = await import(pathToFileURL(path.join(packageRoot, 'agent-spine-plugin/src/index.js')).href);
+  const { createKingWorkerHarness, LocalKaos } = await import(pathToFileURL(path.join(packageRoot, 'worker-host.mjs')).href);
+  const env = { ...process.env, BLUN_HOME: config.blunHome, BLUN_PROFILE: config.profile };
+  const harness = createKingWorkerHarness({ homeDir: config.blunHome, configPath: config.settingsPath });
+  const hostFactory = createGoalHostFactory({ harness, workDir: config.projectRoot, model: config.model,
+    permission: config.permission, tickTimeoutMs: config.tickTimeoutMs, cleanupTimeoutMs: config.cleanupTimeoutMs,
+    sessionOptions: { kaos: (await LocalKaos.create()).withCwd(config.projectRoot).withEnv({
+      BLUN_HOME: config.blunHome, BLUN_PROFILE: config.profile, AGENTSPINE_STATE_DIR: config.gatewayStateDirectory,
+    }) },
+    signal });
+  const adapter = gateway.createTelegramAdapter({ root: config.projectRoot, env });
+  try {
+    do {
+      if (signal?.aborted) return { status: 'stopped', processed: false };
+      const result = await runGuardedWorkerTick({ config, gateway, hostFactory, env, adapter });
+      await mkdir(path.join(config.blunHome, 'worker'), { recursive: true });
+      await appendFile(path.join(config.blunHome, 'worker', 'worker.log'), JSON.stringify({
+        schema: 'blun.king-goal-worker-log/v1', at: new Date().toISOString(), status: result.status,
+        queueId: result.queueId ?? null, hostSettlement: result.hostSettlement ?? null,
+        statusReports: result.statusReports,
+        intake: result.intake.map(item => ({ status: item.status, messageId: item.messageId, error: item.error }))
+      }) + '\n', { mode: 0o600 });
+      await onResult(result);
+      if (once || result.status === 'stopped' || result.status === 'blocked') return result;
+      await delay(result.processed ? 1000 : 15000, undefined, { signal }).catch(error => {
+        if (error.name !== 'AbortError') throw error;
+      });
+    } while (!signal?.aborted);
+    return { status: 'stopped', processed: false };
+  } finally {
+    let quiet = true;
+    for (const session of harness.sessions.values()) {
+      const proof = await session.quiesce({ deadlineAt: Date.now() + (config.cleanupTimeoutMs ?? 10000) }).catch(() => null);
+      if (!proof || proof.status !== 'quiescent' || proof.remaining.length) quiet = false;
+    }
+    // Never turn a cleanup deadline into a successful host termination acknowledgement.
+    if (quiet) await harness.close();
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const index = args.indexOf('--config');
+  if (index < 0 || !args[index + 1] || args[index + 1].startsWith('--')) throw new Error('--config requires a path');
+  const config = await loadWorkerConfig(args[index + 1]);
+  process.env.BLUN_HOME = config.blunHome;
+  process.env.BLUN_PROFILE = config.profile;
+  process.env.AGENTSPINE_STATE_DIR = config.gatewayStateDirectory;
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once('SIGINT', stop); process.once('SIGTERM', stop);
+  try { await runWorkerHost(config, { once: args.includes('--once'), signal: controller.signal,
+    onResult: result => process.stdout.write(JSON.stringify(result) + '\n') }); }
+  finally { process.removeListener('SIGINT', stop); process.removeListener('SIGTERM', stop); }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch(error => { process.stderr.write(String(error.message).slice(0, 500) + '\n'); process.exitCode = 1; });
+}

package/bin/core-bootstrap.js

@@ -5,22 +5,39 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
 const { acquireSharedRuntimeLease } = require('./update-lease');
+const { installWindowsNodeCrashDump } = require('./windows-node-crash-dump.cjs');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 
 const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
 
 async function runCoreBootstrap() {
+  let diagnostics;
+  try { diagnostics = installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME }); } catch {}
   const packageRoot = path.resolve(__dirname, '..');
   const mainPath = path.join(packageRoot, 'blun.mjs');
-  const leaseResult = await acquireSharedRuntimeLease({ packageRoot });
-  if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
+  let leaseResult;
 
   try {
+    leaseResult = await acquireSharedRuntimeLease({ packageRoot });
+    if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
     leaseResult.lease.assertOwned();
     process.argv = [process.execPath, mainPath, ...process.argv.slice(2)];
     await import(pathToFileURL(mainPath).href);
     leaseResult.lease.assertOwned();
   } catch (error) {
-    await leaseResult.lease.release();
+    try {
+      if (diagnostics?.enabled) diagnostics.write(error, 'bootstrap-failure');
+      else recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
+        kind: 'bootstrap-failure', phase: 'startup', error });
+    } catch {}
+    try { diagnostics?.dispose(); } catch {}
+    try { await leaseResult?.lease?.release(); }
+    catch (leaseError) {
+      try {
+        recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
+          kind: 'lease-release-failure', phase: 'cleanup', error: leaseError });
+      } catch {}
+    }
     throw error;
   }
 

package/bin/launcher-mode.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
+
 const LAUNCHER_MODES = Object.freeze({
   BLUN: 'blun',
   KING: 'king',
@@ -22,9 +25,43 @@ function launcherModeFromArgv(argv) {
   return command === LAUNCHER_MODES.KING ? LAUNCHER_MODES.KING : LAUNCHER_MODES.BLUN;
 }
 
-function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion) {
+function runtimePolicyEnvironment(blunDir) {
+  if (blunDir === undefined) return {};
+  let policy;
+  try {
+    if (!path.isAbsolute(blunDir)) throw new Error('Invalid home');
+    const file = path.join(blunDir, 'runtime-policy.json');
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096) throw new Error('Invalid file');
+    policy = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw new Error('Invalid BLUN runtime policy');
+  }
+  const review = policy?.responseReview;
+  if (policy?.schema !== 'blun.runtime-policy/v1'
+    || Object.keys(policy).sort().join(',') !== 'responseReview,schema'
+    || !review || Object.keys(review).sort().join(',') !== 'guardVersion,language,required'
+    || review.required !== true || typeof review.language !== 'string'
+    || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(review.language)
+    || /^(auto|all)$/i.test(review.language)
+    || typeof review.guardVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(review.guardVersion)) {
+    throw new Error('Invalid BLUN runtime policy');
+  }
+  return {
+    BLUN_LANGUAGE_GUARD_MANDATORY: '1',
+    BLUN_LANGUAGE_GUARD_LANGUAGE: review.language,
+    BLUN_LANGUAGE_GUARD_VERSION: review.guardVersion,
+    BLUN_TELEGRAM_LANGUAGE_GATE: 'required',
+    BLUN_TELEGRAM_OUTPUT_LOCALE: review.language,
+    AGENTSPINE_STATE_DIR: path.join(blunDir, 'state', 'agent-spine'),
+  };
+}
+
+function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion, blunDir) {
   return {
     ...sourceEnv,
+    ...runtimePolicyEnvironment(blunDir),
     BLUN_NO_AUTO_UPDATE: '1',
     BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
     BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',

package/bin/launcher-restart-policy.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const RESTART_WINDOW_MS = 60 * 60 * 1000;
+const MAX_RESTARTS_PER_WINDOW = 3;
+const RESTART_DELAYS_MS = Object.freeze([1000, 3000, 5000]);
+const INTENTIONAL_STOP_TTL_MS = 2 * 60 * 1000;
+const OPERATOR_SIGNALS = new Set(['SIGHUP', 'SIGINT', 'SIGTERM']);
+
+function restartBudgetPath(homeDir) {
+  return path.join(path.resolve(homeDir), 'diagnostics', 'launcher-restart-budget.json');
+}
+
+function intentionalStopMarkerPath(homeDir) {
+  return path.join(path.resolve(homeDir), 'diagnostics', 'intentional-core-stop.json');
+}
+
+function launcherStatusQueuePath(homeDir, stateDir) {
+  return path.join(stateDir ? path.resolve(stateDir) : path.join(path.resolve(homeDir), 'channels', 'telegram'),
+    'launcher-status-queue.jsonl');
+}
+
+function atomicWriteJson(file, value, fsImpl = fs) {
+  fsImpl.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    fsImpl.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    fsImpl.renameSync(temporary, file);
+  } finally {
+    try { fsImpl.rmSync(temporary, { force: true }); } catch {}
+  }
+}
+
+function claimLauncherRestart(options) {
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const fsImpl = options.fsImpl || fs;
+  const file = restartBudgetPath(options.homeDir);
+  const denied = { allowed: false, attempt: MAX_RESTARTS_PER_WINDOW, limit: MAX_RESTARTS_PER_WINDOW, windowMs: RESTART_WINDOW_MS };
+  let attempts = [];
+  try {
+    const stat = fsImpl.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096) return denied;
+    const saved = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+    if (saved?.schema !== 'blun.launcher-restart-budget/v1' || !Array.isArray(saved.attempts)
+      || saved.attempts.some((value) => !Number.isFinite(value) || value > nowMs)) return denied;
+    attempts = saved.attempts.filter((value) => value > nowMs - RESTART_WINDOW_MS);
+  } catch (error) {
+    if (error.code !== 'ENOENT') return denied;
+  }
+  if (attempts.length >= MAX_RESTARTS_PER_WINDOW) return { ...denied, attempt: attempts.length };
+  attempts.push(nowMs);
+  try {
+    atomicWriteJson(file, {
+      schema: 'blun.launcher-restart-budget/v1', updatedAt: new Date(nowMs).toISOString(), attempts,
+    }, fsImpl);
+  } catch {
+    // Never restart without a durable budget claim.
+    return denied;
+  }
+  return { allowed: true, attempt: attempts.length, limit: MAX_RESTARTS_PER_WINDOW, windowMs: RESTART_WINDOW_MS };
+}
+
+function isWindowsFailFastExitCode(code) {
+  if (!Number.isInteger(code)) return false;
+  const unsigned = code >>> 0;
+  return unsigned >= 0xC0000000 && unsigned !== 0xC000013A;
+}
+
+function isAbnormalCoreExit(result, loaded) {
+  if (OPERATOR_SIGNALS.has(result?.signal)) return false;
+  return Boolean(result?.error) || (loaded === true && isWindowsFailFastExitCode(result?.code));
+}
+
+function writeIntentionalStopMarker(options) {
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const file = intentionalStopMarkerPath(options.homeDir);
+  atomicWriteJson(file, {
+    schema: 'blun.intentional-core-stop/v1', pid: options.pid,
+    createdAtMs: nowMs, expiresAtMs: nowMs + INTENTIONAL_STOP_TTL_MS,
+  }, options.fsImpl);
+  return file;
+}
+
+function consumeIntentionalStopMarker(options) {
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const file = intentionalStopMarkerPath(options.homeDir);
+  const fsImpl = options.fsImpl || fs;
+  let marker;
+  try {
+    const stat = fsImpl.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096) return false;
+    marker = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+    fsImpl.rmSync(file);
+  } catch { return false; }
+  return marker?.schema === 'blun.intentional-core-stop/v1'
+    && Number.isInteger(marker.pid) && marker.pid === options.childPid
+    && Number.isFinite(marker.createdAtMs) && Number.isFinite(marker.expiresAtMs)
+    && marker.createdAtMs <= nowMs && marker.expiresAtMs >= nowMs
+    && marker.expiresAtMs - marker.createdAtMs <= INTENTIONAL_STOP_TTL_MS;
+}
+
+function restartDelayMs(attempt) {
+  return RESTART_DELAYS_MS[Math.max(0, Math.min(RESTART_DELAYS_MS.length - 1, attempt - 1))];
+}
+
+function appendLauncherStatus(options) {
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const exhausted = options.kind === 'launcher-restart-exhausted';
+  const signal = options.signal ? ` signal=${options.signal}` : '';
+  const event = {
+    schema: 'blun.launcher-status/v1', id: crypto.randomUUID(), createdAt: new Date(nowMs).toISOString(),
+    kind: options.kind, attempt: options.attempt, limit: options.limit,
+    exitCode: options.exitCode, signal: options.signal,
+    text: `[launcher.restart] ${exhausted ? 'stopped ' : ''}${options.attempt}/${options.limit} exit=${options.exitCode}${signal}`,
+  };
+  const file = launcherStatusQueuePath(options.homeDir, options.stateDir);
+  const fsImpl = options.fsImpl || fs;
+  fsImpl.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fsImpl.appendFileSync(file, `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600 });
+  return event;
+}
+
+module.exports = {
+  INTENTIONAL_STOP_TTL_MS, MAX_RESTARTS_PER_WINDOW, RESTART_DELAYS_MS, RESTART_WINDOW_MS,
+  appendLauncherStatus, claimLauncherRestart, consumeIntentionalStopMarker, intentionalStopMarkerPath,
+  isAbnormalCoreExit, isWindowsFailFastExitCode, launcherStatusQueuePath, restartBudgetPath,
+  restartDelayMs, writeIntentionalStopMarker,
+};

package/bin/launcher-runtime.js

@@ -22,6 +22,11 @@ const {
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
 const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
+const {
+  appendLauncherStatus, claimLauncherRestart, consumeIntentionalStopMarker,
+  isAbnormalCoreExit, restartDelayMs,
+} = require('./launcher-restart-policy.cjs');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
@@ -109,6 +114,7 @@ function spawnProtectedCore(args, env, cwd) {
   );
   let loadedSettled = false;
   let completedSettled = false;
+  let operatorSignal;
   let resolveLoaded;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
@@ -129,11 +135,12 @@ function spawnProtectedCore(args, env, cwd) {
     completedSettled = true;
     for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
     settleLoaded(false);
-    resolveCompleted(result);
+    resolveCompleted(operatorSignal === undefined ? result : { ...result, signal: operatorSignal });
   };
   const signalHandlers = new Map();
   for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM']) {
     const handler = () => {
+      operatorSignal = signal;
       try {
         child.kill(signal);
       } catch {}
@@ -154,12 +161,45 @@ function spawnProtectedCore(args, env, cwd) {
 }
 
 async function superviseProtectedCore(args, env, cwd, releaseNotice) {
-  const core = spawnProtectedCore(args, env, cwd);
-  const loaded = await core.loaded;
-  await releaseNotice();
-  const result = await core.completed;
-  if (result.error) throw result.error;
-  return exitCodeForChild(result, loaded);
+  let noticeReleased = false;
+  for (;;) {
+    const core = spawnProtectedCore(args, env, cwd);
+    const loaded = await core.loaded;
+    if (!noticeReleased) {
+      noticeReleased = true;
+      await releaseNotice();
+    }
+    const result = await core.completed;
+    const exitCode = result.error ? 1 : exitCodeForChild(result, loaded);
+    const intentionalStop = consumeIntentionalStopMarker({
+      homeDir: env.BLUN_HOME, childPid: core.child.pid, nowMs: Date.now(),
+    });
+    recordRuntimeExit({
+      homeDir: env.BLUN_HOME, source: 'launcher', kind: result.error ? 'child-error' : 'child-exit',
+      exitCode, signal: result.signal, phase: loaded ? 'runtime' : 'startup',
+      cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION, profile: env.BLUN_PROFILE,
+      loaded, childPid: core.child.pid, error: result.error,
+    });
+    if (intentionalStop || !isAbnormalCoreExit(result, loaded)) {
+      if (result.error) throw result.error;
+      return exitCode;
+    }
+    const claim = claimLauncherRestart({ homeDir: env.BLUN_HOME, nowMs: Date.now() });
+    try {
+      appendLauncherStatus({
+        homeDir: env.BLUN_HOME,
+        stateDir: env.BLUN_TELEGRAM_STATE_DIR
+          || path.join(env.BLUN_SHARED_HOME || env.BLUN_HOME, 'channels', 'telegram'),
+        nowMs: Date.now(), attempt: claim.attempt, limit: claim.limit, exitCode, signal: result.signal,
+        kind: claim.allowed ? 'launcher-restart' : 'launcher-restart-exhausted',
+      });
+    } catch {}
+    if (!claim.allowed) {
+      if (result.error) throw result.error;
+      return exitCode;
+    }
+    await new Promise((resolve) => setTimeout(resolve, restartDelayMs(claim.attempt)));
+  }
 }
 
 function exitCodeForChild(result, loaded) {
@@ -403,9 +443,8 @@ async function runLauncher(options = {}) {
     }
 
     // --- 6. Start -----------------------------------------------------------
-    const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
+    const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
     env.BLUN_HOME = blunDir;
-    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,

package/bin/runtime-exit-ledger.cjs

@@ -0,0 +1,144 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const DEFAULT_MAX_BYTES = 1024 * 1024;
+const DEFAULT_RETAIN_BYTES = 512 * 1024;
+
+function runtimeExitLedgerPath(homeDir) {
+  return path.join(homeDir, 'diagnostics', 'runtime-exits.jsonl');
+}
+
+function sanitizeExitText(input, maxChars = 2048) {
+  let value = String(input ?? '');
+  const homes = new Set([os.homedir(), process.env.USERPROFILE, process.env.HOME]
+    .filter((entry) => typeof entry === 'string' && entry.length > 2));
+  for (const home of homes) {
+    for (const variant of [path.normalize(home), home.replaceAll('\\', '/')]) {
+      const escaped = variant.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+      value = value.replace(new RegExp(escaped, process.platform === 'win32' ? 'giu' : 'gu'), '$HOME');
+    }
+  }
+  value = value
+    .replace(/[A-Za-z]:[\\/]Users[\\/][^\\/\s"']+/giu, '$HOME')
+    .replace(/\/home\/[^/\s"']+/gu, '$HOME')
+    .replace(/(Authorization\s*:\s*Bearer\s+)[^\s,;]+/giu, '$1<redacted>')
+    .replace(/\bsk-[A-Za-z0-9_-]{10,}\b/gu, '<redacted>')
+    .replace(/\b\d{6,}:[A-Za-z0-9_-]{20,}\b/gu, '<redacted>')
+    .replace(/("(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)"\s*:\s*)"(?:\\.|[^"\\])*"/giu, '$1"<redacted>"')
+    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)\s*[=:]\s*)[^\s,;}]+/giu, '$1<redacted>')
+    .replace(/(https?:\/\/[^\s/:@]+:)[^\s/@]+@/giu, '$1<redacted>@');
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...[truncated]`;
+}
+
+function buildRuntimeExitRecord(input) {
+  const now = typeof input.now === 'function' ? input.now() : new Date();
+  const record = { schemaVersion: 1, ts: new Date(now).toISOString() };
+  for (const key of ['source', 'kind', 'signal', 'phase', 'cliVersion', 'profile', 'sessionId', 'lastTool', 'detail']) {
+    if (input[key] !== undefined && input[key] !== '') record[key] = sanitizeExitText(input[key]);
+  }
+  for (const [key, value] of Object.entries({ exitCode: input.exitCode, pid: input.pid ?? process.pid,
+    ppid: input.ppid ?? process.ppid, childPid: input.childPid })) {
+    if (Number.isInteger(value)) record[key] = value;
+  }
+  if (typeof input.loaded === 'boolean') record.loaded = input.loaded;
+  if (input.error !== undefined && input.error !== null) {
+    record.error = {
+      name: sanitizeExitText(input.error.name || 'Error', 160),
+      message: sanitizeExitText(input.error.message || input.error),
+      stack: sanitizeExitText(input.error.stack || '', 8192),
+    };
+  }
+  return record;
+}
+
+function directoryIdentity(directory) {
+  const stat = fs.lstatSync(directory, { bigint: true });
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('Unsafe exit directory');
+  return stat;
+}
+
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+
+function regularLedger(stat) {
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n) throw new Error('Unsafe exit ledger');
+  return stat;
+}
+
+function trimLedger(descriptor, maxBytes, retainBytes, incomingBytes) {
+  const size = Number(regularLedger(fs.fstatSync(descriptor, { bigint: true })).size);
+  if (!Number.isSafeInteger(size)) throw new Error('Invalid exit ledger size');
+  if (size + incomingBytes <= maxBytes) return;
+  const keepBytes = Math.max(0, Math.min(size, retainBytes, maxBytes - incomingBytes));
+  const contents = Buffer.alloc(keepBytes);
+  const read = fs.readSync(descriptor, contents, 0, keepBytes, size - keepBytes);
+  const tail = contents.subarray(0, read);
+  const lineStart = size > keepBytes ? tail.indexOf(0x0a) + 1 : 0;
+  fs.ftruncateSync(descriptor, 0);
+  fs.writeFileSync(descriptor, lineStart > 0 || size === keepBytes ? tail.subarray(lineStart) : '');
+}
+
+function recordRuntimeExit(input = {}) {
+  let descriptor;
+  let appendDescriptor;
+  try {
+    const homeDir = typeof input.homeDir === 'string' ? input.homeDir.trim() : '';
+    if (!homeDir || !path.isAbsolute(homeDir)) return false;
+    // Pin the private home and diagnostic directory before opening any output.
+    fs.mkdirSync(homeDir, { recursive: true, mode: 0o700 });
+    const homeIdentity = directoryIdentity(homeDir);
+    const file = runtimeExitLedgerPath(homeDir);
+    const directory = path.dirname(file);
+    try { fs.mkdirSync(directory, { mode: 0o700 }); }
+    catch (error) { if (error.code !== 'EEXIST') throw error; }
+    const directoryStat = directoryIdentity(directory);
+    let before;
+    try { before = regularLedger(fs.lstatSync(file, { bigint: true })); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    const flags = fs.constants.O_RDWR | (fs.constants.O_NOFOLLOW ?? 0)
+      | (fs.constants.O_NONBLOCK ?? 0) | (before ? 0 : fs.constants.O_CREAT | fs.constants.O_EXCL);
+    descriptor = fs.openSync(file, flags, 0o600);
+    const opened = regularLedger(fs.fstatSync(descriptor, { bigint: true }));
+    if ((before && !sameIdentity(before, opened))
+      || !sameIdentity(opened, regularLedger(fs.lstatSync(file, { bigint: true })))
+      || !sameIdentity(homeIdentity, directoryIdentity(homeDir))
+      || !sameIdentity(directoryStat, directoryIdentity(directory))) throw new Error('Exit ledger changed');
+    const maxBytes = Math.max(1024, Number.isInteger(input.maxBytes) ? input.maxBytes : DEFAULT_MAX_BYTES);
+    const retainBytes = Math.max(0, Number.isInteger(input.retainBytes) ? input.retainBytes : DEFAULT_RETAIN_BYTES);
+    const record = buildRuntimeExitRecord(input);
+    let line = `${JSON.stringify(record)}\n`;
+    // Retain identity/exit fields even when a diagnostic detail exceeds the cap.
+    for (const key of ['error', 'detail', 'lastTool', 'sessionId', 'profile', 'cliVersion', 'phase', 'source', 'kind', 'signal']) {
+      if (Buffer.byteLength(line) <= maxBytes) break;
+      delete record[key];
+      record.truncated = true;
+      line = `${JSON.stringify(record)}\n`;
+    }
+    trimLedger(descriptor, maxBytes, retainBytes, Buffer.byteLength(line));
+    // Windows append-only handles cannot truncate. Keep both handles bound to
+    // the same checked inode, using the second handle only for atomic append.
+    appendDescriptor = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND
+      | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+    if (!sameIdentity(opened, regularLedger(fs.fstatSync(appendDescriptor, { bigint: true })))
+      || !sameIdentity(opened, regularLedger(fs.lstatSync(file, { bigint: true })))
+      || !sameIdentity(homeIdentity, directoryIdentity(homeDir))
+      || !sameIdentity(directoryStat, directoryIdentity(directory))) throw new Error('Exit ledger changed');
+    fs.appendFileSync(appendDescriptor, line, { encoding: 'utf8' });
+    try { fs.fchmodSync(descriptor, 0o600); } catch {}
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (appendDescriptor !== undefined) { try { fs.closeSync(appendDescriptor); } catch {} }
+    if (descriptor !== undefined) { try { fs.closeSync(descriptor); } catch {} }
+  }
+}
+
+module.exports = {
+  DEFAULT_MAX_BYTES, DEFAULT_RETAIN_BYTES, buildRuntimeExitRecord, recordRuntimeExit,
+  runtimeExitLedgerPath, sanitizeExitText,
+};

package/bin/runtime-exit-ledger.d.cts

@@ -0,0 +1,23 @@
+export interface RuntimeExitInput {
+  homeDir?: string;
+  source?: string;
+  kind?: string;
+  signal?: string;
+  phase?: string;
+  cliVersion?: string;
+  profile?: string;
+  sessionId?: string;
+  lastTool?: string;
+  detail?: string;
+  exitCode?: number;
+  pid?: number;
+  ppid?: number;
+  childPid?: number;
+  loaded?: boolean;
+  error?: unknown;
+  maxBytes?: number;
+  retainBytes?: number;
+  now?: () => Date | number | string;
+}
+
+export function recordRuntimeExit(input?: RuntimeExitInput): boolean;