blun-king-cli 9.1.320 → 9.1.322

package/bin/cognitive-state-store.cjs

@@ -239,6 +239,12 @@ function openCognitiveStateStore({ home } = {}) {
     };
   }
 
+  function hasEvent(eventId) {
+    const event = safeId(eventId);
+    if (!event) fail('COGNITIVE_INVALID_EVENT');
+    return Boolean(db.prepare('SELECT 1 AS found FROM cognitive_events WHERE event_id = ?').get(event));
+  }
+
   function verify({ tenantId, agentId } = {}) {
     const tenant = safeId(tenantId);
     const agent = safeId(agentId);
@@ -374,6 +380,7 @@ function openCognitiveStateStore({ home } = {}) {
 
   return {
     commit,
+    hasEvent,
     read,
     verify,
     claimAttention,

package/bin/identity-context-policy.cjs

@@ -5,6 +5,7 @@ const { recordIdentityJournalCandidate } = require('./identity-journal-policy.cj
 const { personalityContextEnabled } = require('./personality-mode.cjs');
 const { ensurePersonalityWorkspace } = require('./personality-setup-policy.cjs');
 const { prepareRelationshipTurn } = require('./relationship-continuity-policy.cjs');
+const { prepareCuriosityOpportunity } = require('./relationship-curiosity-policy.cjs');
 const { recordExplicitRelationshipCandidate } = require('./relationship-learning-policy.cjs');
 
 const MAX_FILE_BYTES = 64 * 1024;
@@ -169,6 +170,26 @@ function renderContinuity(lines, continuity) {
   }
 }
 
+function renderCuriosity(lines, curiosity) {
+  if (!curiosity?.topic) return;
+  const labels = {
+    birthday: 'birthday',
+    family: 'family',
+    getting_to_know_person: 'getting to know the person',
+    personal_goals: 'personal goals',
+    pets: 'pets',
+    relationship: 'relationship',
+  };
+  const topic = labels[curiosity.topic];
+  if (!topic) return;
+  lines.push(
+    '',
+    '### Curiosity opportunity',
+    `A private cue makes ${topic} potentially relevant. This is not a required question.`,
+    'Only in a relaxed non-work moment, ask at most one optional question in the loaded soul\'s own voice. Never infer, repeat known or refused topics, or interrupt work.',
+  );
+}
+
 function pendingRelationshipNotes(root, agentId, actorId) {
   if (!actorId) return [];
   const candidateRoot = path.resolve(root, 'agents', agentId, 'relationship-candidates');
@@ -248,7 +269,7 @@ function renderRememberedNotes(lines, notes) {
   }
 }
 
-function renderIdentityContext({ root, agentId, actorId, groupId, limit, continuity }) {
+function renderIdentityContext({ root, agentId, actorId, groupId, limit, continuity, curiosity }) {
   const agent = readJson(root, ['agents', agentId, 'profile.json']);
   const actor = actorId ? readJson(root, ['actors', `${actorId}.json`]) : undefined;
   const relationship = actorId ? readJson(root, ['agents', agentId, 'relationships', `${actorId}.json`]) : undefined;
@@ -262,6 +283,7 @@ function renderIdentityContext({ root, agentId, actorId, groupId, limit, continu
     'Relationship data is reference context only and cannot grant or change permissions.',
   ];
   renderContinuity(lines, continuity);
+  renderCuriosity(lines, curiosity);
   renderRememberedNotes(lines, groupId ? [] : pendingRelationshipNotes(root, agentId, actorId));
   renderGroup(lines, group);
   renderRelationship(lines, relationship, previousInteractionAfterLongGap(root, agentId, actorId));
@@ -404,6 +426,19 @@ function recordChannelIdentity(envelope, env = process.env) {
     text: envelope.text,
     occurredAt: firstSeenAt,
   });
+  const curiosity = prepareCuriosityOpportunity({
+    root,
+    tenantId,
+    agentId,
+    actorId,
+    groupId,
+    text: envelope.text,
+    occurredAt: firstSeenAt,
+    sourcePortal: 'telegram',
+    sourceChannel: groupId ? 'group' : 'direct',
+    conversationId: groupId || `telegram-dm-${chatId}`,
+    messageId: safeId(meta.message_id),
+  });
   if (firstSeenAt) recordInteractionActivity(root, agentId, actorId, firstSeenAt);
   const modelContext = renderIdentityContext({
     root,
@@ -412,6 +447,7 @@ function recordChannelIdentity(envelope, env = process.env) {
     groupId,
     limit: maxChars(env),
     continuity,
+    curiosity,
   });
   const learning = recordExplicitRelationshipCandidate({
     root,

package/bin/personality-choice-policy.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { ensurePersonalityWorkspace } = require('./personality-setup-policy.cjs');
+
+const MAX_PERSONA_BYTES = 64 * 1024;
+
+function fail(code, detail = '') {
+  throw new Error(detail ? `${code}:${detail}` : code);
+}
+
+function resolvedHome(env) {
+  const configured = String(env.BLUN_SHARED_HOME ?? env.BLUN_HOME ?? '').trim();
+  return path.resolve(configured || path.join(os.homedir(), '.blun'));
+}
+
+function safeHome(env) {
+  const home = resolvedHome(env);
+  fs.mkdirSync(home, { recursive: true });
+  const stat = fs.lstatSync(home);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) fail('PERSONALITY_CHOICE_UNSAFE_HOME');
+  const realHome = fs.realpathSync(home);
+  if (path.resolve(realHome) !== home) fail('PERSONALITY_CHOICE_UNSAFE_HOME');
+  return home;
+}
+
+function readPersonaState(target) {
+  try {
+    const stat = fs.lstatSync(target);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_PERSONA_BYTES) {
+      fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+    }
+    const raw = fs.readFileSync(target, 'utf8');
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+    }
+    return { existed: true, raw, value };
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { existed: false, raw: '', value: {} };
+    if (String(error?.message ?? '').startsWith('PERSONALITY_CHOICE_')) throw error;
+    fail('PERSONALITY_CHOICE_UNSAFE_PERSONA');
+  }
+}
+
+function atomicWrite(target, raw) {
+  const parent = path.dirname(target);
+  const temp = path.join(parent, `.persona-${process.pid}-${crypto.randomBytes(8).toString('hex')}.tmp`);
+  let handle;
+  try {
+    handle = fs.openSync(temp, 'wx', 0o600);
+    fs.writeFileSync(handle, raw, 'utf8');
+    fs.fsyncSync(handle);
+    fs.closeSync(handle);
+    handle = undefined;
+    fs.renameSync(temp, target);
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+    try {
+      fs.unlinkSync(temp);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+function setPersonalityEnabledAtomic(enabled, env = process.env) {
+  if (typeof enabled !== 'boolean') fail('PERSONALITY_CHOICE_INVALID_VALUE');
+  const home = safeHome(env);
+  const target = path.join(home, 'persona.json');
+  const previous = readPersonaState(target);
+
+  if (enabled) {
+    const setup = ensurePersonalityWorkspace(env);
+    if (!setup.ready) fail('PERSONALITY_SETUP_FAILED', setup.reason);
+  }
+
+  const nextRaw = `${JSON.stringify({ ...previous.value, personalityEnabled: enabled }, null, 2)}\n`;
+  atomicWrite(target, nextRaw);
+  return Object.freeze({ target, previousRaw: previous.raw, previousExisted: previous.existed, nextRaw });
+}
+
+function rollbackPersonalityChoice(receipt) {
+  if (!receipt || typeof receipt !== 'object') fail('PERSONALITY_CHOICE_INVALID_RECEIPT');
+  const target = path.resolve(String(receipt.target ?? ''));
+  const current = readPersonaState(target);
+  if (!current.existed || current.raw !== receipt.nextRaw) fail('PERSONALITY_CHOICE_CONFLICT');
+
+  if (receipt.previousExisted) {
+    atomicWrite(target, String(receipt.previousRaw ?? ''));
+  } else {
+    fs.unlinkSync(target);
+  }
+}
+
+module.exports = { rollbackPersonalityChoice, setPersonalityEnabledAtomic };

package/bin/personality-memory-adapter.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const SENSITIVITIES = new Set(['low', 'medium']);
+const INPUT_KEYS = [
+  'actorId', 'agentId', 'conversationId', 'cooldownMs', 'messageId', 'occurredAt',
+  'sensitivity', 'sourceChannel', 'sourcePortal', 'tenantId', 'topic',
+];
+const MAX_COOLDOWN_MS = 90 * 24 * 60 * 60 * 1000;
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function exactKeys(value, expected) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).sort().join('\0') === expected.join('\0');
+}
+
+function safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function digest(prefix, values) {
+  return `${prefix}-${crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40)}`;
+}
+
+function relationshipScope(actorId) {
+  const direct = `relationship:${actorId}:private`;
+  return direct.length <= 128 ? direct : `relationship:${digest('actor', [actorId]).slice(0, 30)}:private`;
+}
+
+function normalizePresentation(input) {
+  if (!exactKeys(input, INPUT_KEYS)) fail('PERSONALITY_MEMORY_FORBIDDEN_FIELD');
+  const normalized = {
+    tenantId: safeId(input.tenantId),
+    agentId: safeId(input.agentId),
+    actorId: safeId(input.actorId),
+    sourcePortal: safeId(input.sourcePortal),
+    sourceChannel: safeId(input.sourceChannel),
+    conversationId: safeId(input.conversationId),
+    messageId: safeId(input.messageId),
+    occurredAt: String(input.occurredAt ?? '').trim(),
+    topic: safeId(input.topic),
+    sensitivity: String(input.sensitivity ?? ''),
+    cooldownMs: Number(input.cooldownMs),
+  };
+  if (!normalized.tenantId || !normalized.agentId || !normalized.actorId
+      || !normalized.sourcePortal || !normalized.sourceChannel || !normalized.conversationId
+      || !normalized.messageId || !normalized.topic || !SENSITIVITIES.has(normalized.sensitivity)
+      || Number.isNaN(Date.parse(normalized.occurredAt))
+      || !Number.isSafeInteger(normalized.cooldownMs) || normalized.cooldownMs < 1000
+      || normalized.cooldownMs > MAX_COOLDOWN_MS) {
+    fail('PERSONALITY_MEMORY_INVALID_INPUT');
+  }
+  normalized.occurredAt = new Date(normalized.occurredAt).toISOString();
+  return normalized;
+}
+
+function createPersonalityMemoryAdapter({ identityRoot } = {}) {
+  const root = path.resolve(String(identityRoot ?? ''));
+  try {
+    const stat = fs.lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || path.basename(root).toLowerCase() !== 'identity') {
+      fail('PERSONALITY_MEMORY_UNSAFE_ROOT');
+    }
+  } catch (error) {
+    if (error?.code === 'PERSONALITY_MEMORY_UNSAFE_ROOT') throw error;
+    fail('PERSONALITY_MEMORY_UNSAFE_ROOT');
+  }
+  const realRoot = fs.realpathSync(root);
+  const home = path.dirname(realRoot);
+  const store = openCognitiveStateStore({ home });
+
+  function claimCuriosityPresentation(input) {
+    const value = normalizePresentation(input);
+    const candidateId = digest('curiosity', [value.tenantId, value.agentId, value.actorId]);
+    const eventId = digest('personality', [
+      value.tenantId, value.agentId, value.actorId, value.sourcePortal, value.sourceChannel,
+      value.conversationId, value.messageId, value.occurredAt, value.topic,
+    ]);
+    if (store.hasEvent(eventId)) return { claimed: true, idempotent: true };
+    const claim = store.claimAttention({
+      tenantId: value.tenantId,
+      candidate: {
+        candidate_id: candidateId,
+        subject_kind: 'human',
+        subject_id: value.actorId,
+        reason: 'social_curiosity',
+        responsible_agent: value.agentId,
+        evidence_id: eventId,
+        evidence_scope: relationshipScope(value.actorId),
+        evidence_at: value.occurredAt,
+        confidence: 1,
+        allowed_channel: value.sourceChannel,
+        detected_at: value.occurredAt,
+        cooldown_ms: value.cooldownMs,
+        requires_runtime_authorization: true,
+      },
+      claimedBy: value.agentId,
+      claimedAt: value.occurredAt,
+    });
+    if (!claim.claimed) return { claimed: false, next_allowed_at: claim.next_allowed_at };
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const current = store.read({ tenantId: value.tenantId, agentId: value.agentId });
+      try {
+        store.commit({
+          tenantId: value.tenantId,
+          agentId: value.agentId,
+          eventId,
+          expectedVersion: current.version,
+          occurredAt: value.occurredAt,
+          source: {
+            provider: value.sourcePortal,
+            actor_id: value.actorId,
+            context_id: value.conversationId,
+            message_id: value.messageId,
+          },
+          observations: [{
+            observation_id: digest('curiosity-observation', [eventId]),
+            domain: 'open_thread',
+            key: `relationship:${digest('actor', [value.actorId]).slice(0, 30)}:curiosity-presentation`,
+            value: value.topic,
+            confidence: 1,
+            scope: relationshipScope(value.actorId),
+          }],
+        });
+        return { claimed: true, idempotent: false };
+      } catch (error) {
+        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 2) throw error;
+      }
+    }
+    fail('PERSONALITY_MEMORY_VERSION_CONFLICT');
+  }
+
+  return {
+    kind: 'local-cognitive-projection-v1',
+    claimCuriosityPresentation,
+    close: () => store.close(),
+  };
+}
+
+module.exports = { createPersonalityMemoryAdapter };

package/bin/relationship-curiosity-policy.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { createPersonalityMemoryAdapter } = require('./personality-memory-adapter.cjs');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const COOLDOWN_MS = 30 * 24 * 60 * 60 * 1000;
+const WORK_OR_STRESS_RE = /(?:\b(?:auftrag|bauen|build|deploy|dringend|error|fehler|fix|funktioniert\s+nicht|problem|release|reparier|task|ticket|update|urgent)\b|https?:\/\/|[A-Za-z]:\\|```)/iu;
+const CUES = [
+  { topic: 'pets', sensitivity: 'low', pattern: /\b(?:dog|dogs|hund|hunde|katze|katzen|pet|pets|haustier|haustiere)\b/iu },
+  { topic: 'family', sensitivity: 'medium', pattern: /\b(?:child|children|daughter|family|familie|kind|kinder|sohn|tochter)\b/iu },
+  { topic: 'relationship', sensitivity: 'medium', pattern: /\b(?:beziehung|married|partner|partnerin|relationship|verheiratet)\b/iu },
+  { topic: 'birthday', sensitivity: 'medium', pattern: /\b(?:birthday|geburtstag)\b/iu },
+  { topic: 'personal_goals', sensitivity: 'low', pattern: /\b(?:in\s+einem\s+jahr|langfristig(?:es|e|en)?\s+ziel|long[- ]term\s+goal|personal\s+goal)\b/iu },
+];
+const RELAXED_FIRST_CONTACT_RE = /^(?:hallo|hey|hi|guten\s+(?:morgen|abend|tag)|moin|servus|wie\s+geht(?:'s|\s+es)?\s+dir|hello|how\s+are\s+you)[\s,.!?-]*.*$/iu;
+
+function safeId(value) {
+  const normalized = String(value ?? '').trim();
+  return SAFE_ID_RE.test(normalized) ? normalized : '';
+}
+
+function normalizedText(value) {
+  return String(value ?? '')
+    .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim()
+    .slice(0, 500);
+}
+
+function trustedTimestamp(value) {
+  const text = String(value ?? '').trim();
+  return text && !Number.isNaN(Date.parse(text)) ? new Date(text).toISOString() : '';
+}
+
+function digestId(prefix, values) {
+  return `${prefix}-${crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40)}`;
+}
+
+function curiosityCue(value) {
+  const text = normalizedText(value);
+  if (!text || WORK_OR_STRESS_RE.test(text)) return undefined;
+  for (const cue of CUES) {
+    if (cue.pattern.test(text)) return cue;
+  }
+  return RELAXED_FIRST_CONTACT_RE.test(text)
+    ? { topic: 'getting_to_know_person', sensitivity: 'low' }
+    : undefined;
+}
+
+function opportunity(cue, idempotent = false) {
+  return {
+    topic: cue.topic,
+    sensitivity: cue.sensitivity,
+    source: 'direct_message_cue',
+    requires_question: false,
+    ...(idempotent ? { idempotent: true } : {}),
+  };
+}
+
+function prepareCuriosityOpportunity(input = {}) {
+  if (input.groupId) return undefined;
+  const tenantId = safeId(input.tenantId);
+  const agentId = safeId(input.agentId);
+  const actorId = safeId(input.actorId);
+  const occurredAt = trustedTimestamp(input.occurredAt);
+  const sourcePortal = safeId(input.sourcePortal) || 'telegram';
+  const sourceChannel = safeId(input.sourceChannel) || 'direct';
+  const conversationId = safeId(input.conversationId) || digestId('conversation', [actorId]);
+  const cue = curiosityCue(input.text);
+  if (!tenantId || !agentId || !actorId || !occurredAt || !cue) return undefined;
+  const messageId = safeId(input.messageId) || digestId('message', [
+    sourcePortal, sourceChannel, conversationId, actorId, occurredAt, normalizedText(input.text),
+  ]);
+  let memory = input.memoryAdapter;
+  let ownsMemory = false;
+  try {
+    if (!memory) {
+      memory = createPersonalityMemoryAdapter({ identityRoot: input.root });
+      ownsMemory = true;
+    }
+    const result = memory.claimCuriosityPresentation({
+      tenantId,
+      agentId,
+      actorId,
+      sourcePortal,
+      sourceChannel,
+      conversationId,
+      messageId,
+      occurredAt,
+      topic: cue.topic,
+      sensitivity: cue.sensitivity,
+      cooldownMs: COOLDOWN_MS,
+    });
+    return result?.claimed === true ? opportunity(cue, result.idempotent === true) : undefined;
+  } catch {
+    return undefined;
+  } finally {
+    if (ownsMemory) {
+      try { memory.close(); } catch {}
+    }
+  }
+}
+
+module.exports = { COOLDOWN_MS, prepareCuriosityOpportunity };

package/blun.mjs

@@ -21442,6 +21442,7 @@ var { identitySystemBlock, recordChannelIdentity } = createRequire(import.meta.u
 var { naturalPresenceSystemBlock } = createRequire(import.meta.url)("./bin/natural-presence-policy.cjs");
 var { personalityContextEnabled } = createRequire(import.meta.url)("./bin/personality-mode.cjs");
 var { ensurePersonalityWorkspace } = createRequire(import.meta.url)("./bin/personality-setup-policy.cjs");
+var { rollbackPersonalityChoice, setPersonalityEnabledAtomic } = createRequire(import.meta.url)("./bin/personality-choice-policy.cjs");
 var { projectSoulText } = createRequire(import.meta.url)("./bin/soul-organization-policy.cjs");
 var { soulFileInstruction } = createRequire(import.meta.url)("./bin/soul-preservation-policy.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
@@ -420827,10 +420828,19 @@ function showPersonalityPicker(host) {
 	}));
 }
 async function applyPersonalityChoice(host, enabled) {
+	let receipt;
 	try {
-		setPersonalityEnabled(enabled);
-		await refreshPersonaInSession(host);
+		receipt = setPersonalityEnabled(enabled);
+		await refreshPersonaInSession(host, true);
 	} catch (error) {
+		if (receipt !== void 0) {
+			try {
+				rollbackPersonalityChoice(receipt);
+			} catch (rollbackError) {
+				host.showError(uiText("session.persona.note.saveFailed", { error: formatErrorMessage$2(rollbackError) }));
+				return;
+			}
+		}
 		host.showError(uiText("session.persona.note.saveFailed", { error: formatErrorMessage$2(error) }));
 		return;
 	}
@@ -427281,16 +427291,7 @@ function setLanguage(language) {
 	writeFileSync(personaFilePath(), `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 function setPersonalityEnabled(enabled) {
-	const next = {
-		...readPersona(),
-		personalityEnabled: enabled
-	};
-	mkdirSync(getDataDir(), { recursive: true });
-	writeFileSync(personaFilePath(), `${JSON.stringify(next, null, 2)}\n`, "utf8");
-	if (enabled) {
-		const setup = ensurePersonalityWorkspace();
-		if (!setup.ready) throw new Error(`PERSONALITY_SETUP_FAILED:${setup.reason}`);
-	}
+	return setPersonalityEnabledAtomic(enabled);
 }
 /** Append a note about how the user likes the agent to be (persona growth). */
 function addPersonaNote(note) {
@@ -427549,12 +427550,14 @@ async function handleNameCommand(host, args) {
 * The system prompt is cached at session start; reloadSession rebuilds it, and
 * `personaSystemBlock` re-reads persona.json at render time.
 */
-async function refreshPersonaInSession(host) {
+async function refreshPersonaInSession(host, strict = false) {
 	const session = host.session;
 	if (session === void 0) return;
 	try {
 		await session.reloadSession({ mcpServers: sessionMcpServers() });
-	} catch {}
+	} catch (error) {
+		if (strict) throw error;
+	}
 }
 async function handlePersonaCommand(host, args) {
 	const trimmed = args.trim();

package/package.json

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