blun-king-cli 9.1.303 → 9.1.305

package/bin/cognitive-state-store.cjs

@@ -0,0 +1,249 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+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 FORBIDDEN_KEY_RE = /(?:^|_)(?:acl|api_key|capability|password|permission|secret|token)(?:_|$)/iu;
+const MAX_EVENT_BYTES = 64 * 1024;
+const MAX_OBSERVATIONS = 32;
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function cleanText(value, max = 512) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  return text && text.length <= max ? text : '';
+}
+
+function hasForbiddenKey(value) {
+  if (!value || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return value.some(hasForbiddenKey);
+  return Object.entries(value).some(([key, child]) => FORBIDDEN_KEY_RE.test(key) || hasForbiddenKey(child));
+}
+
+function exactKeys(value, keys) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => keys.has(key));
+}
+
+function normalizeSource(source) {
+  const allowed = new Set(['provider', 'actor_id', 'context_id', 'message_id']);
+  if (!exactKeys(source, allowed) || hasForbiddenKey(source)) fail('COGNITIVE_FORBIDDEN_FIELD');
+  const normalized = {
+    provider: safeId(source.provider),
+    actor_id: safeId(source.actor_id),
+    context_id: safeId(source.context_id),
+    message_id: safeId(source.message_id),
+  };
+  if (Object.values(normalized).some((value) => !value)) fail('COGNITIVE_INVALID_EVENT');
+  return normalized;
+}
+
+function normalizeObservation(value) {
+  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope']);
+  if (!exactKeys(value, allowed) || hasForbiddenKey(value)) fail('COGNITIVE_FORBIDDEN_FIELD');
+  const observation = {
+    observation_id: safeId(value.observation_id),
+    domain: String(value.domain ?? ''),
+    key: cleanText(value.key, 128),
+    value: cleanText(value.value, 2048),
+    confidence: Number(value.confidence),
+    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) {
+    fail('COGNITIVE_INVALID_EVENT');
+  }
+  if (FORBIDDEN_KEY_RE.test(observation.key)) fail('COGNITIVE_FORBIDDEN_FIELD');
+  return observation;
+}
+
+function normalizeEvent(input) {
+  const tenantId = safeId(input.tenantId);
+  const agentId = safeId(input.agentId);
+  const eventId = safeId(input.eventId);
+  const expectedVersion = Number(input.expectedVersion);
+  const occurredAt = String(input.occurredAt ?? '').trim();
+  if (!tenantId || !agentId || !eventId || !Number.isSafeInteger(expectedVersion)
+      || expectedVersion < 0 || Number.isNaN(Date.parse(occurredAt))
+      || !Array.isArray(input.observations) || input.observations.length < 1
+      || input.observations.length > MAX_OBSERVATIONS) fail('COGNITIVE_INVALID_EVENT');
+  const normalized = {
+    tenant_id: tenantId,
+    agent_id: agentId,
+    event_id: eventId,
+    expected_version: expectedVersion,
+    occurred_at: occurredAt,
+    source: normalizeSource(input.source),
+    observations: input.observations.map(normalizeObservation),
+  };
+  const ids = new Set(normalized.observations.map((item) => item.observation_id));
+  if (ids.size !== normalized.observations.length) fail('COGNITIVE_INVALID_EVENT');
+  const payload = JSON.stringify(normalized);
+  if (Buffer.byteLength(payload) > MAX_EVENT_BYTES) fail('COGNITIVE_INVALID_EVENT');
+  return { normalized, payload };
+}
+
+function ensureHome(home) {
+  const root = path.resolve(String(home ?? ''));
+  try {
+    const stat = fs.lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) fail('COGNITIVE_UNSAFE_HOME');
+    return fs.realpathSync(root);
+  } catch (error) {
+    if (error?.code === 'COGNITIVE_UNSAFE_HOME') throw error;
+    fail('COGNITIVE_UNSAFE_HOME');
+  }
+}
+
+function initialize(db) {
+  db.exec(`
+    PRAGMA foreign_keys = ON;
+    PRAGMA journal_mode = WAL;
+    PRAGMA busy_timeout = 5000;
+    CREATE TABLE IF NOT EXISTS cognitive_streams (
+      tenant_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (tenant_id, agent_id)
+    );
+    CREATE TABLE IF NOT EXISTS cognitive_events (
+      event_id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      expected_version INTEGER NOT NULL,
+      new_version INTEGER NOT NULL,
+      occurred_at TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      previous_hash TEXT NOT NULL,
+      event_hash TEXT NOT NULL UNIQUE
+    );
+    CREATE TABLE IF NOT EXISTS cognitive_observations (
+      observation_id TEXT PRIMARY KEY,
+      event_id TEXT NOT NULL REFERENCES cognitive_events(event_id),
+      tenant_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      domain TEXT NOT NULL,
+      fact_key TEXT NOT NULL,
+      value_text TEXT NOT NULL,
+      confidence REAL NOT NULL,
+      scope TEXT NOT NULL,
+      source_json TEXT NOT NULL,
+      occurred_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS cognitive_observations_stream
+      ON cognitive_observations (tenant_id, agent_id, occurred_at, observation_id);
+  `);
+}
+
+function openCognitiveStateStore({ home } = {}) {
+  const root = ensureHome(home);
+  const stateRoot = path.join(root, 'state');
+  fs.mkdirSync(stateRoot, { recursive: true });
+  if (!fs.realpathSync(stateRoot).startsWith(`${root}${path.sep}`)) fail('COGNITIVE_UNSAFE_HOME');
+  const db = new DatabaseSync(path.join(stateRoot, 'cognitive-state.sqlite'));
+  initialize(db);
+
+  function commit(input) {
+    const { normalized, payload } = normalizeEvent(input);
+    const existing = db.prepare('SELECT payload_json, new_version, event_hash FROM cognitive_events WHERE event_id = ?').get(normalized.event_id);
+    if (existing) {
+      if (existing.payload_json !== payload) fail('COGNITIVE_EVENT_ID_REUSE');
+      return { version: existing.new_version, event_hash: existing.event_hash, idempotent: true };
+    }
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const stream = db.prepare('SELECT version FROM cognitive_streams WHERE tenant_id = ? AND agent_id = ?').get(normalized.tenant_id, normalized.agent_id);
+      const actualVersion = Number(stream?.version ?? 0);
+      if (actualVersion !== normalized.expected_version) fail('COGNITIVE_VERSION_CONFLICT');
+      const previous = db.prepare('SELECT event_hash FROM cognitive_events WHERE tenant_id = ? AND agent_id = ? ORDER BY new_version DESC LIMIT 1').get(normalized.tenant_id, normalized.agent_id);
+      const previousHash = String(previous?.event_hash ?? '0'.repeat(64));
+      const eventHash = crypto.createHash('sha256').update(`${previousHash}\0${payload}`).digest('hex');
+      const newVersion = actualVersion + 1;
+      db.prepare(`INSERT INTO cognitive_events
+        (event_id, tenant_id, agent_id, expected_version, new_version, occurred_at, payload_json, previous_hash, event_hash)
+        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)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+      const sourceJson = JSON.stringify(normalized.source);
+      for (const observation of normalized.observations) {
+        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);
+      }
+      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`)
+        .run(normalized.tenant_id, normalized.agent_id, newVersion, normalized.occurred_at);
+      db.exec('COMMIT');
+      return { version: newVersion, event_hash: eventHash };
+    } catch (error) {
+      try { db.exec('ROLLBACK'); } catch {}
+      throw error;
+    }
+  }
+
+  function read({ tenantId, agentId } = {}) {
+    const tenant = safeId(tenantId);
+    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
+      FROM cognitive_observations WHERE tenant_id = ? AND agent_id = ? ORDER BY occurred_at, rowid`).all(tenant, agent);
+    return {
+      version: Number(stream?.version ?? 0),
+      ...(stream?.updated_at ? { updated_at: stream.updated_at } : {}),
+      observations: rows.map((row) => ({
+        observation_id: row.observation_id,
+        domain: row.domain,
+        key: row.fact_key,
+        value: row.value_text,
+        confidence: row.confidence,
+        scope: row.scope,
+        source: JSON.parse(row.source_json),
+        occurred_at: row.occurred_at,
+      })),
+    };
+  }
+
+  function verify({ tenantId, agentId } = {}) {
+    const tenant = safeId(tenantId);
+    const agent = safeId(agentId);
+    if (!tenant || !agent) fail('COGNITIVE_INVALID_EVENT');
+    const rows = db.prepare(`SELECT payload_json, previous_hash, event_hash FROM cognitive_events
+      WHERE tenant_id = ? AND agent_id = ? ORDER BY new_version`).all(tenant, agent);
+    let previousHash = '0'.repeat(64);
+    for (const row of rows) {
+      const calculated = crypto.createHash('sha256').update(`${previousHash}\0${row.payload_json}`).digest('hex');
+      if (row.previous_hash !== previousHash || row.event_hash !== calculated) return { valid: false, events: rows.length };
+      previousHash = row.event_hash;
+    }
+    return { valid: true, events: rows.length, head_hash: previousHash };
+  }
+
+  return {
+    commit,
+    read,
+    verify,
+    close: () => {
+      try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch {}
+      db.close();
+    },
+  };
+}
+
+module.exports = { openCognitiveStateStore };

package/bin/cognitive-turn-lifecycle.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const RIGHTS_AUTHORITIES = new Set(['runtime_user_prompt_hook', 'runtime_tool_policy']);
+const RIGHTS_DECISIONS = new Set(['passed', 'blocked', 'not_applicable']);
+const TURN_REASONS = new Set(['completed', 'cancelled', 'filtered', 'failed']);
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  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 safeTurnId(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function digestId(prefix, values) {
+  const digest = crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40);
+  return `${prefix}-${digest}`;
+}
+
+function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now = () => new Date().toISOString() } = {}) {
+  const tenant = safeId(tenantId);
+  const agent = safeId(agentId);
+  const runtime = safeId(runtimeId ?? `runtime-${process.pid}-${Date.now()}`);
+  if (!tenant || !agent || !runtime || typeof now !== 'function') fail('COGNITIVE_LIFECYCLE_INVALID');
+  const store = openCognitiveStateStore({ home });
+  const stageTimes = new Map();
+  const stageResults = new Map();
+
+  function stageTime(stageKey) {
+    if (!stageTimes.has(stageKey)) {
+      const occurredAt = String(now());
+      if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_LIFECYCLE_INVALID');
+      stageTimes.set(stageKey, occurredAt);
+    }
+    return stageTimes.get(stageKey);
+  }
+
+  function commitStage(stageKey, observations) {
+    if (stageResults.has(stageKey)) return { ...stageResults.get(stageKey), idempotent: true };
+    const occurredAt = stageTime(stageKey);
+    const eventId = digestId('cycle', [tenant, agent, runtime, stageKey]);
+    const normalized = observations.map((item, index) => ({
+      observation_id: digestId('cycleobs', [eventId, String(index)]),
+      ...item,
+    }));
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      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: runtime,
+            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);
+    const originKind = safeId(input.originKind);
+    if (turnId === null || !originKind) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const key = `turn:${turnId}`;
+    return commitStage(`turn-${turnId}-start`, [
+      { domain: 'open_thread', key: `${key}:phase`, value: 'perceived', confidence: 1, scope: 'runtime' },
+      { domain: 'assumption', key: `${key}:classification`, value: `origin:${originKind}`, confidence: 1, scope: 'runtime' },
+      { domain: 'goal', key: `${key}:plan`, value: 'run-bounded-model-turn', confidence: 1, scope: 'runtime' },
+      { domain: 'next_trigger', key: `${key}:next`, value: 'runtime-policy-check', confidence: 1, scope: 'runtime' },
+      { domain: 'expected_evidence', key: `${key}:evidence`, value: 'turn.ended-event', confidence: 1, scope: 'runtime' },
+    ]);
+  }
+
+  function recordRightsCheck(input) {
+    if (!exactKeys(input, new Set(['turnId', 'decision', 'authority']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const decision = String(input.decision ?? '');
+    const authority = String(input.authority ?? '');
+    if (turnId === null || !RIGHTS_DECISIONS.has(decision)) fail('COGNITIVE_LIFECYCLE_INVALID');
+    if (!RIGHTS_AUTHORITIES.has(authority)) fail('COGNITIVE_RIGHTS_AUTHORITY_REQUIRED');
+    return commitStage(`turn-${turnId}-rights-${authority}`, [{
+      domain: 'world',
+      key: `turn:${turnId}:rights-check`,
+      value: `${decision}:${authority}`,
+      confidence: 1,
+      scope: 'runtime',
+    }]);
+  }
+
+  function endTurn(input) {
+    if (!exactKeys(input, new Set(['turnId', 'reason', 'durationMs']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const reason = String(input.reason ?? '');
+    const durationMs = Number(input.durationMs);
+    if (turnId === null || !TURN_REASONS.has(reason) || !Number.isSafeInteger(durationMs) || durationMs < 0) {
+      fail('COGNITIVE_LIFECYCLE_INVALID');
+    }
+    const key = `turn:${turnId}`;
+    return commitStage(`turn-${turnId}-end`, [
+      { domain: 'open_thread', key: `${key}:phase`, value: reason, confidence: 1, scope: 'runtime' },
+      { domain: 'expected_evidence', key: `${key}:result`, value: `turn.ended:${reason}:${durationMs}ms`, confidence: 1, scope: 'runtime' },
+      { domain: 'next_trigger', key: `${key}:next`, value: reason === 'completed' ? 'await-next-input' : 'inspect-turn-outcome', confidence: 1, scope: 'runtime' },
+    ]);
+  }
+
+  return {
+    startTurn,
+    recordRightsCheck,
+    endTurn,
+    read: () => store.read({ tenantId: tenant, agentId: agent }),
+    verify: () => store.verify({ tenantId: tenant, agentId: agent }),
+    close: () => store.close(),
+  };
+}
+
+function createRuntimeCognitiveTurnLifecycle({ home, agentName, runtimeId, now } = {}) {
+  const resolvedHome = String(home ?? '').trim();
+  const resolvedAgent = String(agentName ?? '').trim();
+  if (!resolvedHome || !resolvedAgent) fail('COGNITIVE_LIFECYCLE_INVALID');
+  return createCognitiveTurnLifecycle({
+    home: resolvedHome,
+    tenantId: digestId('home', [resolvedHome.toLowerCase()]),
+    agentId: digestId('agent', [resolvedAgent.toLowerCase()]),
+    runtimeId,
+    now,
+  });
+}
+
+module.exports = { createCognitiveTurnLifecycle, createRuntimeCognitiveTurnLifecycle };

package/blun.mjs

@@ -261391,7 +261391,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, 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, 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();
@@ -261411,6 +261411,7 @@ var init_turn = __esmMin((() => {
 	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	({ projectRecurringCronHistory } = createRequire(import.meta.url)("./bin/recurring-cron-history-policy.cjs"));
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
+	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.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;
 	BLUN_TELEGRAM_OUTBOUND_TOOL_RE = /^mcp__[^\s]*telegram[^\s]*__(?:reply|react|edit_message)$/i;
@@ -261471,6 +261472,8 @@ var init_turn = __esmMin((() => {
 		interruptedTelemetryTurnIds = /* @__PURE__ */ new Set();
 		stepFailureByTurn = /* @__PURE__ */ new Map();
 		currentStep = 0;
+		cognitiveLifecycle;
+		cognitiveLifecycleUnavailable = false;
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261478,6 +261481,33 @@ var init_turn = __esmMin((() => {
 		get agentId() {
 			return this.agent.homedir ? basename$2(this.agent.homedir) : this.agent.type;
 		}
+		getCognitiveLifecycle() {
+			if (this.cognitiveLifecycleUnavailable) return null;
+			if (this.cognitiveLifecycle !== void 0) return this.cognitiveLifecycle;
+			const home = this.agent.blunHomeDir ?? this.agent.homedir;
+			if (home === void 0) {
+				this.cognitiveLifecycleUnavailable = true;
+				return null;
+			}
+			try {
+				this.cognitiveLifecycle = createRuntimeCognitiveTurnLifecycle({
+					home,
+					agentName: this.agent.activeProfile?.name ?? this.agent.type
+				});
+				return this.cognitiveLifecycle;
+			} catch (error) {
+				this.cognitiveLifecycleUnavailable = true;
+				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: "open", error_type: error?.code ?? error?.name ?? "Error" });
+				return null;
+			}
+		}
+		recordCognitiveStage(method, input) {
+			try {
+				this.getCognitiveLifecycle()?.[method](input);
+			} catch (error) {
+				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: method, error_type: error?.code ?? error?.name ?? "Error" });
+			}
+		}
 		prompt(input, origin = USER_PROMPT_ORIGIN) {
 			return this.promptWithAcceptance(input, origin).turnId;
 		}
@@ -261805,6 +261835,12 @@ var init_turn = __esmMin((() => {
 				origin
 			});
 			this.agent.context.appendUserMessage(input, origin);
+			this.recordCognitiveStage("startTurn", { turnId, originKind: origin.kind });
+			this.recordCognitiveStage("recordRightsCheck", {
+				turnId,
+				decision: "not_applicable",
+				authority: "runtime_user_prompt_hook"
+			});
 			const ended = {
 				type: "turn.ended",
 				turnId,
@@ -261812,6 +261848,7 @@ var init_turn = __esmMin((() => {
 				durationMs: Date.now() - startedAt
 			};
 			this.agent.usage.endTurn();
+			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			return ended;
 		}
@@ -261841,6 +261878,7 @@ var init_turn = __esmMin((() => {
 				origin
 			});
 			this.agent.context.appendUserMessage(input, origin);
+			this.recordCognitiveStage("startTurn", { turnId, originKind: origin.kind });
 			const startedAt = Date.now();
 			let ended;
 			let blockedByUserPromptHook = false;
@@ -261848,6 +261886,11 @@ var init_turn = __esmMin((() => {
 			let errorEvent;
 			try {
 				const promptHookEnded = await this.applyUserPromptHook(turnId, input, origin, signal, startedAt);
+				this.recordCognitiveStage("recordRightsCheck", {
+					turnId,
+					decision: origin.kind !== "user" ? "not_applicable" : promptHookEnded?.blocked === true ? "blocked" : "passed",
+					authority: "runtime_user_prompt_hook"
+				});
 				if (promptHookEnded !== void 0) {
 					ended = promptHookEnded.event;
 					blockedByUserPromptHook = promptHookEnded.blocked;
@@ -261919,6 +261962,7 @@ var init_turn = __esmMin((() => {
 				mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
 				...this.requestProviderProps()
 			});
+			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			this.agent.endResponderTurn();
 			if (standalone && this.currentId === turnId && this.agent.goal.getGoal().goal?.status !== "active") this.activeTurn = null;

package/package.json

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