blun-king-cli 9.1.420 → 9.1.422

package/LIESMICH.txt

@@ -97,6 +97,17 @@ erzeugen dadurch keine leeren Folgezüge. Beim nächsten Ereignis wird der
 gespeicherte Auslöser erneut eingeordnet. Sofortige Ziele und ältere Ziele ohne
 Checkpoint laufen unverändert weiter.
 
+Ab BLUN King 9.1.421 muss ein wartendes Ziel mit Zeit-Trigger einen genauen
+`dueAt`-Zeitpunkt speichern. Der Zeitpunkt wird auf UTC normalisiert. Bei einem
+natürlichen Sitzungsstart im Auto- oder God-Modus wartet das Ziel vor diesem
+Zeitpunkt weiter und startet, sobald der Zeitpunkt erreicht oder überschritten
+ist. Der erste Fortsetzungszug erhält die gespeicherte Fälligkeit als
+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

@@ -116,6 +116,17 @@ erzeugen dadurch keine leeren Folgezüge. Beim nächsten Ereignis wird der
 gespeicherte Auslöser erneut eingeordnet. Sofortige Ziele und ältere Ziele ohne
 Checkpoint laufen unverändert weiter.
 
+Ab BLUN King 9.1.421 muss ein wartendes Ziel mit Zeit-Trigger einen genauen
+`dueAt`-Zeitpunkt speichern. Der Zeitpunkt wird auf UTC normalisiert. Bei einem
+natürlichen Sitzungsstart im Auto- oder God-Modus wartet das Ziel vor diesem
+Zeitpunkt weiter und startet, sobald der Zeitpunkt erreicht oder überschritten
+ist. Der erste Fortsetzungszug erhält die gespeicherte Fälligkeit als
+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-action-checkpoint.cjs

@@ -20,11 +20,12 @@ const PROBLEM_FRAME_KEYS = new Set([
   'successCriterion', 'missingKnowledge', 'candidateActions', 'selectedAction',
   'selectionReason', 'supportChoice', 'risk', 'reversibility',
 ]);
-const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition']);
+const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition', 'dueAt']);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
 const EVIDENCE_DIGEST_RE = /^[a-f0-9]{16}$/u;
+const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/u;
 
 function bounded(value, field, max = 512) {
   const text = String(value ?? '')
@@ -35,9 +36,12 @@ function bounded(value, field, max = 512) {
   return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
 }
 
-function normalizedTimestamp(value) {
+function normalizedTimestamp(value, field = 'updatedAt', requireIsoString = false) {
+  if (requireIsoString && (typeof value !== 'string' || !ISO_TIMESTAMP_RE.test(value))) {
+    throw new TypeError(`${field} must be an ISO timestamp`);
+  }
   const date = new Date(value);
-  if (!Number.isFinite(date.getTime())) throw new TypeError('updatedAt must be an ISO timestamp');
+  if (!Number.isFinite(date.getTime())) throw new TypeError(`${field} must be an ISO timestamp`);
   return date.toISOString();
 }
 
@@ -96,10 +100,18 @@ function normalizeNextTrigger(input, phase) {
   if (phase !== 'wait' && kind !== 'immediate') {
     throw new TypeError('non-wait phase requires an immediate nextTrigger');
   }
-  return Object.freeze({
+  if (kind === 'time' && input.dueAt === undefined) {
+    throw new TypeError('time nextTrigger requires dueAt');
+  }
+  if (kind !== 'time' && input.dueAt !== undefined) {
+    throw new TypeError('dueAt is only valid for a time nextTrigger');
+  }
+  const trigger = {
     kind,
     condition: bounded(input.condition, 'nextTrigger condition'),
-  });
+  };
+  if (kind === 'time') trigger.dueAt = normalizedTimestamp(input.dueAt, 'nextTrigger dueAt', true);
+  return Object.freeze(trigger);
 }
 
 function normalizedEvidenceBasis(value, allowLegacy = false) {
@@ -287,6 +299,7 @@ function projectActionCheckpoint(checkpoint) {
   lines.push(`Expected evidence: ${value.expectedEvidence}`);
   if (value.nextTrigger !== undefined) {
     lines.push(`Next trigger: ${value.nextTrigger.kind.replaceAll('_', ' ')} - ${value.nextTrigger.condition}`);
+    if (value.nextTrigger.dueAt !== undefined) lines.push(`Due at: ${value.nextTrigger.dueAt}`);
   }
   if (value.problemFrame !== undefined) {
     const frame = value.problemFrame;

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

@@ -2,23 +2,64 @@
 
 const AUTONOMOUS_PERMISSION_MODES = new Set(['auto', 'yolo']);
 const ACTIVE_PHASES = new Set(['orient', 'plan', 'act', 'verify', 'learn']);
+const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/u;
 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 goalAutostartDecision({ goal, permissionMode } = {}) {
+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;
   if (goal.status !== 'active' || !AUTONOMOUS_PERMISSION_MODES.has(permissionMode)) return WAIT;
 
   const checkpoint = goal.actionCheckpoint;
   if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) return WAIT;
-  if (!ACTIVE_PHASES.has(checkpoint.phase)) return WAIT;
   const trigger = checkpoint.nextTrigger;
   if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) return WAIT;
-  if (trigger.kind !== 'immediate') return WAIT;
   if (typeof trigger.condition !== 'string' || trigger.condition.trim().length === 0) return WAIT;
-  return START;
+  if (ACTIVE_PHASES.has(checkpoint.phase) && trigger.kind === 'immediate') return START;
+  const timed = goalTimeTriggerDecision({ goal, permissionMode, now });
+  if (timed.kind !== 'due') return WAIT;
+  return Object.freeze({
+    kind: 'start',
+    trigger: 'time',
+    dueAt: timed.dueAt,
+    observation: timed.observation,
+  });
 }
 
 function goalContinuationDecision({ goal } = {}) {
@@ -28,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/blun.mjs

@@ -7,6 +7,7 @@ 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 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 +39,7 @@ import { createServer } from "node:http";
 import { pipeline as pipeline$1 } from "node:stream/promises";
 const { writeTelegramConsoleStatus } = telegramConsoleStatusPolicy;
 const { goalAutostartDecision, goalContinuationDecision } = cognitiveGoalAutostartPolicy;
+const { GoalTimeTriggerController } = cognitiveGoalTimeTriggerController;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -245769,7 +245771,8 @@ var init_events$1 = __esmMin((() => {
 			expectedEvidence: string(),
 			nextTrigger: object({
 				kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
-				condition: string()
+				condition: string(),
+				dueAt: string().optional()
 			}).strict().optional(),
 			problemFrame: object({
 				successCriterion: string(),
@@ -260288,8 +260291,26 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 		expectedEvidence: string().min(1).max(512),
 		nextTrigger: object({
 			kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
-			condition: string().min(1).max(512)
-		}).strict(),
+			condition: string().min(1).max(512),
+			dueAt: string().min(1).max(64).optional()
+		}).strict().superRefine((value, ctx) => {
+			if (value.kind === "time") {
+				if (value.dueAt === void 0) ctx.addIssue({
+					code: "custom",
+					path: ["dueAt"],
+					message: "time nextTrigger requires dueAt"
+				});
+				else if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/u.test(value.dueAt) || !Number.isFinite(new Date(value.dueAt).getTime())) ctx.addIssue({
+					code: "custom",
+					path: ["dueAt"],
+					message: "dueAt must be an ISO timestamp"
+				});
+			} else if (value.dueAt !== void 0) ctx.addIssue({
+				code: "custom",
+				path: ["dueAt"],
+				message: "dueAt is only valid for a time nextTrigger"
+			});
+		}),
 		problemFrame: requireProblemFrame ? problemFrameSchema : problemFrameSchema.optional()
 	}).strict();
 }
@@ -262782,7 +262803,7 @@ var init_outcome_prompts = __esmMin((() => {}));
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.md?raw
 var update_goal_default;
 var init_update_goal$1 = __esmMin((() => {
-	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, exact `nextTrigger`, and an explicit evidence basis. Persist the exact `nextTrigger` that releases `nextAction`: use `immediate` outside the `wait` phase; while waiting, name the external event, time, dependency, or user decision instead of pretending work can continue. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
+	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, exact `nextTrigger`, and an explicit evidence basis. Persist the exact `nextTrigger` that releases `nextAction`: use `immediate` outside the `wait` phase; while waiting, name the external event, time, dependency, or user decision instead of pretending work can continue. A `time` trigger must include the exact ISO timestamp in `dueAt`; no other trigger kind may include `dueAt`. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
 	update_goal_default += "\nFor a non-trivial or unfamiliar problem, preserve `problemFrame` with the success criterion, missing knowledge, bounded candidate actions, selected action and reason, support choice, risk, and reversibility. The selected action must match one candidate. Problem framing is descriptive state and never grants permission.\n";
 }));
 //#endregion
@@ -507767,6 +507788,7 @@ var SessionEventHandler = class {
 			this.handleEvent(event, sendQueued);
 		});
 		this.syncMcpServerStatusSnapshot(session);
+		this.host.syncGoalTimeTrigger();
 	}
 	async syncMcpServerStatusSnapshot(session) {
 		const { host } = this;
@@ -508270,6 +508292,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;
@@ -516141,6 +516164,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. */
@@ -516244,6 +516268,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();
@@ -516666,6 +516697,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;
@@ -516673,27 +516739,16 @@ var BlunTUI = class {
 		const sessionId = session.id;
 		const autostart = goalAutostartDecision({
 			goal,
-			permissionMode: this.state.appState.permissionMode
+			permissionMode: this.state.appState.permissionMode,
+			now: new Date()
 		});
 		if (autostart.kind === "start") {
 			this.startupGoalPromptedSessionId = sessionId;
-			this.beginSessionRequest();
-			this.setAppState({
-				model: BLUN_KING_MODEL_ALIAS,
-				modelFallbackAllowed: false
-			});
-			try {
-				const result = await session.promptAccepted(GOAL_CONTINUATION_PROMPT);
-				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());
@@ -516707,6 +516762,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;
@@ -516786,6 +516842,7 @@ var BlunTUI = class {
 	}
 	emergencyTerminalExit(exitCode = 129) {
 		this.isShuttingDown = true;
+		this.goalTimeTriggerController.dispose();
 		this.unregisterSignalHandlers();
 		this.channelQueueDeadline?.dispose();
 		this.directFocusController?.dispose();
@@ -518133,6 +518190,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);
@@ -518144,6 +518202,7 @@ var BlunTUI = class {
 			this.updateQueueDisplay();
 			this.sessionEventHandler.retryQueuedGoalPromotion();
 		}
+		if (goalTimeTriggerChanged) queueMicrotask(() => this.syncGoalTimeTrigger());
 		if (additionalDirsChanged) this.setupAutocomplete();
 		this.state.ui.requestRender();
 	}
@@ -518282,6 +518341,7 @@ var BlunTUI = class {
 	}
 	unloadCurrentSession(reason) {
 		const previous = this.session;
+		this.goalTimeTriggerController.reset();
 		this.managedQuotaWarningController.dismiss();
 		this.sessionEventUnsubscribe?.();
 		this.sessionEventUnsubscribe = void 0;
@@ -518334,6 +518394,7 @@ var BlunTUI = class {
 	}
 	resetSessionRuntime() {
 		this.aborted = false;
+		this.goalTimeTriggerController.reset();
 		this.managedQuotaWarningController.dismiss();
 		this.streamingUI.discardPending();
 		this.streamingUI.disposeActiveCompactionBlock();

package/package.json

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