blun-king-cli 9.1.362 → 9.1.364

package/bin/cognitive-effective-view.cjs

@@ -14,8 +14,12 @@ function compareVariants(left, right) {
 
 function resolveCognitiveEvidenceGroup(entries) {
   if (!Array.isArray(entries) || entries.length === 0) return null;
-  const superseded = new Set(entries.map((item) => item.supersedes).filter(Boolean));
-  const active = entries.filter((item) => !superseded.has(item.observationId));
+  const withdrawals = entries.filter((item) => Boolean(item.withdraws));
+  const deletionCutoff = withdrawals.length > 0
+    ? Math.max(...withdrawals.map((item) => item.occurredAt)) : Number.NEGATIVE_INFINITY;
+  const evidence = entries.filter((item) => !item.withdraws && item.occurredAt > deletionCutoff);
+  const superseded = new Set(evidence.map((item) => item.supersedes).filter(Boolean));
+  const active = evidence.filter((item) => !superseded.has(item.observationId));
   if (active.length === 0) return null;
   const ordered = [...active].sort((left, right) => left.occurredAt - right.occurredAt
     || left.index - right.index);

package/bin/cognitive-focus-projection.cjs

@@ -49,6 +49,8 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     const observationId = clean(item?.observation_id, 128);
     const supersedes = item?.supersedes === null || item?.supersedes === undefined
       ? null : clean(item.supersedes, 128);
+    const withdraws = item?.withdraws === null || item?.withdraws === undefined
+      ? null : clean(item.withdraws, 128);
     const confidence = Number(item?.confidence);
     const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
     if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
@@ -56,7 +58,7 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
         || !Number.isFinite(occurredAt)) return;
     const groupKey = `${scope}\0${domain}\0${key}`;
     const existing = groups.get(groupKey) ?? [];
-    existing.push({ domain, key, value, scope, observationId, supersedes, confidence, occurredAt, index });
+    existing.push({ domain, key, value, scope, observationId, supersedes, withdraws, confidence, occurredAt, index });
     groups.set(groupKey, existing);
   });
 

package/bin/cognitive-state-store.cjs

@@ -52,7 +52,7 @@ function normalizeSource(source) {
 }
 
 function normalizeObservation(value) {
-  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope', 'supersedes']);
+  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope', 'supersedes', 'withdraws']);
   if (!exactKeys(value, allowed) || hasForbiddenKey(value)) fail('COGNITIVE_FORBIDDEN_FIELD');
   const observation = {
     observation_id: safeId(value.observation_id),
@@ -72,6 +72,13 @@ function normalizeObservation(value) {
     observation.supersedes = safeId(value.supersedes);
     if (!observation.supersedes || observation.confidence !== 1) fail('COGNITIVE_INVALID_CORRECTION');
   }
+  if (value.withdraws !== undefined && value.withdraws !== null) {
+    observation.withdraws = safeId(value.withdraws);
+    if (!observation.withdraws || observation.confidence !== 1 || observation.value !== 'withdrawn') {
+      fail('COGNITIVE_INVALID_WITHDRAWAL');
+    }
+  }
+  if (observation.supersedes && observation.withdraws) fail('COGNITIVE_INVALID_EVENT');
   return observation;
 }
 
@@ -148,7 +155,8 @@ function initialize(db) {
       scope TEXT NOT NULL,
       source_json TEXT NOT NULL,
       occurred_at TEXT NOT NULL,
-      supersedes_observation_id TEXT
+      supersedes_observation_id TEXT,
+      withdraws_observation_id TEXT
     );
     CREATE INDEX IF NOT EXISTS cognitive_observations_stream
       ON cognitive_observations (tenant_id, agent_id, occurred_at, observation_id);
@@ -176,6 +184,9 @@ function initialize(db) {
   if (!observationColumns.some((column) => column.name === 'supersedes_observation_id')) {
     db.exec('ALTER TABLE cognitive_observations ADD COLUMN supersedes_observation_id TEXT');
   }
+  if (!observationColumns.some((column) => column.name === 'withdraws_observation_id')) {
+    db.exec('ALTER TABLE cognitive_observations ADD COLUMN withdraws_observation_id TEXT');
+  }
 }
 
 function openCognitiveStateStore({ home } = {}) {
@@ -207,8 +218,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)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        (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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
       const sourceJson = JSON.stringify(normalized.source);
       for (const observation of normalized.observations) {
         if (observation.supersedes) {
@@ -218,9 +229,16 @@ function openCognitiveStateStore({ home } = {}) {
               || target.domain !== observation.domain || target.fact_key !== observation.key
               || target.scope !== observation.scope) fail('COGNITIVE_INVALID_CORRECTION');
         }
+        if (observation.withdraws) {
+          const target = db.prepare(`SELECT tenant_id, agent_id, domain, fact_key, scope
+            FROM cognitive_observations WHERE observation_id = ?`).get(observation.withdraws);
+          if (!target || target.tenant_id !== normalized.tenant_id || target.agent_id !== normalized.agent_id
+              || target.domain !== observation.domain || target.fact_key !== observation.key
+              || 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,
-          normalized.occurred_at, observation.supersedes ?? null);
+          normalized.occurred_at, observation.supersedes ?? null, observation.withdraws ?? null);
       }
       db.prepare(`INSERT INTO cognitive_streams (tenant_id, agent_id, version, updated_at) VALUES (?, ?, ?, ?)
         ON CONFLICT(tenant_id, agent_id) DO UPDATE SET version = excluded.version, updated_at = excluded.updated_at`)
@@ -239,7 +257,7 @@ function openCognitiveStateStore({ home } = {}) {
     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,
-      supersedes_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 {
       version: Number(stream?.version ?? 0),
@@ -254,6 +272,7 @@ function openCognitiveStateStore({ home } = {}) {
         source: JSON.parse(row.source_json),
         occurred_at: row.occurred_at,
         supersedes: row.supersedes_observation_id ?? null,
+        withdraws: row.withdraws_observation_id ?? null,
       })),
     };
   }

package/bin/cognitive-turn-lifecycle.cjs

@@ -230,6 +230,94 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     return commitDurableStage(`focus-${input.snapshotId}`, observations);
   }
 
+  function commitExplicitFocusRevision(kind, input) {
+    const correction = kind === 'correction';
+    const allowed = correction
+      ? new Set(['requestId', 'targetObservationId', 'domain', 'key', 'value', 'scope', 'authority', 'confirmation', 'occurredAt', 'source'])
+      : new Set(['requestId', 'targetObservationId', 'domain', 'key', 'scope', 'authority', 'confirmation', 'occurredAt', 'source']);
+    if (!exactKeys(input, allowed)) fail('COGNITIVE_REVISION_INVALID');
+    const requestId = safeId(input.requestId);
+    const targetObservationId = safeId(input.targetObservationId);
+    const domain = String(input.domain ?? '');
+    const key = cleanLabel(input.key, 128);
+    const scope = cleanLabel(input.scope, 128);
+    const occurredAt = String(input.occurredAt ?? '').trim();
+    const source = input.source;
+    if (input.authority !== 'runtime_user_prompt_hook' || input.confirmation !== 'explicit_user_request') {
+      fail('COGNITIVE_REVISION_EXPLICIT_USER_REQUIRED');
+    }
+    if (!requestId || !targetObservationId || !FOCUS_DOMAINS.has(domain) || !key
+        || AUTHORITY_KEY_RE.test(key) || !scope || scope === 'runtime'
+        || Number.isNaN(Date.parse(occurredAt))
+        || !exactKeys(source, new Set(['provider', 'actorId', 'contextId', 'messageId']))) {
+      fail('COGNITIVE_REVISION_INVALID');
+    }
+    const normalizedSource = {
+      provider: safeId(source.provider),
+      actor_id: safeId(source.actorId),
+      context_id: safeId(source.contextId),
+      message_id: safeId(source.messageId),
+    };
+    if (Object.values(normalizedSource).some((value) => !value)) fail('COGNITIVE_REVISION_INVALID');
+    const value = correction ? cleanLabel(input.value, 512) : 'withdrawn';
+    if (!value) fail('COGNITIVE_REVISION_INVALID');
+    const eventId = digestId('revision', [tenant, agent, kind, requestId]);
+    const observationId = digestId('revisionobs', [eventId]);
+    const observation = {
+      observation_id: observationId,
+      domain,
+      key,
+      value,
+      confidence: 1,
+      scope,
+      ...(correction ? { supersedes: targetObservationId } : { withdraws: targetObservationId }),
+    };
+    const normalizedOccurredAt = new Date(occurredAt).toISOString();
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const current = store.read({ tenantId: tenant, agentId: agent });
+      const existing = current.observations.find((item) => item.observation_id === observationId);
+      if (existing) {
+        const matches = existing.domain === observation.domain && existing.key === observation.key
+          && existing.value === observation.value && existing.confidence === 1
+          && existing.scope === observation.scope && existing.occurred_at === normalizedOccurredAt
+          && existing.supersedes === (observation.supersedes ?? null)
+          && existing.withdraws === (observation.withdraws ?? null)
+          && existing.source.provider === normalizedSource.provider
+          && existing.source.actor_id === normalizedSource.actor_id
+          && existing.source.context_id === normalizedSource.context_id
+          && existing.source.message_id === normalizedSource.message_id;
+        if (!matches) fail('COGNITIVE_REVISION_REQUEST_REUSE');
+        return { version: current.version, idempotent: true };
+      }
+      const target = current.observations.find((item) => item.observation_id === targetObservationId);
+      if (target && Date.parse(normalizedOccurredAt) < Date.parse(target.occurred_at)) {
+        fail('COGNITIVE_REVISION_TIME_ORDER');
+      }
+      try {
+        return store.commit({
+          tenantId: tenant,
+          agentId: agent,
+          eventId,
+          expectedVersion: current.version,
+          occurredAt: normalizedOccurredAt,
+          source: normalizedSource,
+          observations: [observation],
+        });
+      } catch (error) {
+        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
+      }
+    }
+    fail('COGNITIVE_VERSION_CONFLICT');
+  }
+
+  function correctFocusObservation(input) {
+    return commitExplicitFocusRevision('correction', input);
+  }
+
+  function withdrawFocusObservation(input) {
+    return commitExplicitFocusRevision('withdrawal', input);
+  }
+
   function toolFields(input, allowedKeys) {
     if (!exactKeys(input, allowedKeys)) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
@@ -337,6 +425,8 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     recordToolResult,
     recordToolBatch,
     recordFocusSnapshot,
+    correctFocusObservation,
+    withdrawFocusObservation,
     authorizeAttention,
     projectForTurn,
     endTurn,

package/package.json

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