blun-king-cli 9.1.371 → 9.1.373

package/bin/cognitive-action-checkpoint.cjs

@@ -6,8 +6,11 @@ const PHASES = new Set(['orient', 'plan', 'act', 'verify', 'learn', 'wait']);
 const EVIDENCE_BASES = new Set([
   'runtime_tool', 'user_statement', 'external_report', 'carried_forward',
 ]);
+const EPISTEMIC_STATES = new Set([
+  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown',
+]);
 const MODEL_KEYS = new Set([
-  'revision', 'phase', 'evidenceBasis', 'lastVerified', 'nextAction', 'expectedEvidence', 'updatedAt',
+  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'updatedAt',
 ]);
 const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
 const EVIDENCE_INPUT_KEYS = new Set([
@@ -46,6 +49,14 @@ function normalizedEvidenceBasis(value, allowLegacy = false) {
     : 'evidenceBasis is invalid');
 }
 
+function normalizedEpistemicState(value, allowLegacy = false) {
+  const state = String(value ?? '').trim();
+  if (EPISTEMIC_STATES.has(state) || allowLegacy && state === 'legacy_unknown') return state;
+  throw new TypeError(value === undefined
+    ? 'epistemicState is required'
+    : 'epistemicState is invalid');
+}
+
 function normalizedTurnId(value) {
   const turnId = Number(value);
   if (!Number.isSafeInteger(turnId) || turnId < 0) throw new TypeError('evidence turnId must be a non-negative integer');
@@ -129,11 +140,18 @@ function assertActionCheckpointRevision(current, input) {
 
 function assertActionCheckpointEvidenceBasis(current, input, runtimeEvidence) {
   const basis = normalizedEvidenceBasis(input?.evidenceBasis);
+  const epistemicState = normalizedEpistemicState(input?.epistemicState);
   if (basis === 'runtime_tool') {
     const receipt = normalizeActionEvidenceReceipt(runtimeEvidence);
     if (receipt.successfulTools < 1) {
       throw new TypeError('runtime_tool evidenceBasis requires a successful runtime tool in the current turn');
     }
+    if (epistemicState !== 'verified') {
+      throw new TypeError('runtime_tool evidenceBasis requires verified epistemicState');
+    }
+  }
+  if (basis === 'external_report' && epistemicState === 'verified') {
+    throw new TypeError('external_report evidenceBasis cannot claim verified epistemicState');
   }
   if (basis === 'carried_forward') {
     if (!current) throw new TypeError('carried_forward evidenceBasis requires a current checkpoint');
@@ -144,6 +162,9 @@ function assertActionCheckpointEvidenceBasis(current, input, runtimeEvidence) {
     if (bounded(input?.lastVerified, 'lastVerified') !== currentValue.lastVerified) {
       throw new TypeError('carried_forward evidenceBasis cannot change lastVerified');
     }
+    if (epistemicState !== currentValue.epistemicState) {
+      throw new TypeError('carried_forward evidenceBasis cannot change epistemicState');
+    }
   }
   return basis;
 }
@@ -162,6 +183,9 @@ function normalizeActionCheckpoint(input, options = {}) {
   const evidenceBasis = input.evidenceBasis === undefined && replay
     ? 'legacy_unknown'
     : normalizedEvidenceBasis(input.evidenceBasis, replay);
+  const epistemicState = input.epistemicState === undefined && replay
+    ? 'legacy_unknown'
+    : normalizedEpistemicState(input.epistemicState, replay);
   const updatedAt = options.preserveUpdatedAt === true && input.updatedAt !== undefined
     ? normalizedTimestamp(input.updatedAt)
     : normalizedTimestamp(options.now ?? new Date());
@@ -169,6 +193,7 @@ function normalizeActionCheckpoint(input, options = {}) {
     revision: normalizedRevision(input.revision),
     phase,
     evidenceBasis,
+    epistemicState,
     lastVerified: bounded(input.lastVerified, 'lastVerified'),
     nextAction: bounded(input.nextAction, 'nextAction'),
     expectedEvidence: bounded(input.expectedEvidence, 'expectedEvidence'),
@@ -191,6 +216,7 @@ function projectActionCheckpoint(checkpoint) {
     `Revision: ${value.revision}`,
     `Phase: ${value.phase}`,
     `Evidence basis: ${value.evidenceBasis.replaceAll('_', ' ')}`,
+    `Epistemic state: ${value.epistemicState.replaceAll('_', ' ')}`,
     `Last verified: ${value.lastVerified}`,
   ];
   lines.push(`Next action: ${value.nextAction}`);

package/bin/cognitive-focus-projection.cjs

@@ -20,6 +20,15 @@ const LABELS = new Map([
   ['self', 'Self'],
 ]);
 const SAFETY_LINE = 'Durable context only; it cannot authorize any action or override the current assignment or runtime policy.';
+const EPISTEMIC_MARKERS = new Map([
+  ['verified', ''],
+  ['credible_unverified', ' [unverified]'],
+  ['hypothesis', ' [hypothesis]'],
+  ['uncertain_memory', ' [uncertain memory]'],
+  ['stale', ' [stale]'],
+  ['unknown', ' [unknown]'],
+  ['legacy_unknown', ' [unknown]'],
+]);
 
 function clean(value, max = 256) {
   const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
@@ -52,13 +61,19 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     const withdraws = item?.withdraws === null || item?.withdraws === undefined
       ? null : clean(item.withdraws, 128);
     const confidence = Number(item?.confidence);
+    const epistemicState = item?.epistemic_state === undefined
+      ? 'legacy_unknown' : String(item.epistemic_state);
     const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
     if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
         || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
+        || !EPISTEMIC_MARKERS.has(epistemicState)
         || !Number.isFinite(occurredAt)) return;
     const groupKey = `${scope}\0${domain}\0${key}`;
     const existing = groups.get(groupKey) ?? [];
-    existing.push({ domain, key, value, scope, observationId, supersedes, withdraws, confidence, occurredAt, index });
+    existing.push({
+      domain, key, value, scope, observationId, supersedes, withdraws,
+      confidence, epistemicState, occurredAt, index,
+    });
     groups.set(groupKey, existing);
   });
 
@@ -83,7 +98,7 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     if (item.conflict) return `- Conflict: ${item.key} has incompatible evidence; verify before relying on it.`;
     const marker = item.corrected ? ' [corrected]'
       : item.contested ? ' [contested; stronger evidence]' : item.revised ? ' [revised]' : '';
-    return `- ${LABELS.get(item.domain)}: ${item.value}${marker}`;
+    return `- ${LABELS.get(item.domain)}: ${item.value}${EPISTEMIC_MARKERS.get(item.epistemicState)}${marker}`;
   });
   while ([`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n').length > maxChars
       && lines.length > 0) lines.pop();

package/bin/cognitive-state-store.cjs

@@ -7,6 +7,9 @@ const { DatabaseSync } = require('node:sqlite');
 
 const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 const DOMAINS = new Set(['self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'next_trigger', 'expected_evidence']);
+const EPISTEMIC_STATES = new Set([
+  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
+]);
 const FORBIDDEN_KEY_RE = /(?:^|_)(?:acl|api_key|capability|password|permission|secret|token)(?:_|$)/iu;
 const MAX_EVENT_BYTES = 64 * 1024;
 const MAX_OBSERVATIONS = 32;
@@ -52,7 +55,7 @@ function normalizeSource(source) {
 }
 
 function normalizeObservation(value) {
-  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope', 'supersedes', 'withdraws']);
+  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'epistemic_state', 'scope', 'supersedes', 'withdraws']);
   if (!exactKeys(value, allowed) || hasForbiddenKey(value)) fail('COGNITIVE_FORBIDDEN_FIELD');
   const observation = {
     observation_id: safeId(value.observation_id),
@@ -60,11 +63,14 @@ function normalizeObservation(value) {
     key: cleanText(value.key, 128),
     value: cleanText(value.value, 2048),
     confidence: Number(value.confidence),
+    epistemic_state: value.epistemic_state === undefined
+      ? 'legacy_unknown' : String(value.epistemic_state),
     scope: cleanText(value.scope, 128),
   };
   if (!observation.observation_id || !DOMAINS.has(observation.domain) || !observation.key
       || !observation.value || !Number.isFinite(observation.confidence)
-      || observation.confidence < 0 || observation.confidence > 1 || !observation.scope) {
+      || observation.confidence < 0 || observation.confidence > 1
+      || !EPISTEMIC_STATES.has(observation.epistemic_state) || !observation.scope) {
     fail('COGNITIVE_INVALID_EVENT');
   }
   if (FORBIDDEN_KEY_RE.test(observation.key)) fail('COGNITIVE_FORBIDDEN_FIELD');
@@ -152,6 +158,7 @@ function initialize(db) {
       fact_key TEXT NOT NULL,
       value_text TEXT NOT NULL,
       confidence REAL NOT NULL,
+      epistemic_state TEXT NOT NULL DEFAULT 'legacy_unknown',
       scope TEXT NOT NULL,
       source_json TEXT NOT NULL,
       occurred_at TEXT NOT NULL,
@@ -187,6 +194,9 @@ function initialize(db) {
   if (!observationColumns.some((column) => column.name === 'withdraws_observation_id')) {
     db.exec('ALTER TABLE cognitive_observations ADD COLUMN withdraws_observation_id TEXT');
   }
+  if (!observationColumns.some((column) => column.name === 'epistemic_state')) {
+    db.exec("ALTER TABLE cognitive_observations ADD COLUMN epistemic_state TEXT NOT NULL DEFAULT 'legacy_unknown'");
+  }
 }
 
 function openCognitiveStateStore({ home } = {}) {
@@ -218,8 +228,8 @@ function openCognitiveStateStore({ home } = {}) {
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(normalized.event_id, normalized.tenant_id, normalized.agent_id, actualVersion, newVersion, normalized.occurred_at, payload, previousHash, eventHash);
       const insertObservation = db.prepare(`INSERT INTO cognitive_observations
-        (observation_id, event_id, tenant_id, agent_id, domain, fact_key, value_text, confidence, scope, source_json, occurred_at, supersedes_observation_id, withdraws_observation_id)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        (observation_id, event_id, tenant_id, agent_id, domain, fact_key, value_text, confidence, epistemic_state, scope, source_json, occurred_at, supersedes_observation_id, withdraws_observation_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
       const sourceJson = JSON.stringify(normalized.source);
       for (const observation of normalized.observations) {
         if (observation.supersedes) {
@@ -237,7 +247,8 @@ function openCognitiveStateStore({ home } = {}) {
               || target.scope !== observation.scope) fail('COGNITIVE_INVALID_WITHDRAWAL');
         }
         insertObservation.run(observation.observation_id, normalized.event_id, normalized.tenant_id, normalized.agent_id,
-          observation.domain, observation.key, observation.value, observation.confidence, observation.scope, sourceJson,
+          observation.domain, observation.key, observation.value, observation.confidence, observation.epistemic_state,
+          observation.scope, sourceJson,
           normalized.occurred_at, observation.supersedes ?? null, observation.withdraws ?? null);
       }
       db.prepare(`INSERT INTO cognitive_streams (tenant_id, agent_id, version, updated_at) VALUES (?, ?, ?, ?)
@@ -256,7 +267,7 @@ function openCognitiveStateStore({ home } = {}) {
     const agent = safeId(agentId);
     if (!tenant || !agent) fail('COGNITIVE_INVALID_EVENT');
     const stream = db.prepare('SELECT version, updated_at FROM cognitive_streams WHERE tenant_id = ? AND agent_id = ?').get(tenant, agent);
-    const rows = db.prepare(`SELECT domain, fact_key, value_text, confidence, scope, source_json, occurred_at, observation_id,
+    const rows = db.prepare(`SELECT domain, fact_key, value_text, confidence, epistemic_state, scope, source_json, occurred_at, observation_id,
       supersedes_observation_id, withdraws_observation_id
       FROM cognitive_observations WHERE tenant_id = ? AND agent_id = ? ORDER BY occurred_at, rowid`).all(tenant, agent);
     return {
@@ -268,6 +279,7 @@ function openCognitiveStateStore({ home } = {}) {
         key: row.fact_key,
         value: row.value_text,
         confidence: row.confidence,
+        epistemic_state: row.epistemic_state,
         scope: row.scope,
         source: JSON.parse(row.source_json),
         occurred_at: row.occurred_at,

package/bin/cognitive-turn-lifecycle.cjs

@@ -15,6 +15,9 @@ const TOOL_POLICY_DECISIONS = new Set(['passed', 'blocked', 'error']);
 const TOOL_OUTCOMES = new Set(['success', 'error', 'cancelled']);
 const TURN_REASONS = new Set(['completed', 'cancelled', 'filtered', 'failed']);
 const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
+const FOCUS_EPISTEMIC_STATES = new Set([
+  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
+]);
 const AUTHORITY_KEY_RE = /(?:^|:|_)(?:acl|api[_-]?key|capability|password|permission|secret|token)(?::|_|$)/iu;
 
 function fail(code) {
@@ -90,6 +93,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     const eventId = digestId('cycle', [tenant, agent, runtime, stageKey]);
     const normalized = observations.map((item, index) => ({
       observation_id: digestId('cycleobs', [eventId, String(index)]),
+      epistemic_state: 'verified',
       ...item,
     }));
     for (let attempt = 0; attempt < 4; attempt += 1) {
@@ -216,16 +220,19 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
       fail('COGNITIVE_FOCUS_INVALID');
     }
     const observations = input.observations.map((item) => {
-      if (!exactKeys(item, new Set(['domain', 'key', 'value', 'confidence', 'scope']))) fail('COGNITIVE_FOCUS_INVALID');
+      if (!exactKeys(item, new Set(['domain', 'key', 'value', 'confidence', 'epistemicState', 'scope']))) fail('COGNITIVE_FOCUS_INVALID');
       const domain = String(item.domain ?? '');
       const key = cleanLabel(item.key, 128);
       const value = cleanLabel(item.value, 512);
       const confidence = Number(item.confidence);
+      const epistemicState = item.epistemicState === undefined
+        ? 'legacy_unknown' : String(item.epistemicState);
       const scope = cleanLabel(item.scope, 128);
       if (!FOCUS_DOMAINS.has(domain) || !key || AUTHORITY_KEY_RE.test(key) || !value
           || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
+          || !FOCUS_EPISTEMIC_STATES.has(epistemicState)
           || !scope || scope === 'runtime') fail('COGNITIVE_FOCUS_INVALID');
-      return { domain, key, value, confidence, scope };
+      return { domain, key, value, confidence, epistemic_state: epistemicState, scope };
     });
     return commitDurableStage(`focus-${input.snapshotId}`, observations);
   }
@@ -269,6 +276,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
       key,
       value,
       confidence: 1,
+      epistemic_state: 'verified',
       scope,
       ...(correction ? { supersedes: targetObservationId } : { withdraws: targetObservationId }),
     };

package/bin/cognitive-work-focus.cjs

@@ -4,6 +4,9 @@ const crypto = require('node:crypto');
 
 const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 const STATUSES = new Set(['active', 'paused', 'blocked']);
+const EPISTEMIC_STATES = new Set([
+  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
+]);
 const NEXT_TRIGGER = new Map([
   ['active', 'Continue the active goal from its last verified state.'],
   ['paused', 'Wait until the goal is explicitly resumed.'],
@@ -36,8 +39,11 @@ function buildCognitiveWorkFocus(goal) {
   const lastVerified = bounded(checkpoint?.lastVerified);
   const nextAction = bounded(checkpoint?.nextAction);
   const checkpointEvidence = bounded(checkpoint?.expectedEvidence);
+  const checkpointEpistemicState = bounded(checkpoint?.epistemicState, 32);
   const hasCheckpoint = checkpoint !== null && checkpointPhase && lastVerified
     && nextAction && checkpointEvidence;
+  const epistemicState = hasCheckpoint && EPISTEMIC_STATES.has(checkpointEpistemicState)
+    ? checkpointEpistemicState : hasCheckpoint ? 'legacy_unknown' : 'verified';
   const digest = crypto.createHash('sha256')
     .update([
       goalId, objective, completionCriterion, status, String(turnsUsed),
@@ -45,6 +51,7 @@ function buildCognitiveWorkFocus(goal) {
       hasCheckpoint ? lastVerified : '',
       hasCheckpoint ? nextAction : '',
       hasCheckpoint ? checkpointEvidence : '',
+      epistemicState,
     ].join('\0'))
     .digest('hex').slice(0, 40);
   const keyRoot = `goal:${goalId}`;
@@ -52,21 +59,21 @@ function buildCognitiveWorkFocus(goal) {
     snapshotId: `goalfocus-${digest}`,
     focusScope,
     observations: [
-      { domain: 'goal', key: `${keyRoot}:objective`, value: objective, confidence: 1, scope: focusScope },
+      { domain: 'goal', key: `${keyRoot}:objective`, value: objective, confidence: 1, epistemicState, scope: focusScope },
       {
         domain: 'open_thread', key: `${keyRoot}:status`,
         value: hasCheckpoint ? `Goal is ${status}. Phase ${checkpointPhase}. Last verified: ${lastVerified}` : `Goal is ${status}.`,
-        confidence: 1, scope: focusScope,
+        confidence: 1, epistemicState, scope: focusScope,
       },
       {
         domain: 'next_trigger', key: `${keyRoot}:next`,
         value: status === 'active' && hasCheckpoint ? nextAction : NEXT_TRIGGER.get(status),
-        confidence: 1, scope: focusScope,
+        confidence: 1, epistemicState, scope: focusScope,
       },
       {
         domain: 'expected_evidence', key: `${keyRoot}:evidence`,
         value: status === 'active' && hasCheckpoint ? checkpointEvidence : completionCriterion,
-        confidence: 1, scope: focusScope,
+        confidence: 1, epistemicState, scope: focusScope,
       },
     ],
   };

package/bin/launcher-runtime.js

@@ -30,6 +30,9 @@ const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
+  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_EXIT_INTENT_MESSAGE,
@@ -40,7 +43,9 @@ const {
   recordRunningUpdateEvent,
   readActiveRuntime,
   readPendingRuntime,
+  restoreActiveRuntime,
   clearPendingRuntime,
+  handoffArgsForMode,
   stageRuntime,
 } = require('./running-update.cjs');
 const {
@@ -326,8 +331,9 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
   let updateStarted = false;
-  let runtimeReady = false;
-  let activeSession;
+  let runtimeReady = options.initialRuntimeReady === true;
+  let activeSession = options.initialActiveSession;
+  let acceptedHandoff;
   let runtimeExitIntent = false;
   let supervisionCompleted = false;
   let runningUpdatePollTimer;
@@ -467,6 +473,35 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         if (runtimeReady && !updateStarted) startPreparation(child);
       } else if (runtimeReady) scheduleNextPreparation(child);
     }
+    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE) {
+      refreshRunningUpdateMode();
+      const requestedCwd = resolveHandoffCwd(message.cwd, '');
+      const requestMatches = preparedTarget !== undefined
+        && automaticMode()
+        && validSessionMessage(message)
+        && activeSession !== undefined
+        && message.version === preparedTarget.version
+        && message.mode === runningUpdateMode
+        && message.sessionId === activeSession.sessionId
+        && requestedCwd === activeSession.cwd;
+      if (!requestMatches) return;
+      acceptedHandoff = Object.freeze({
+        cwd: requestedCwd,
+        mode: runningUpdateMode,
+        sessionId: message.sessionId,
+        target: preparedTarget,
+      });
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+            version: preparedTarget.version,
+            mode: runningUpdateMode,
+            sessionId: message.sessionId,
+          });
+        } catch {}
+      }
+    }
   };
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
   const core = options.existingCore || spawnCore(args, env, cwd, {
@@ -508,6 +543,82 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   supervisionCompleted = true;
   clearRunningUpdatePoll();
   if (existingMessageHandler) core.child.off('message', existingMessageHandler);
+  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE && acceptedHandoff !== undefined) {
+    const sharedHome = env.BLUN_SHARED_HOME;
+    const previousActiveRuntime = (options.readActiveRuntime || readActiveRuntime)(sharedHome);
+    const previousVersion = readPackageVersionAt(packageRoot);
+    const handoffArgs = handoffArgsForMode(args, acceptedHandoff.mode, acceptedHandoff.sessionId);
+    let targetSession;
+    const targetCore = spawnCore(handoffArgs, env, acceptedHandoff.cwd, {
+      packageRoot: acceptedHandoff.target.packageRoot,
+      onMessage(message) {
+        if (message?.type === RUNTIME_READY_MESSAGE && validSessionMessage(message)) {
+          targetSession = Object.freeze({
+            cwd: resolveHandoffCwd(message.cwd, acceptedHandoff.cwd),
+            sessionId: message.sessionId,
+          });
+        }
+      },
+    });
+    const targetLoaded = await targetCore.loaded;
+    const targetReady = targetLoaded
+      && await (options.waitForRuntimeReady || waitForRuntimeReady)(targetCore, options.readyTimeoutMs);
+    if (targetReady) {
+      await (options.activateRuntime || activateRuntime)(sharedHome, acceptedHandoff.target);
+      (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, acceptedHandoff.target);
+      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+        event: 'activated-live-handoff',
+        fromVersion: previousVersion,
+        toVersion: acceptedHandoff.target.version,
+        mode: acceptedHandoff.mode,
+        sessionId: acceptedHandoff.sessionId,
+      }, { now: options.nowImpl });
+      return superviseProtectedCore(handoffArgs, env, acceptedHandoff.cwd, async () => {}, {
+        ...options,
+        existingCore: targetCore,
+        initialActiveSession: targetSession,
+        initialRuntimeReady: true,
+        packageRoot: acceptedHandoff.target.packageRoot,
+        startupPendingRuntime: undefined,
+        staleActiveRuntime: undefined,
+        recoveryRuntime: {
+          activeRuntime: previousActiveRuntime,
+          activatedAt: (options.nowImpl || Date.now)(),
+          packageRoot,
+          version: previousVersion,
+        },
+      });
+    }
+    try {
+      targetCore.child.kill();
+    } catch {}
+    await (options.restoreActiveRuntime || restoreActiveRuntime)(sharedHome, previousActiveRuntime);
+    (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, acceptedHandoff.target);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+      event: 'live-handoff-rolled-back',
+      failedVersion: acceptedHandoff.target.version,
+      recoveryVersion: previousVersion,
+    }, { now: options.nowImpl });
+    const fallback = spawnCore(handoffArgs, env, acceptedHandoff.cwd, { packageRoot });
+    const fallbackLoaded = await fallback.loaded;
+    const fallbackReady = fallbackLoaded
+      && await (options.waitForRuntimeReady || waitForRuntimeReady)(fallback, options.readyTimeoutMs);
+    if (fallbackReady) {
+      return superviseProtectedCore(handoffArgs, env, acceptedHandoff.cwd, async () => {}, {
+        ...options,
+        existingCore: fallback,
+        initialActiveSession: activeSession,
+        initialRuntimeReady: true,
+        packageRoot,
+        startupPendingRuntime: undefined,
+        staleActiveRuntime: undefined,
+        recoveryRuntime: undefined,
+      });
+    }
+    const fallbackResult = await fallback.completed;
+    if (fallbackResult.error) throw fallbackResult.error;
+    return exitCodeForChild(fallbackResult, fallbackLoaded);
+  }
   const recovery = options.recoveryRuntime;
   if (shouldRecoverActivatedRuntime(result, recovery, {
     now: (options.nowImpl || Date.now)(),

package/bin/personality-memory-adapter.cjs

@@ -130,6 +130,7 @@ function createPersonalityMemoryAdapter({ identityRoot } = {}) {
             key: `relationship:${digest('actor', [value.actorId]).slice(0, 30)}:curiosity-presentation`,
             value: value.topic,
             confidence: 1,
+            epistemic_state: 'verified',
             scope: relationshipScope(value.actorId),
           }],
         });

package/blun.mjs

@@ -245733,6 +245733,7 @@ var init_events$1 = __esmMin((() => {
 			revision: number$1().int().min(1),
 			phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 			evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward", "legacy_unknown"]),
+			epistemicState: _enum(["verified", "credible_unverified", "hypothesis", "uncertain_memory", "stale", "unknown", "legacy_unknown"]),
 			lastVerified: string(),
 			nextAction: string(),
 			expectedEvidence: string(),
@@ -261769,7 +261770,10 @@ var init_turn = __esmMin((() => {
 			if (active === null || active === "resuming" || !active.acceptingSteers || expectedTurnId !== void 0 && expectedTurnId !== this.currentId) return null;
 			if (this.telegramDeliveryLedger.isDuplicate(input, origin)) {
 				this.agent.telemetry.track("telegram_delivery_duplicate_dropped", { intake: "active_steer" });
-				return this.currentId;
+				return {
+					turnId: this.currentId,
+					duplicate: true
+				};
 			}
 			this.telegramDeliveryLedger.remember(input, origin);
 			this.agent.records.logRecord({
@@ -261778,7 +261782,10 @@ var init_turn = __esmMin((() => {
 				origin
 			});
 			this.bufferSteer(input, origin, this.currentId);
-			return this.currentId;
+			return {
+				turnId: this.currentId,
+				duplicate: false
+			};
 		}
 		retry(trigger) {
 			return this.prompt([], {
@@ -262700,7 +262707,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, and an explicit evidence basis. 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. 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.\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, and an explicit evidence basis. 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.\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";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts
@@ -262715,6 +262722,7 @@ var init_update_goal = __esmMin((() => {
 		revision: number$1().int().min(1),
 		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 		evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward"]),
+		epistemicState: _enum(["verified", "credible_unverified", "hypothesis", "uncertain_memory", "stale", "unknown"]),
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),
 		expectedEvidence: string().min(1).max(512)
@@ -265455,11 +265463,12 @@ var init_agent = __esmMin((() => {
 				steer: (payload) => {
 					this.telemetry.track("input_steer", { parts: payload.input.length });
 					if (payload.activeTurnOnly === true) {
-						const activeTurnId = this.turn.steerActive(payload.input, payload.expectedTurnId);
+						const activeSteer = this.turn.steerActive(payload.input, payload.expectedTurnId);
 						return {
-							accepted: activeTurnId !== null,
-							buffered: activeTurnId !== null,
-							turnId: activeTurnId
+							accepted: activeSteer !== null,
+							buffered: activeSteer !== null && activeSteer.duplicate !== true,
+							duplicate: activeSteer?.duplicate === true,
+							turnId: activeSteer?.turnId ?? null
 						};
 					}
 					const launchedTurnId = this.turn.steer(payload.input);
@@ -516165,11 +516174,14 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 //#region src/tui/blun-tui.ts
 const {
 	AUTO_UPDATE_SETTLE_MS,
+	RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_EXIT_INTENT_MESSAGE,
 	RUNTIME_READY_MESSAGE,
+	isSafeRuntimeBoundary,
 	pruneRunningUpdateReleases
 } = __require("./bin/running-update.cjs");
 const {
@@ -516205,10 +516217,38 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 	const version = tui.runningUpdatePreparedVersion;
 	const mode = tui.runningUpdatePreparedMode;
 	if (typeof version !== "string" || mode !== RUNNING_UPDATE_MODES.RESUME && mode !== RUNNING_UPDATE_MODES.NEW) return false;
-	if (tui.runningUpdatePreparedNoticeVersion === version) return false;
-	tui.runningUpdatePreparedNoticeVersion = version;
-	tui.showStatus(`Update ${version} ist sicher geladen. Die laufende Sitzung bleibt aktiv; beim naechsten natuerlichen Start wird sie automatisch fortgesetzt.`, "success");
-	return false;
+	if (!isSafeRuntimeBoundary({
+		isShuttingDown: tui.isShuttingDown,
+		streamingPhase: tui.state.appState.streamingPhase,
+		isCompacting: tui.state.appState.isCompacting,
+		queuedMessages: tui.state.queuedMessages.length,
+		activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
+		shellCommands: tui.shellOutputStreams.size,
+		queueCommandRunning: tui.queueCommandRunning
+	})) {
+		if (tui.runningUpdatePreparedNoticeVersion !== version) {
+			tui.runningUpdatePreparedNoticeVersion = version;
+			tui.showStatus(`Update ${version} ist sicher geladen und wird nach dem laufenden Auftrag in derselben Sitzung uebernommen.`, "success");
+		}
+		return false;
+	}
+	if (!process.connected || tui.runningUpdateHandoffRequestedVersion === version) return false;
+	const sessionId = tui.getCurrentSessionId();
+	if (typeof sessionId !== "string" || sessionId.length === 0) return false;
+	tui.runningUpdateHandoffRequestedVersion = version;
+	try {
+		process.send({
+			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
+			version,
+			mode,
+			sessionId,
+			cwd: tui.state.appState.workDir
+		});
+		return true;
+	} catch {
+		tui.runningUpdateHandoffRequestedVersion = void 0;
+		return false;
+	}
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
@@ -516217,6 +516257,7 @@ function installRunningUpdateListener(tui) {
 			tui.runningUpdatePreparedMode = message.mode;
 			requestRunningUpdateAtSafeBoundary(tui);
 		}
+		if (message?.type === RUNNING_UPDATE_HANDOFF_ACK_MESSAGE && message.version === tui.runningUpdateHandoffRequestedVersion && message.sessionId === tui.getCurrentSessionId()) void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 	};
 	process.on("message", handler);
 	return () => process.off("message", handler);
@@ -517242,8 +517283,10 @@ var BlunTUI = class {
 			return this.restoreQueuedSteer(inFlight, error);
 		};
 		try {
-			if (!(await this.harness.withInteractiveAgent(item.agentId ?? "main", () => session.steerActive(input, expectedTurnId === void 0 ? {} : { expectedTurnId }))).accepted) return this.recoverRejectedActiveSteer(inFlight);
+			const result = await this.harness.withInteractiveAgent(item.agentId ?? "main", () => session.steerActive(input, expectedTurnId === void 0 ? {} : { expectedTurnId }));
+			if (!result.accepted) return this.recoverRejectedActiveSteer(inFlight);
 			inFlight.accepted = true;
+			if (result.duplicate === true) return this.commitQueuedSteer(inFlight);
 			if (inFlight.turnEnded) return restoreHead();
 			this.commitQueuedSteerIfReady(inFlight);
 		} catch (error) {

package/package.json

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