blun-king-cli 9.1.421 → 9.1.423

package/LIESMICH.txt

@@ -106,6 +106,8 @@ ausdrücklichen Trigger-Beleg. Andere Trigger-Arten dürfen kein `dueAt`
 enthalten. Ein Laufzeit-Wecker für eine durchgehend geöffnete Sitzung ist in
 diesem Release noch nicht enthalten.
 
+Ab BLUN King 9.1.422 überwacht auch eine durchgehend geöffnete, untätige Sitzung ihren gespeicherten Zeit-Trigger. Sobald `dueAt` erreicht oder überschritten ist, fügt der Auto- oder God-Modus genau eine verborgene Fortsetzung in dieselbe Sitzung ein. Wird der Zeitpunkt während einer laufenden Antwort, Verdichtung, wartenden Nachricht, eines Befehls oder Dialogs fällig, wartet die Fortsetzung bis zum Leerlauf. Unmittelbar vor dem Start liest King Ziel, Checkpoint-Revision, Fälligkeit, Berechtigungsmodus und Sitzung erneut; ein geänderter oder veralteter Trigger kann deshalb nicht auslösen. Stoppen, Notausgang, Entladen und Wechseln der Sitzung entsorgen den Timer. Im manuellen Modus erfolgt kein selbstständiger Start.
+
 Zuverlässiger King-Start
 -----------------------
 Bei einer ausdrücklich als wiederholbar gekennzeichneten Serverüberlastung

package/README.md

@@ -125,6 +125,8 @@ ausdrücklichen Trigger-Beleg. Andere Trigger-Arten dürfen kein `dueAt`
 enthalten. Ein Laufzeit-Wecker für eine durchgehend geöffnete Sitzung ist in
 diesem Release noch nicht enthalten.
 
+Ab BLUN King 9.1.422 überwacht auch eine durchgehend geöffnete, untätige Sitzung ihren gespeicherten Zeit-Trigger. Sobald `dueAt` erreicht oder überschritten ist, fügt der Auto- oder God-Modus genau eine verborgene Fortsetzung in dieselbe Sitzung ein. Wird der Zeitpunkt während einer laufenden Antwort, Verdichtung, wartenden Nachricht, eines Befehls oder Dialogs fällig, wartet die Fortsetzung bis zum Leerlauf. Unmittelbar vor dem Start liest King Ziel, Checkpoint-Revision, Fälligkeit, Berechtigungsmodus und Sitzung erneut; ein geänderter oder veralteter Trigger kann deshalb nicht auslösen. Stoppen, Notausgang, Entladen und Wechseln der Sitzung entsorgen den Timer. Im manuellen Modus erfolgt kein selbstständiger Start.
+
 ## Zuverlässiger King-Start
 
 Bei einer vom Server ausdrücklich als wiederholbar gekennzeichneten

package/bin/cognitive-goal-autostart-policy.cjs

@@ -7,6 +7,40 @@ const START = Object.freeze({ kind: 'start', trigger: 'immediate' });
 const WAIT = Object.freeze({ kind: 'wait' });
 const CONTINUE = Object.freeze({ kind: 'continue' });
 const YIELD = Object.freeze({ kind: 'yield' });
+const IGNORE = Object.freeze({ kind: 'ignore' });
+
+function goalTimeTriggerDecision({ goal, permissionMode, now = new Date() } = {}) {
+  if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return IGNORE;
+  if (goal.status !== 'active' || !AUTONOMOUS_PERMISSION_MODES.has(permissionMode)) return IGNORE;
+  if (typeof goal.goalId !== 'string' || goal.goalId.trim().length === 0) return IGNORE;
+
+  const checkpoint = goal.actionCheckpoint;
+  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) return IGNORE;
+  if (!Number.isInteger(checkpoint.revision) || checkpoint.revision < 1) return IGNORE;
+  if (checkpoint.phase !== 'wait') return IGNORE;
+  const trigger = checkpoint.nextTrigger;
+  if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) return IGNORE;
+  if (trigger.kind !== 'time' || typeof trigger.condition !== 'string' || trigger.condition.trim().length === 0) return IGNORE;
+
+  const dueAt = String(trigger.dueAt ?? '');
+  if (!ISO_TIMESTAMP_RE.test(dueAt)) return IGNORE;
+  const dueAtMs = new Date(dueAt).getTime();
+  const nowMs = new Date(now).getTime();
+  if (!Number.isFinite(dueAtMs) || !Number.isFinite(nowMs)) return IGNORE;
+  const key = `${goal.goalId}:${checkpoint.revision}:${dueAt}`;
+  if (dueAtMs > nowMs) return Object.freeze({
+    kind: 'schedule',
+    key,
+    dueAt,
+    delayMs: dueAtMs - nowMs,
+  });
+  return Object.freeze({
+    kind: 'due',
+    key,
+    dueAt,
+    observation: `The checkpointed time trigger became due at ${dueAt}.`,
+  });
+}
 
 function goalAutostartDecision({ goal, permissionMode, now = new Date() } = {}) {
   if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return WAIT;
@@ -18,18 +52,13 @@ function goalAutostartDecision({ goal, permissionMode, now = new Date() } = {})
   if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) return WAIT;
   if (typeof trigger.condition !== 'string' || trigger.condition.trim().length === 0) return WAIT;
   if (ACTIVE_PHASES.has(checkpoint.phase) && trigger.kind === 'immediate') return START;
-  if (checkpoint.phase !== 'wait' || trigger.kind !== 'time') return WAIT;
-
-  const dueAt = String(trigger.dueAt ?? '');
-  if (!ISO_TIMESTAMP_RE.test(dueAt)) return WAIT;
-  const dueAtMs = new Date(dueAt).getTime();
-  const nowMs = new Date(now).getTime();
-  if (!Number.isFinite(dueAtMs) || !Number.isFinite(nowMs) || dueAtMs > nowMs) return WAIT;
+  const timed = goalTimeTriggerDecision({ goal, permissionMode, now });
+  if (timed.kind !== 'due') return WAIT;
   return Object.freeze({
     kind: 'start',
     trigger: 'time',
-    dueAt,
-    observation: `The checkpointed time trigger became due at ${dueAt}.`,
+    dueAt: timed.dueAt,
+    observation: timed.observation,
   });
 }
 
@@ -40,4 +69,4 @@ function goalContinuationDecision({ goal } = {}) {
   return checkpoint.phase === 'wait' ? YIELD : CONTINUE;
 }
 
-module.exports = { goalAutostartDecision, goalContinuationDecision };
+module.exports = { goalAutostartDecision, goalContinuationDecision, goalTimeTriggerDecision };

package/bin/cognitive-goal-time-trigger-controller.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+const { goalTimeTriggerDecision } = require('./cognitive-goal-autostart-policy.cjs');
+
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
+class GoalTimeTriggerController {
+  #readState;
+  #start;
+  #now;
+  #setTimer;
+  #clearTimer;
+  #onError;
+  #retryDelayMs;
+  #timer;
+  #timerKey;
+  #inFlightKey;
+  #startedKey;
+  #generation = 0;
+  #disposed = false;
+
+  constructor({
+    readState,
+    start,
+    now = () => new Date(),
+    setTimer = setTimeout,
+    clearTimer = clearTimeout,
+    onError = () => {},
+    retryDelayMs = 1_000,
+  } = {}) {
+    if (typeof readState !== 'function') throw new TypeError('readState must be a function');
+    if (typeof start !== 'function') throw new TypeError('start must be a function');
+    this.#readState = readState;
+    this.#start = start;
+    this.#now = now;
+    this.#setTimer = setTimer;
+    this.#clearTimer = clearTimer;
+    this.#onError = onError;
+    this.#retryDelayMs = retryDelayMs;
+  }
+
+  sync() {
+    if (this.#disposed) return undefined;
+    const state = this.#readState() ?? {};
+    const decision = goalTimeTriggerDecision({
+      goal: state.goal,
+      permissionMode: state.permissionMode,
+      now: this.#now(),
+    });
+    if (decision.kind === 'ignore' || typeof state.sessionId !== 'string' || state.sessionId.length === 0) {
+      this.#clearScheduledTimer();
+      return undefined;
+    }
+
+    const key = `${state.sessionId}:${decision.key}`;
+    if (this.#startedKey === key || this.#inFlightKey === key) {
+      this.#clearScheduledTimer();
+      return undefined;
+    }
+    if (decision.kind === 'schedule') {
+      this.#schedule(key, Math.min(MAX_TIMER_DELAY_MS, Math.max(0, decision.delayMs)));
+      return undefined;
+    }
+
+    this.#clearScheduledTimer();
+    if (state.idle !== true) return undefined;
+    return this.#startDueTrigger(key, decision);
+  }
+
+  reset() {
+    this.#generation += 1;
+    this.#clearScheduledTimer();
+    this.#inFlightKey = undefined;
+    this.#startedKey = undefined;
+  }
+
+  dispose() {
+    this.reset();
+    this.#disposed = true;
+  }
+
+  #schedule(key, delayMs) {
+    if (this.#timer !== undefined && this.#timerKey === key) return;
+    this.#clearScheduledTimer();
+    this.#timerKey = key;
+    this.#timer = this.#setTimer(() => {
+      this.#timer = undefined;
+      this.#timerKey = undefined;
+      void this.sync();
+    }, delayMs);
+    this.#timer?.unref?.();
+  }
+
+  #startDueTrigger(key, decision) {
+    const generation = this.#generation;
+    this.#inFlightKey = key;
+    const trigger = {
+      key,
+      trigger: 'time',
+      dueAt: decision.dueAt,
+      observation: decision.observation,
+    };
+    let result;
+    try {
+      result = this.#start(trigger);
+    } catch (error) {
+      result = Promise.reject(error);
+    }
+    return Promise.resolve(result).then((accepted) => {
+      if (this.#disposed || generation !== this.#generation || this.#inFlightKey !== key) return false;
+      this.#inFlightKey = undefined;
+      if (accepted === true) {
+        this.#startedKey = key;
+        return true;
+      }
+      this.#scheduleRetry(key);
+      return false;
+    }, (error) => {
+      if (!this.#disposed && generation === this.#generation && this.#inFlightKey === key) {
+        this.#inFlightKey = undefined;
+        this.#onError(error);
+        this.#scheduleRetry(key);
+      }
+      return false;
+    });
+  }
+
+  #scheduleRetry(key) {
+    const state = this.#readState() ?? {};
+    const decision = goalTimeTriggerDecision({
+      goal: state.goal,
+      permissionMode: state.permissionMode,
+      now: this.#now(),
+    });
+    if (decision.kind !== 'due' || `${state.sessionId}:${decision.key}` !== key) return;
+    this.#schedule(key, this.#retryDelayMs);
+  }
+
+  #clearScheduledTimer() {
+    if (this.#timer !== undefined) this.#clearTimer(this.#timer);
+    this.#timer = undefined;
+    this.#timerKey = undefined;
+  }
+}
+
+module.exports = { GoalTimeTriggerController, MAX_TIMER_DELAY_MS };

package/bin/launcher-runtime.js

@@ -29,6 +29,7 @@ const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 const { acquireSharedRuntimeLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
@@ -218,8 +219,35 @@ async function superviseProtectedCore(args, env, cwd, releaseLauncherLeases, opt
   const loaded = await core.loaded;
   if (loaded) await releaseLauncherLeases();
   const result = await core.completed;
-  if (result.error) throw result.error;
-  return exitCodeForChild(result, loaded);
+  if (result.error) {
+    recordRuntimeExit({
+      homeDir: env.BLUN_HOME,
+      source: 'launcher',
+      kind: 'child-error',
+      exitCode: 1,
+      phase: loaded ? 'runtime' : 'startup',
+      cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION,
+      profile: env.BLUN_PROFILE,
+      loaded,
+      childPid: core.child?.pid,
+      error: result.error,
+    });
+    throw result.error;
+  }
+  const exitCode = exitCodeForChild(result, loaded);
+  recordRuntimeExit({
+    homeDir: env.BLUN_HOME,
+    source: 'launcher',
+    kind: '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,
+  });
+  return exitCode;
 }
 
 function installTelegramForProfile(packageRoot, blunDir) {

package/bin/runtime-exit-ledger.cjs

@@ -0,0 +1,143 @@
+'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;
+const MAX_MESSAGE_CHARS = 2048;
+const MAX_STACK_CHARS = 8192;
+const MAX_DETAIL_CHARS = 2048;
+
+function runtimeExitLedgerPath(homeDir) {
+  return path.join(homeDir, 'diagnostics', 'runtime-exits.jsonl');
+}
+
+function replaceAllLiteral(value, needle, replacement) {
+  if (!needle) return value;
+  const lowerValue = process.platform === 'win32' ? value.toLowerCase() : value;
+  const lowerNeedle = process.platform === 'win32' ? needle.toLowerCase() : needle;
+  let result = '';
+  let cursor = 0;
+  for (;;) {
+    const index = lowerValue.indexOf(lowerNeedle, cursor);
+    if (index === -1) return `${result}${value.slice(cursor)}`;
+    result += `${value.slice(cursor, index)}${replacement}`;
+    cursor = index + needle.length;
+  }
+}
+
+function sanitizeExitText(input, maxChars = MAX_DETAIL_CHARS) {
+  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) {
+    value = replaceAllLiteral(value, path.normalize(home), '$HOME');
+    value = replaceAllLiteral(value, home.replaceAll('\\', '/'), '$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*)[^\s,;}]+/giu, '$1<redacted>')
+    .replace(/(https?:\/\/[^\s/:@]+:)[^\s/@]+@/giu, '$1<redacted>@');
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...[truncated]`;
+}
+
+function normalizedError(error) {
+  if (error === undefined || error === null) return undefined;
+  if (error instanceof Error) {
+    return {
+      name: sanitizeExitText(error.name || error.constructor?.name || 'Error', 160),
+      message: sanitizeExitText(error.message || String(error), MAX_MESSAGE_CHARS),
+      stack: sanitizeExitText(error.stack || '', MAX_STACK_CHARS),
+    };
+  }
+  return {
+    name: typeof error === 'object' && typeof error.name === 'string'
+      ? sanitizeExitText(error.name, 160)
+      : 'NonErrorRejection',
+    message: sanitizeExitText(error, MAX_MESSAGE_CHARS),
+  };
+}
+
+function finiteInteger(value) {
+  return Number.isInteger(value) ? value : undefined;
+}
+
+function buildRuntimeExitRecord(input) {
+  const now = typeof input.now === 'function' ? input.now() : new Date();
+  const record = {
+    schemaVersion: 1,
+    ts: (now instanceof Date ? now : new Date(now)).toISOString(),
+    source: sanitizeExitText(input.source || 'unknown', 80),
+    kind: sanitizeExitText(input.kind || 'unknown', 120),
+    exitCode: finiteInteger(input.exitCode),
+    signal: input.signal ? sanitizeExitText(input.signal, 40) : undefined,
+    phase: input.phase ? sanitizeExitText(input.phase, 80) : undefined,
+    cliVersion: input.cliVersion ? sanitizeExitText(input.cliVersion, 80) : undefined,
+    profile: input.profile ? sanitizeExitText(input.profile, 120) : undefined,
+    sessionId: input.sessionId ? sanitizeExitText(input.sessionId, 240) : undefined,
+    pid: finiteInteger(input.pid ?? process.pid),
+    ppid: finiteInteger(input.ppid ?? process.ppid),
+    childPid: finiteInteger(input.childPid),
+    loaded: typeof input.loaded === 'boolean' ? input.loaded : undefined,
+    detail: input.detail ? sanitizeExitText(input.detail, MAX_DETAIL_CHARS) : undefined,
+    error: normalizedError(input.error),
+  };
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function trimLedger(filePath, maxBytes, retainBytes, incomingBytes) {
+  let size;
+  try {
+    size = fs.statSync(filePath).size;
+  } catch {
+    return;
+  }
+  if (size + incomingBytes <= maxBytes) return;
+  const contents = fs.readFileSync(filePath);
+  const keepFrom = Math.max(0, contents.length - Math.min(retainBytes, maxBytes - incomingBytes));
+  let lineStart = keepFrom;
+  if (lineStart > 0) {
+    const nextNewline = contents.indexOf(0x0a, lineStart);
+    lineStart = nextNewline === -1 ? contents.length : nextNewline + 1;
+  }
+  fs.writeFileSync(filePath, contents.subarray(lineStart), { mode: 0o600 });
+}
+
+function recordRuntimeExit(input = {}) {
+  try {
+    const homeDir = typeof input.homeDir === 'string' ? input.homeDir.trim() : '';
+    if (!homeDir) return false;
+    const filePath = runtimeExitLedgerPath(homeDir);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const line = `${JSON.stringify(buildRuntimeExitRecord(input))}\n`;
+    const incomingBytes = Buffer.byteLength(line);
+    const maxBytes = Math.max(1024, finiteInteger(input.maxBytes) ?? DEFAULT_MAX_BYTES);
+    const retainBytes = Math.max(0, finiteInteger(input.retainBytes) ?? DEFAULT_RETAIN_BYTES);
+    trimLedger(filePath, maxBytes, retainBytes, incomingBytes);
+    fs.appendFileSync(filePath, line, { encoding: 'utf8', mode: 0o600 });
+    try {
+      fs.chmodSync(filePath, 0o600);
+    } catch {}
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_RETAIN_BYTES,
+  buildRuntimeExitRecord,
+  recordRuntimeExit,
+  runtimeExitLedgerPath,
+  sanitizeExitText,
+};

package/blun.mjs

@@ -7,6 +7,8 @@ const __dirname = __cjsShimDirname(__filename);
 import { createRequire } from "node:module";
 import telegramConsoleStatusPolicy from "./bin/telegram-console-status-policy.cjs";
 import cognitiveGoalAutostartPolicy from "./bin/cognitive-goal-autostart-policy.cjs";
+import cognitiveGoalTimeTriggerController from "./bin/cognitive-goal-time-trigger-controller.cjs";
+import runtimeExitLedger from "./bin/runtime-exit-ledger.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -38,6 +40,8 @@ import { createServer } from "node:http";
 import { pipeline as pipeline$1 } from "node:stream/promises";
 const { writeTelegramConsoleStatus } = telegramConsoleStatusPolicy;
 const { goalAutostartDecision, goalContinuationDecision } = cognitiveGoalAutostartPolicy;
+const { GoalTimeTriggerController } = cognitiveGoalTimeTriggerController;
+const { recordRuntimeExit } = runtimeExitLedger;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -507786,6 +507790,7 @@ var SessionEventHandler = class {
 			this.handleEvent(event, sendQueued);
 		});
 		this.syncMcpServerStatusSnapshot(session);
+		this.host.syncGoalTimeTrigger();
 	}
 	async syncMcpServerStatusSnapshot(session) {
 		const { host } = this;
@@ -508289,6 +508294,7 @@ var SessionEventHandler = class {
 	}
 	handleGoalUpdated(event) {
 		this.host.setAppState({ goal: event.snapshot });
+		this.host.syncGoalTimeTrigger();
 		if (event.snapshot === null && this.goalCompletionAwaitingClear) {
 			this.goalCompletionAwaitingClear = false;
 			this.queuedGoalPromotionPending = true;
@@ -516160,6 +516166,7 @@ var BlunTUI = class {
 	personalMemoryController;
 	customerMistakeController;
 	managedQuotaWarningController;
+	goalTimeTriggerController;
 	managedQuotaWarningPersistence = Promise.resolve();
 	footerMounted = false;
 	/** Timer that auto-clears the one-shot "moved to background" footer hint. */
@@ -516263,6 +516270,13 @@ var BlunTUI = class {
 			}
 		}));
 		this.streamingUI = new StreamingUIController(this);
+		this.goalTimeTriggerController = new GoalTimeTriggerController({
+			readState: () => this.readGoalTimeTriggerState(),
+			start: (trigger) => this.startAutonomousGoalContinuation(trigger),
+			onError: (error) => {
+				this.track("goal_time_trigger_failed", { error_type: error?.code ?? error?.name ?? "Error" });
+			}
+		});
 		this.authFlow = new AuthFlowController(this);
 		this.personalMemoryController = new PersonalMemoryController(this);
 		this.customerMistakeController = new CustomerMistakeHostController();
@@ -516685,6 +516699,41 @@ var BlunTUI = class {
 		});
 		return result.kind === "selected" ? result.path : void 0;
 	}
+	readGoalTimeTriggerState() {
+		return {
+			sessionId: this.session?.id ?? "",
+			goal: this.state.appState.goal,
+			permissionMode: this.state.appState.permissionMode,
+			idle: this.session !== void 0 && !this.isShuttingDown && !this.aborted && !this.queueCommandRunning && this.queueSteerInFlight === void 0 && !this.editorReplacementActive && !this.deferUserMessages && !this.streamingUI.hasActiveTurn() && this.state.appState.streamingPhase === "idle" && !this.state.appState.isCompacting && this.state.queuedMessages.length === 0
+		};
+	}
+	syncGoalTimeTrigger() {
+		if (this.isShuttingDown) return;
+		void this.goalTimeTriggerController?.sync();
+	}
+	async startAutonomousGoalContinuation(autostart) {
+		const session = this.session;
+		if (session === void 0) return false;
+		const sessionId = session.id;
+		const autostartPrompt = autostart.observation === void 0 ? GOAL_CONTINUATION_PROMPT : `${GOAL_CONTINUATION_PROMPT}\n\n${autostart.observation}`;
+		this.beginSessionRequest();
+		this.setAppState({
+			model: BLUN_KING_MODEL_ALIAS,
+			modelFallbackAllowed: false
+		});
+		try {
+			const result = await session.promptAccepted(autostartPrompt);
+			if (!result.accepted && this.session?.id === sessionId) {
+				this.setAppState({ streamingPhase: "idle" });
+				this.resetLivePane();
+				this.track("goal_autostart", { outcome: "not_accepted" });
+			}
+			return result.accepted === true;
+		} catch (error) {
+			if (this.session?.id === sessionId) this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
+			return false;
+		}
+	}
 	async promptStartupResumeGoalIfNeeded() {
 		const session = this.session;
 		const goal = this.state.appState.goal;
@@ -516696,25 +516745,12 @@ var BlunTUI = class {
 			now: new Date()
 		});
 		if (autostart.kind === "start") {
-			const autostartPrompt = autostart.observation === void 0 ? GOAL_CONTINUATION_PROMPT : `${GOAL_CONTINUATION_PROMPT}\n\n${autostart.observation}`;
 			this.startupGoalPromptedSessionId = sessionId;
-			this.beginSessionRequest();
-			this.setAppState({
-				model: BLUN_KING_MODEL_ALIAS,
-				modelFallbackAllowed: false
-			});
-			try {
-				const result = await session.promptAccepted(autostartPrompt);
-				if (!result.accepted && this.session?.id === sessionId) {
-					this.setAppState({ streamingPhase: "idle" });
-					this.resetLivePane();
-					this.track("goal_autostart", { outcome: "not_accepted" });
-				}
-			} catch (error) {
-				if (this.session?.id === sessionId) this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
-			}
+			if (autostart.trigger === "time") await this.goalTimeTriggerController.sync();
+			else await this.startAutonomousGoalContinuation(autostart);
 			return;
 		}
+		this.syncGoalTimeTrigger();
 		if (goal.status !== "paused" && goal.status !== "blocked") return;
 		this.startupGoalPromptedSessionId = sessionId;
 		const choice = await promptStartupResumeGoal(this, goal.objective, startupResumeGoalPromptCopy());
@@ -516728,6 +516764,7 @@ var BlunTUI = class {
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
+		this.goalTimeTriggerController.dispose();
 		await this.flushInputDraft();
 		this.unregisterSignalHandlers();
 		this.aborted = true;
@@ -516773,6 +516810,17 @@ var BlunTUI = class {
 		if (process.platform !== "win32") signals.push("SIGHUP");
 		for (const signal of signals) {
 			const handler = () => {
+				recordRuntimeExit({
+					homeDir: process.env["BLUN_HOME"],
+					source: "core",
+					kind: "signal",
+					exitCode: signal === "SIGTERM" ? 143 : 129,
+					signal,
+					phase: "runtime",
+					cliVersion: process.env["BLUN_PUBLIC_PACKAGE_VERSION"],
+					profile: process.env["BLUN_PROFILE"],
+					sessionId: this.getCurrentSessionId()
+				});
 				if (signal === "SIGHUP") {
 					this.emergencyTerminalExit();
 					return;
@@ -516789,7 +516837,20 @@ var BlunTUI = class {
 			});
 		}
 		const terminalErrorHandler = (error) => {
-			if (isDeadTerminalError(error)) this.emergencyTerminalExit();
+			if (isDeadTerminalError(error)) {
+				recordRuntimeExit({
+					homeDir: process.env["BLUN_HOME"],
+					source: "core",
+					kind: "dead-terminal",
+					exitCode: 129,
+					phase: "runtime",
+					cliVersion: process.env["BLUN_PUBLIC_PACKAGE_VERSION"],
+					profile: process.env["BLUN_PROFILE"],
+					sessionId: this.getCurrentSessionId(),
+					error
+				});
+				this.emergencyTerminalExit();
+			}
 		};
 		process.stdout.on("error", terminalErrorHandler);
 		process.stderr.on("error", terminalErrorHandler);
@@ -516807,6 +516868,7 @@ var BlunTUI = class {
 	}
 	emergencyTerminalExit(exitCode = 129) {
 		this.isShuttingDown = true;
+		this.goalTimeTriggerController.dispose();
 		this.unregisterSignalHandlers();
 		this.channelQueueDeadline?.dispose();
 		this.directFocusController?.dispose();
@@ -518154,6 +518216,7 @@ var BlunTUI = class {
 		if (!hasPatchChanges(this.state.appState, effectivePatch)) return;
 		const additionalDirsChanged = "additionalDirs" in effectivePatch && !sameStringArrays(this.state.appState.additionalDirs, effectivePatch.additionalDirs ?? []);
 		const busyChanged = "streamingPhase" in effectivePatch || "isCompacting" in effectivePatch;
+		const goalTimeTriggerChanged = busyChanged || "permissionMode" in effectivePatch;
 		Object.assign(this.state.appState, effectivePatch);
 		if ("planMode" in effectivePatch) this.updateEditorBorderHighlight();
 		this.state.loopIndicator.setState(this.state.appState);
@@ -518165,6 +518228,7 @@ var BlunTUI = class {
 			this.updateQueueDisplay();
 			this.sessionEventHandler.retryQueuedGoalPromotion();
 		}
+		if (goalTimeTriggerChanged) queueMicrotask(() => this.syncGoalTimeTrigger());
 		if (additionalDirsChanged) this.setupAutocomplete();
 		this.state.ui.requestRender();
 	}
@@ -518303,6 +518367,7 @@ var BlunTUI = class {
 	}
 	unloadCurrentSession(reason) {
 		const previous = this.session;
+		this.goalTimeTriggerController.reset();
 		this.managedQuotaWarningController.dismiss();
 		this.sessionEventUnsubscribe?.();
 		this.sessionEventUnsubscribe = void 0;
@@ -518355,6 +518420,7 @@ var BlunTUI = class {
 	}
 	resetSessionRuntime() {
 		this.aborted = false;
+		this.goalTimeTriggerController.reset();
 		this.managedQuotaWarningController.dismiss();
 		this.streamingUI.discardPending();
 		this.streamingUI.disposeActiveCompactionBlock();
@@ -519548,6 +519614,15 @@ async function runShell(opts, version) {
 	const trackLifecycle = (event, properties) => {
 		trackLifecycleForSession(tui.getCurrentSessionId(), event, properties);
 	};
+	const recordShellExit = (entry) => recordRuntimeExit({
+		homeDir: process.env["BLUN_HOME"] ?? telemetryBootstrap.homeDir,
+		source: "core",
+		phase: "runtime",
+		cliVersion: version,
+		profile: process.env["BLUN_PROFILE"],
+		sessionId: tui.getCurrentSessionId(),
+		...entry
+	});
 	let savedStty;
 	try {
 		const saved = execSync("stty -g", {
@@ -519581,12 +519656,22 @@ async function runShell(opts, version) {
 		process.exit(exitCode);
 	};
 	const onUncaughtException = (error) => {
+		recordShellExit({
+			kind: "uncaught-exception",
+			exitCode: 1,
+			error
+		});
 		try {
 			log.error("uncaughtException, restoring terminal and exiting", { error: String(error) });
 		} catch {}
 		emergencyExit(1);
 	};
 	const onUnhandledRejection = (reason) => {
+		recordShellExit({
+			kind: "unhandled-rejection",
+			exitCode: 1,
+			error: reason
+		});
 		try {
 			log.error("unhandledRejection, restoring terminal and exiting", { reason: String(reason) });
 		} catch {}
@@ -519601,6 +519686,10 @@ async function runShell(opts, version) {
 	tui.onExit = async (exitCode = 0) => {
 		const sessionId = tui.getCurrentSessionId();
 		const hasContent = tui.hasSessionContent();
+		recordShellExit({
+			kind: "normal-exit",
+			exitCode
+		});
 		setCrashPhase("shutdown");
 		trackLifecycle("exit", { duration_ms: Date.now() - startedAt });
 		await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
@@ -519631,6 +519720,12 @@ async function runShell(opts, version) {
 			...tui.getStartupPhaseMs()
 		});
 	} catch (error) {
+		recordShellExit({
+			kind: "startup-failure",
+			exitCode: 1,
+			phase: "startup",
+			error
+		});
 		removeCrashHandlers();
 		setCrashPhase("shutdown");
 		trackLifecycle("exit", { duration_ms: Date.now() - startedAt });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.421",
+  "version": "9.1.423",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {