blun-king-cli 9.1.307 → 9.1.309

package/bin/cognitive-attention-policy.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const SUBJECT_KINDS = new Set(['human', 'agent', 'task']);
+const SIGNAL_KINDS = new Set(['heartbeat', 'commitment', 'task_blocked']);
+const HEARTBEAT_STALE_MS = 5 * 60 * 1000;
+const BLOCKED_TASK_STALE_MS = 10 * 60 * 1000;
+const MAX_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
+
+function fail() {
+  const error = new Error('ATTENTION_INVALID_INPUT');
+  error.code = 'ATTENTION_INVALID_INPUT';
+  throw error;
+}
+
+function exactKeys(value, keys) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => keys.has(key));
+}
+
+function safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function instant(value) {
+  if (value === null || value === undefined) return null;
+  const milliseconds = Date.parse(String(value));
+  return Number.isFinite(milliseconds) ? milliseconds : null;
+}
+
+function normalizeQuietHours(value) {
+  if (!exactKeys(value, new Set(['startHour', 'endHour']))) fail();
+  const startHour = Number(value.startHour);
+  const endHour = Number(value.endHour);
+  if (!Number.isInteger(startHour) || startHour < 0 || startHour > 23
+      || !Number.isInteger(endHour) || endHour < 0 || endHour > 23
+      || startHour === endHour) fail();
+  return { startHour, endHour };
+}
+
+function isQuietTime(nowMs, offsetMinutes, quietHours) {
+  const localHour = new Date(nowMs + offsetMinutes * 60 * 1000).getUTCHours();
+  return quietHours.startHour < quietHours.endHour
+    ? localHour >= quietHours.startHour && localHour < quietHours.endHour
+    : localHour >= quietHours.startHour || localHour < quietHours.endHour;
+}
+
+function signalReason(subjectKind, signal, nowMs) {
+  if (!exactKeys(signal, new Set([
+    'kind', 'heartbeatAt', 'activeTask', 'expectedBy', 'blockedSince',
+    'evidenceId', 'evidenceScope', 'confidence',
+  ]))) fail();
+  if (!SIGNAL_KINDS.has(signal.kind)) fail();
+  const evidenceId = safeId(signal.evidenceId);
+  const evidenceScope = safeId(signal.evidenceScope);
+  const confidence = Number(signal.confidence);
+  if (!evidenceId || !evidenceScope || !Number.isFinite(confidence)
+      || confidence < 0 || confidence > 1) fail();
+  if (confidence < 0.5) return null;
+
+  if (signal.kind === 'heartbeat') {
+    if (!exactKeys(signal, new Set(['kind', 'heartbeatAt', 'activeTask', 'evidenceId', 'evidenceScope', 'confidence']))
+        || subjectKind !== 'agent' || signal.activeTask !== true) return null;
+    const heartbeatAt = instant(signal.heartbeatAt);
+    if (heartbeatAt === null || heartbeatAt > nowMs) fail();
+    return nowMs - heartbeatAt >= HEARTBEAT_STALE_MS
+      ? { reason: 'missing_heartbeat', anchor: new Date(heartbeatAt).toISOString(), evidenceId, evidenceScope, confidence }
+      : null;
+  }
+  if (signal.kind === 'commitment') {
+    if (!exactKeys(signal, new Set(['kind', 'expectedBy', 'evidenceId', 'evidenceScope', 'confidence']))) fail();
+    const expectedBy = instant(signal.expectedBy);
+    if (expectedBy === null) fail();
+    return nowMs > expectedBy
+      ? { reason: 'overdue_commitment', anchor: new Date(expectedBy).toISOString(), evidenceId, evidenceScope, confidence }
+      : null;
+  }
+  if (!exactKeys(signal, new Set(['kind', 'blockedSince', 'evidenceId', 'evidenceScope', 'confidence'])) || subjectKind !== 'task') return null;
+  const blockedSince = instant(signal.blockedSince);
+  if (blockedSince === null || blockedSince > nowMs) fail();
+  return nowMs - blockedSince >= BLOCKED_TASK_STALE_MS
+    ? { reason: 'blocked_task', anchor: new Date(blockedSince).toISOString(), evidenceId, evidenceScope, confidence }
+    : null;
+}
+
+function buildAttentionCandidate(input) {
+  const allowed = new Set([
+    'tenantId', 'subjectKind', 'subjectId', 'responsibleAgent', 'currentAgent', 'now', 'signal',
+    'absenceUntil', 'timezoneOffsetMinutes', 'quietHours', 'cooldownMs', 'allowedChannel',
+  ]);
+  if (!exactKeys(input, allowed)) fail();
+  const tenantId = safeId(input.tenantId);
+  const subjectKind = String(input.subjectKind ?? '');
+  const subjectId = safeId(input.subjectId);
+  const responsibleAgent = safeId(input.responsibleAgent);
+  const currentAgent = safeId(input.currentAgent);
+  const allowedChannel = safeId(input.allowedChannel);
+  const nowMs = instant(input.now);
+  const offsetMinutes = Number(input.timezoneOffsetMinutes);
+  const cooldownMs = Number(input.cooldownMs);
+  if (!tenantId || !SUBJECT_KINDS.has(subjectKind) || !subjectId || !responsibleAgent
+      || !currentAgent || !allowedChannel || nowMs === null
+      || !Number.isInteger(offsetMinutes) || offsetMinutes < -840 || offsetMinutes > 840
+      || !Number.isSafeInteger(cooldownMs) || cooldownMs < 1000 || cooldownMs > MAX_COOLDOWN_MS) fail();
+  if (currentAgent !== responsibleAgent) return null;
+
+  const absenceUntil = instant(input.absenceUntil);
+  if (input.absenceUntil !== null && absenceUntil === null) fail();
+  if (absenceUntil !== null && absenceUntil > nowMs) return null;
+  const quietHours = normalizeQuietHours(input.quietHours);
+  if (isQuietTime(nowMs, offsetMinutes, quietHours)) return null;
+
+  const reason = signalReason(subjectKind, input.signal, nowMs);
+  if (reason === null) return null;
+  const digest = crypto.createHash('sha256')
+    .update([tenantId, subjectKind, subjectId, reason.reason, reason.evidenceId].join('\0'))
+    .digest('hex')
+    .slice(0, 40);
+  return {
+    candidate_id: `attention-${digest}`,
+    subject_kind: subjectKind,
+    subject_id: subjectId,
+    reason: reason.reason,
+    evidence_id: reason.evidenceId,
+    evidence_scope: reason.evidenceScope,
+    evidence_at: reason.anchor,
+    confidence: reason.confidence,
+    responsible_agent: responsibleAgent,
+    allowed_channel: allowedChannel,
+    detected_at: new Date(nowMs).toISOString(),
+    cooldown_ms: cooldownMs,
+    requires_runtime_authorization: true,
+  };
+}
+
+module.exports = {
+  BLOCKED_TASK_STALE_MS,
+  HEARTBEAT_STALE_MS,
+  buildAttentionCandidate,
+};

package/bin/cognitive-state-store.cjs

@@ -147,6 +147,14 @@ function initialize(db) {
     );
     CREATE INDEX IF NOT EXISTS cognitive_observations_stream
       ON cognitive_observations (tenant_id, agent_id, occurred_at, observation_id);
+    CREATE TABLE IF NOT EXISTS cognitive_attention_claims (
+      tenant_id TEXT NOT NULL,
+      candidate_id TEXT NOT NULL,
+      claimed_by TEXT NOT NULL,
+      claimed_at TEXT NOT NULL,
+      next_allowed_at TEXT NOT NULL,
+      PRIMARY KEY (tenant_id, candidate_id)
+    );
   `);
 }
 
@@ -235,10 +243,57 @@ function openCognitiveStateStore({ home } = {}) {
     return { valid: true, events: rows.length, head_hash: previousHash };
   }
 
+  function claimAttention(input) {
+    const allowedInput = new Set(['tenantId', 'candidate', 'claimedBy', 'claimedAt']);
+    const allowedCandidate = new Set([
+      'candidate_id', 'subject_kind', 'subject_id', 'reason', 'responsible_agent',
+      'evidence_id', 'evidence_scope', 'evidence_at', 'confidence', 'allowed_channel',
+      'detected_at', 'cooldown_ms', 'requires_runtime_authorization',
+    ]);
+    if (!exactKeys(input, allowedInput) || !exactKeys(input.candidate, allowedCandidate)
+        || hasForbiddenKey(input)) fail('COGNITIVE_FORBIDDEN_FIELD');
+    const tenant = safeId(input.tenantId);
+    const candidateId = safeId(input.candidate.candidate_id);
+    const claimedBy = safeId(input.claimedBy);
+    const claimedAtMs = Date.parse(String(input.claimedAt ?? ''));
+    const cooldownMs = Number(input.candidate.cooldown_ms);
+    if (!tenant || !candidateId || !claimedBy || !Number.isFinite(claimedAtMs)
+        || !Number.isSafeInteger(cooldownMs) || cooldownMs < 1000
+        || input.candidate.requires_runtime_authorization !== true) fail('COGNITIVE_INVALID_EVENT');
+    const claimedAt = new Date(claimedAtMs).toISOString();
+    const nextAllowedAt = new Date(claimedAtMs + cooldownMs).toISOString();
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const existing = db.prepare(`SELECT claimed_by, next_allowed_at FROM cognitive_attention_claims
+        WHERE tenant_id = ? AND candidate_id = ?`).get(tenant, candidateId);
+      if (existing && Date.parse(existing.next_allowed_at) > claimedAtMs) {
+        db.exec('COMMIT');
+        return {
+          claimed: false,
+          claimed_by: existing.claimed_by,
+          next_allowed_at: existing.next_allowed_at,
+        };
+      }
+      db.prepare(`INSERT INTO cognitive_attention_claims
+        (tenant_id, candidate_id, claimed_by, claimed_at, next_allowed_at) VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(tenant_id, candidate_id) DO UPDATE SET
+          claimed_by = excluded.claimed_by,
+          claimed_at = excluded.claimed_at,
+          next_allowed_at = excluded.next_allowed_at`)
+        .run(tenant, candidateId, claimedBy, claimedAt, nextAllowedAt);
+      db.exec('COMMIT');
+      return { claimed: true, claimed_by: claimedBy, next_allowed_at: nextAllowedAt };
+    } catch (error) {
+      try { db.exec('ROLLBACK'); } catch {}
+      throw error;
+    }
+  }
+
   return {
     commit,
     read,
     verify,
+    claimAttention,
     close: () => {
       try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch {}
       db.close();

package/bin/launcher-runtime.js

@@ -68,6 +68,7 @@ const RAW_ARGS = process.argv.slice(2);
 const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.argv));
 const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
+const RUNNING_UPDATE_RESUME_SESSION_ENV = 'BLUN_RUNNING_UPDATE_RESUME_SESSION_ID';
 const RUNTIME_READY_TIMEOUT_MS = 60_000;
 const RUNNING_UPDATE_RECHECK_MS = 5 * 60_000;
 const RUNNING_UPDATE_RECHECK_JITTER_MS = 2 * 60_000;
@@ -312,6 +313,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   let pendingHandoff;
   let updateStarted = false;
   let runtimeReady = false;
+  let activeSession;
   let runtimeExitIntent = false;
   let supervisionCompleted = false;
   let runningUpdatePollTimer;
@@ -329,6 +331,23 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     (options.clearTimeoutImpl || clearTimeout)(runningUpdatePollTimer);
     runningUpdatePollTimer = undefined;
   };
+  const validSessionMessage = (message) => typeof message?.sessionId === 'string'
+    && message.sessionId.length > 0
+    && message.sessionId.length <= 256
+    && !/[\u0000-\u001f\u007f]/u.test(message.sessionId)
+    && resolveHandoffCwd(message.cwd, '') !== '';
+  const stagedRuntimeOptions = () => ({
+    mode: runningUpdateMode,
+    ...(runningUpdateMode === RUNNING_UPDATE_MODES.RESUME && activeSession !== undefined
+      ? { cwd: activeSession.cwd, sessionId: activeSession.sessionId }
+      : {}),
+  });
+  const persistPreparedRuntime = () => {
+    if (preparedTarget === undefined) return;
+    const sharedHome = env.BLUN_SHARED_HOME;
+    if (typeof sharedHome !== 'string' || sharedHome.length === 0) return;
+    (options.stageRuntime || stageRuntime)(sharedHome, preparedTarget, stagedRuntimeOptions());
+  };
   const scheduleNextPreparation = (child) => {
     clearRunningUpdatePoll();
     if (supervisionCompleted || pendingHandoff !== undefined || updateStarted) return;
@@ -367,7 +386,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         return;
       }
       preparedTarget = target;
-      (options.stageRuntime || stageRuntime)(sharedHome, target, { mode: runningUpdateMode });
+      persistPreparedRuntime();
       const runningVersion = readPackageVersionAt(packageRoot);
       (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, previousTarget === undefined ? {
         event: 'prepared-for-next-start',
@@ -396,13 +415,20 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       && preparedTarget !== undefined
       && message.version === preparedTarget.version
       && message.mode === runningUpdateMode
-      && typeof message.sessionId === 'string'
-      && message.sessionId.length > 0
-      && message.sessionId.length <= 256
-      && !/[\u0000-\u001f\u007f]/u.test(message.sessionId)
-      && resolveHandoffCwd(message.cwd, '') !== '') {
-      pendingHandoff = Object.freeze({
+      && validSessionMessage(message)) {
+      activeSession = Object.freeze({
         cwd: resolveHandoffCwd(message.cwd, cwd),
+        sessionId: message.sessionId,
+      });
+      try {
+        persistPreparedRuntime();
+      } catch (error) {
+        options.onRunningUpdateError?.(error);
+        scheduleNextPreparation(child);
+        return;
+      }
+      pendingHandoff = Object.freeze({
+        cwd: activeSession.cwd,
         mode: message.mode,
         sessionId: message.sessionId,
         target: preparedTarget,
@@ -423,6 +449,17 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       }
     }
     if (message?.type === RUNTIME_READY_MESSAGE) {
+      if (validSessionMessage(message)) {
+        activeSession = Object.freeze({
+          cwd: resolveHandoffCwd(message.cwd, cwd),
+          sessionId: message.sessionId,
+        });
+        try {
+          persistPreparedRuntime();
+        } catch (error) {
+          options.onRunningUpdateError?.(error);
+        }
+      }
       runtimeReady = true;
       refreshRunningUpdateMode();
       if (automaticMode()) startPreparation(child);
@@ -482,7 +519,11 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     const handoffArgs = handoffArgsForMode(args, pendingHandoff.mode, pendingHandoff.sessionId);
     const handoffCwd = pendingHandoff.cwd;
     const previousActive = (options.readActiveRuntime || readActiveRuntime)(sharedHome);
-    const nextCore = spawnCore(handoffArgs, env, handoffCwd, { packageRoot: target.packageRoot });
+    const resumeEnv = {
+      ...env,
+      [RUNNING_UPDATE_RESUME_SESSION_ENV]: pendingHandoff.sessionId,
+    };
+    const nextCore = spawnCore(handoffArgs, resumeEnv, handoffCwd, { packageRoot: target.packageRoot });
     const nextLoaded = await nextCore.loaded;
     const nextReady = nextLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
       nextCore,
@@ -498,7 +539,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         toVersion: target.version,
         mode: pendingHandoff.mode,
       }, { now: options.nowImpl });
-      return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+      return superviseProtectedCore(handoffArgs, resumeEnv, handoffCwd, async () => {}, {
         ...options,
         existingCore: nextCore,
         packageRoot: target.packageRoot,
@@ -519,14 +560,14 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       fromVersion: readPackageVersionAt(packageRoot),
       toVersion: target.version,
     }, { now: options.nowImpl });
-    const fallback = spawnCore(handoffArgs, env, handoffCwd, { packageRoot });
+    const fallback = spawnCore(handoffArgs, resumeEnv, handoffCwd, { packageRoot });
     const fallbackLoaded = await fallback.loaded;
     const fallbackReady = fallbackLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
       fallback,
       options.readyTimeoutMs,
     );
     if (!fallbackReady) return 1;
-    return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+    return superviseProtectedCore(handoffArgs, resumeEnv, handoffCwd, async () => {}, {
       ...options,
       existingCore: fallback,
       packageRoot,
@@ -641,14 +682,20 @@ function spawnManagedLauncher(binary, cwd) {
   });
 }
 
-function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS) {
+function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS, options = {}) {
   const entryName = path.basename(process.argv[1] || 'king.js').toLowerCase() === 'blun.js'
     ? 'blun.js'
     : 'king.js';
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [path.join(packageRoot, 'bin', entryName), ...args], {
       cwd,
-      env: { ...process.env, BLUN_ACTIVE_RUNTIME_ROOT: packageRoot },
+      env: {
+        ...process.env,
+        BLUN_ACTIVE_RUNTIME_ROOT: packageRoot,
+        ...(typeof options.resumeSessionId === 'string' && options.resumeSessionId.length > 0
+          ? { [RUNNING_UPDATE_RESUME_SESSION_ENV]: options.resumeSessionId }
+          : {}),
+      },
       stdio: 'inherit',
       windowsHide: true,
     });
@@ -873,6 +920,9 @@ async function runLauncher(options = {}) {
         deferredPendingRuntime.packageRoot,
         deferredPendingRuntime.cwd || callerCwd,
         pendingArgs,
+        deferredPendingRuntime.mode === RUNNING_UPDATE_MODES.RESUME
+          ? { resumeSessionId: deferredPendingRuntime.sessionId }
+          : {},
       );
       return;
     }

package/blun.mjs

@@ -515728,20 +515728,28 @@ const {
 	readRunningUpdateMode,
 	writeRunningUpdateMode
 } = __require("./bin/running-update-preference.cjs");
-function notifyRunningRuntimeReady(tui) {
-	if (typeof process.env["BLUN_SHARED_HOME"] === "string" && process.env["BLUN_SHARED_HOME"].length > 0) void pruneRunningUpdateReleases(process.env["BLUN_SHARED_HOME"], {
-		activePackageRoot: __dirname
-	}).catch(() => {});
+const RUNNING_UPDATE_RESUME_SESSION_ENV = "BLUN_RUNNING_UPDATE_RESUME_SESSION_ID";
+function shouldContinueActiveGoalAfterRunningUpdate(expectedSessionId, currentSessionId, goalStatus) {
+	return typeof expectedSessionId === "string" && expectedSessionId.length > 0 && currentSessionId === expectedSessionId && goalStatus === "active";
+}
+function sendRunningRuntimeSession(tui) {
 	if (!process.connected) return;
 	const sessionId = tui.getCurrentSessionId();
 	if (sessionId.length === 0) return;
 	try {
 		process.send({
 			type: RUNTIME_READY_MESSAGE,
-			sessionId
+			sessionId,
+			cwd: tui.state.appState.workDir
 		});
 	} catch {}
 }
+function notifyRunningRuntimeReady(tui) {
+	if (typeof process.env["BLUN_SHARED_HOME"] === "string" && process.env["BLUN_SHARED_HOME"].length > 0) void pruneRunningUpdateReleases(process.env["BLUN_SHARED_HOME"], {
+		activePackageRoot: __dirname
+	}).catch(() => {});
+	sendRunningRuntimeSession(tui);
+}
 function requestRunningUpdateAtSafeBoundary(tui) {
 	if (tui.runningUpdateHandoffStarted || tui.isShuttingDown || !process.connected) return false;
 	const version = tui.runningUpdatePreparedVersion;
@@ -516268,7 +516276,8 @@ var BlunTUI = class {
 		if (this.session !== void 0) {
 			this.sessionEventHandler.startSubscription();
 			if (shouldReplayHistory) {
-				await this.promptStartupResumeGoalIfNeeded();
+				const continuedAfterUpdate = this.continueActiveGoalAfterRunningUpdateIfNeeded();
+				if (!continuedAfterUpdate) await this.promptStartupResumeGoalIfNeeded();
 				if (this.aborted) return;
 			}
 			this.showSessionWarnings(this.session);
@@ -516418,6 +516427,13 @@ var BlunTUI = class {
 		}
 		if (choice === "resume") await handleGoalCommand(this, "resume");
 	}
+	continueActiveGoalAfterRunningUpdateIfNeeded() {
+		const expectedSessionId = process.env[RUNNING_UPDATE_RESUME_SESSION_ENV];
+		delete process.env[RUNNING_UPDATE_RESUME_SESSION_ENV];
+		if (!shouldContinueActiveGoalAfterRunningUpdate(expectedSessionId, this.session?.id, this.state.appState.goal?.status)) return false;
+		this.sendNormalUserInput(RESUME_GOAL_INPUT);
+		return true;
+	}
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
@@ -517913,6 +517929,7 @@ var BlunTUI = class {
 		if (resumeState?.warning !== void 0) this.showStatus(uiText("blunTui.warning", { warning: resumeState.warning }), "warning");
 		this.showStatus(statusMessage);
 		this.showSessionWarnings(session);
+		sendRunningRuntimeSession(this);
 	}
 	async reloadCurrentSessionView(session, statusMessage) {
 		await this.personalMemoryController.clear(session);
@@ -517976,6 +517993,7 @@ var BlunTUI = class {
 		this.showStatus(uiText("blunTui.session.started", { sessionId: session.id }));
 		this.showSessionWarnings(session);
 		this.showConfigWarningsIfAny();
+		sendRunningRuntimeSession(this);
 	}
 	/** Surface config.toml load warnings (degraded or kept-previous config) in the status bar. */
 	async showConfigWarningsIfAny() {

package/package.json

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