blun-king-cli 9.1.359 → 9.1.361

package/bin/cognitive-effective-view.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const CANONICAL_LATEST_DOMAINS = new Set([
+  'goal', 'open_thread', 'next_trigger', 'expected_evidence',
+]);
+const CONFIDENCE_MARGIN = 0.2;
+
+function compareVariants(left, right) {
+  return right.maxConfidence - left.maxConfidence
+    || right.confirmations - left.confirmations
+    || right.latestOccurredAt - left.latestOccurredAt
+    || left.value.localeCompare(right.value);
+}
+
+function resolveCognitiveEvidenceGroup(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+  const ordered = [...entries].sort((left, right) => left.occurredAt - right.occurredAt
+    || left.index - right.index);
+  const latest = ordered.at(-1);
+  const distinctValues = new Set(ordered.map((item) => item.value));
+  if (distinctValues.size === 1) return { ...latest, revised: false, contested: false, conflict: false };
+  if (CANONICAL_LATEST_DOMAINS.has(latest.domain)) {
+    return { ...latest, revised: true, contested: false, conflict: false };
+  }
+
+  const variants = new Map();
+  for (const item of ordered) {
+    const variant = variants.get(item.value) ?? {
+      value: item.value,
+      maxConfidence: item.confidence,
+      confirmations: 0,
+      latestOccurredAt: item.occurredAt,
+      representative: item,
+    };
+    variant.confirmations += 1;
+    variant.latestOccurredAt = Math.max(variant.latestOccurredAt, item.occurredAt);
+    if (item.confidence > variant.maxConfidence
+        || item.confidence === variant.maxConfidence && item.occurredAt >= variant.representative.occurredAt) {
+      variant.maxConfidence = item.confidence;
+      variant.representative = item;
+    }
+    variants.set(item.value, variant);
+  }
+  const ranked = [...variants.values()].sort(compareVariants);
+  const strongest = ranked[0];
+  const runnerUp = ranked[1];
+  if (strongest.maxConfidence - runnerUp.maxConfidence >= CONFIDENCE_MARGIN - Number.EPSILON) {
+    return {
+      ...strongest.representative,
+      confidence: strongest.maxConfidence,
+      occurredAt: strongest.latestOccurredAt,
+      revised: false,
+      contested: true,
+      conflict: false,
+    };
+  }
+  return {
+    ...latest,
+    confidence: strongest.maxConfidence,
+    occurredAt: Math.max(...ranked.map((item) => item.latestOccurredAt)),
+    revised: false,
+    contested: false,
+    conflict: true,
+  };
+}
+
+module.exports = { resolveCognitiveEvidenceGroup };

package/bin/cognitive-focus-projection.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+
 const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
 const DOMAIN_WEIGHTS = new Map([
   ['goal', 60],
@@ -60,11 +62,11 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
     const latest = entries.at(-1);
     if (!scopes.includes(latest.scope)) continue;
-    const revised = entries.some((item) => item.value !== latest.value);
+    const effective = resolveCognitiveEvidenceGroup(entries);
+    if (!effective) continue;
     ranked.push({
-      ...latest,
-      revised,
-      score: DOMAIN_WEIGHTS.get(latest.domain) + latest.confidence * 10,
+      ...effective,
+      score: DOMAIN_WEIGHTS.get(effective.domain) + effective.confidence * 10,
     });
   }
   ranked.sort((left, right) => right.score - left.score
@@ -72,7 +74,11 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
   if (ranked.length === 0) return null;
 
   const selected = ranked.slice(0, maxItems);
-  const lines = selected.map((item) => `- ${LABELS.get(item.domain)}: ${item.value}${item.revised ? ' [revised]' : ''}`);
+  const lines = selected.map((item) => {
+    if (item.conflict) return `- Conflict: ${item.key} has incompatible evidence; verify before relying on it.`;
+    const marker = item.contested ? ' [contested; stronger evidence]' : item.revised ? ' [revised]' : '';
+    return `- ${LABELS.get(item.domain)}: ${item.value}${marker}`;
+  });
   while ([`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n').length > maxChars
       && lines.length > 0) lines.pop();
   if (lines.length === 0) return null;

package/bin/cognitive-turn-lifecycle.cjs

@@ -118,6 +118,50 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     fail('COGNITIVE_VERSION_CONFLICT');
   }
 
+  function commitDurableStage(stageKey, observations) {
+    if (stageResults.has(stageKey)) return { ...stageResults.get(stageKey), idempotent: true };
+    const eventId = digestId('durable', [tenant, agent, stageKey]);
+    if (store.hasEvent(eventId)) {
+      const result = { idempotent: true };
+      stageResults.set(stageKey, result);
+      return result;
+    }
+    const occurredAt = stageTime(`durable:${stageKey}`);
+    const normalized = observations.map((item, index) => ({
+      observation_id: digestId('durableobs', [eventId, String(index)]),
+      ...item,
+    }));
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      if (store.hasEvent(eventId)) {
+        const result = { idempotent: true };
+        stageResults.set(stageKey, result);
+        return result;
+      }
+      const expectedVersion = store.read({ tenantId: tenant, agentId: agent }).version;
+      try {
+        const result = store.commit({
+          tenantId: tenant,
+          agentId: agent,
+          eventId,
+          expectedVersion,
+          occurredAt,
+          source: {
+            provider: 'runtime',
+            actor_id: agent,
+            context_id: 'durable-focus',
+            message_id: stageKey,
+          },
+          observations: normalized,
+        });
+        stageResults.set(stageKey, result);
+        return result;
+      } catch (error) {
+        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
+      }
+    }
+    fail('COGNITIVE_VERSION_CONFLICT');
+  }
+
   function startTurn(input) {
     if (!exactKeys(input, new Set(['turnId', 'originKind']))) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
@@ -183,7 +227,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
           || !scope || scope === 'runtime') fail('COGNITIVE_FOCUS_INVALID');
       return { domain, key, value, confidence, scope };
     });
-    return commitStage(`focus-${input.snapshotId}`, observations);
+    return commitDurableStage(`focus-${input.snapshotId}`, observations);
   }
 
   function toolFields(input, allowedKeys) {

package/bin/cognitive-work-focus.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+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 NEXT_TRIGGER = new Map([
+  ['active', 'Continue the active goal from its last verified state.'],
+  ['paused', 'Wait until the goal is explicitly resumed.'],
+  ['blocked', 'Resolve the current blocker before continuing.'],
+]);
+
+function bounded(value, max = 512) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  if (!text) return '';
+  return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
+}
+
+function buildCognitiveWorkFocus(goal) {
+  if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return null;
+  const goalId = String(goal.goalId ?? '').trim();
+  const objective = bounded(goal.objective);
+  const completionCriterion = bounded(goal.completionCriterion)
+    || 'Goal completion must be supported by verified evidence.';
+  const status = String(goal.status ?? '');
+  const turnsUsed = Number(goal.turnsUsed);
+  if (!SAFE_ID_RE.test(goalId) || !objective || !STATUSES.has(status)
+      || !Number.isSafeInteger(turnsUsed) || turnsUsed < 0) return null;
+
+  const focusScope = `goal:${goalId}`;
+  if (!SAFE_ID_RE.test(focusScope)) return null;
+  const digest = crypto.createHash('sha256')
+    .update([goalId, objective, completionCriterion, status, String(turnsUsed)].join('\0'))
+    .digest('hex').slice(0, 40);
+  const keyRoot = `goal:${goalId}`;
+  return {
+    snapshotId: `goalfocus-${digest}`,
+    focusScope,
+    observations: [
+      { domain: 'goal', key: `${keyRoot}:objective`, value: objective, confidence: 1, scope: focusScope },
+      { domain: 'open_thread', key: `${keyRoot}:status`, value: `Goal is ${status}.`, confidence: 1, scope: focusScope },
+      { domain: 'next_trigger', key: `${keyRoot}:next`, value: NEXT_TRIGGER.get(status), confidence: 1, scope: focusScope },
+      { domain: 'expected_evidence', key: `${keyRoot}:evidence`, value: completionCriterion, confidence: 1, scope: focusScope },
+    ],
+  };
+}
+
+module.exports = { buildCognitiveWorkFocus };

package/blun.mjs

@@ -261464,7 +261464,7 @@ function toolResultText(result) {
 function abandonedToolResultOutput(ended) {
 	return `Tool call did not complete: ${ended.reason === "cancelled" ? "the turn was cancelled" : ended.reason === "failed" ? `the turn failed${ended.error !== void 0 ? ` (${ended.error.message})` : ""}` : "the turn ended"} before its result was recorded. Do not assume the tool completed successfully.`;
 }
-var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -261486,6 +261486,7 @@ var init_turn = __esmMin((() => {
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.cjs"));
 	({ cognitiveFocusScopesForTurn } = createRequire(import.meta.url)("./bin/cognitive-focus-scope.cjs"));
+	({ buildCognitiveWorkFocus } = createRequire(import.meta.url)("./bin/cognitive-work-focus.cjs"));
 	({ buildAttentionQueueItem } = createRequire(import.meta.url)("./bin/cognitive-attention-delivery.cjs"));
 	BLUN_LEAN_TOOL_NAMES = new Set(BLUN_CORE_TOOL_NAMES);
 	BLUN_ATTACHMENT_MARKER_RE = /\b(?:attachment_file_id|telegram-anhang|telegram attachment)\b/i;
@@ -261624,7 +261625,16 @@ var init_turn = __esmMin((() => {
 		projectCognitiveState(turnId, input) {
 			try {
 				const focusScopes = cognitiveFocusScopesForTurn(input);
-				return this.getCognitiveLifecycle()?.projectForTurn({ turnId, focusScopes }) ?? null;
+				const lifecycle = this.getCognitiveLifecycle();
+				const workFocus = buildCognitiveWorkFocus(this.agent.goal.getGoal().goal);
+				if (workFocus !== null) {
+					lifecycle?.recordFocusSnapshot({
+						snapshotId: workFocus.snapshotId,
+						observations: workFocus.observations
+					});
+					focusScopes.unshift(workFocus.focusScope);
+				}
+				return lifecycle?.projectForTurn({ turnId, focusScopes }) ?? null;
 			} catch (error) {
 				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: "projectForTurn", error_type: error?.code ?? error?.name ?? "Error" });
 				return null;

package/package.json

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