blun-king-cli 9.1.301 → 9.1.302

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 { recordExplicitRelationshipCandidate } = require('./relationship-learning-policy.cjs');
 
 const MAX_FILE_BYTES = 64 * 1024;
 const DEFAULT_MAX_CHARS = 1500;
@@ -323,6 +324,15 @@ function recordChannelIdentity(envelope, env = process.env) {
     occurredAt: firstSeenAt,
   });
   if (firstSeenAt) recordInteractionActivity(root, agentId, actorId, firstSeenAt);
+  const learning = recordExplicitRelationshipCandidate({
+    root,
+    tenantId,
+    agentId,
+    actorId,
+    groupId,
+    text: envelope.text,
+    occurredAt: firstSeenAt,
+  });
   const journal = created.includes('relationship') && firstSeenAt
     ? recordIdentityJournalCandidate({
       kind: 'first_interaction',
@@ -341,6 +351,7 @@ function recordChannelIdentity(envelope, env = process.env) {
     actor_id: actorId,
     ...(groupId ? { group_id: groupId } : {}),
     created,
+    ...(learning ? { learning } : {}),
     ...(journal ? { journal } : {}),
     model_context: renderIdentityContext({
       root,

package/bin/relationship-learning-policy.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_VALUE_CHARS = 280;
+const EXPLICIT_PATTERNS = [
+  /^(?:bitte\s+)?merk(?:e)?\s+dir\s*(?::|,|\s+dass\s+)?\s*(.+)$/iu,
+  /^(?:please\s+)?remember(?:\s+that)?\s*(?::|,)?\s*(.+)$/iu,
+];
+const FORBIDDEN_RE = /\b(?:acl|admin|api[_ -]?key|capability|deploy|freigabe|passwor[dt]|permission|secret|token|write access|zugriffs?recht|du darfst|you may)\b/iu;
+
+function safeId(value) {
+  const normalized = String(value ?? '').trim();
+  return SAFE_ID_RE.test(normalized) ? normalized : '';
+}
+
+function isInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function readManifest(root) {
+  const target = path.join(root, 'manifest.json');
+  try {
+    const stat = fs.lstatSync(target);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_FILE_BYTES) return undefined;
+    const value = JSON.parse(fs.readFileSync(target, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function explicitValue(text) {
+  const normalized = String(text ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  for (const pattern of EXPLICIT_PATTERNS) {
+    const match = normalized.match(pattern);
+    const value = String(match?.[1] ?? '').trim().slice(0, MAX_VALUE_CHARS);
+    if (value.length >= 3 && !FORBIDDEN_RE.test(value)) return value;
+  }
+  return '';
+}
+
+function createJsonOnce(root, target, value) {
+  let handle;
+  try {
+    const parent = path.dirname(target);
+    fs.mkdirSync(parent, { recursive: true });
+    if (!isInside(root, fs.realpathSync(parent))) return false;
+    handle = fs.openSync(target, 'wx', 0o600);
+    fs.writeFileSync(handle, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    fs.fsyncSync(handle);
+    return true;
+  } catch (error) {
+    if (error?.code === 'EEXIST') return false;
+    return false;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+  }
+}
+
+function recordExplicitRelationshipCandidate(input = {}) {
+  if (input.groupId) return undefined;
+  const root = path.resolve(String(input.root ?? ''));
+  const tenantId = safeId(input.tenantId);
+  const agentId = safeId(input.agentId);
+  const actorId = safeId(input.actorId);
+  const occurredAt = String(input.occurredAt ?? '').trim();
+  const value = explicitValue(input.text);
+  if (!tenantId || !agentId || !actorId || !value || Number.isNaN(Date.parse(occurredAt))) return undefined;
+  try {
+    if (!fs.lstatSync(root).isDirectory() || fs.lstatSync(root).isSymbolicLink()) return undefined;
+    const realRoot = fs.realpathSync(root);
+    const manifest = readManifest(realRoot);
+    if (manifest?.version !== 1 || manifest.tenant_id !== tenantId || manifest.active_agent_id !== agentId) return undefined;
+    // The timestamp keeps later confirmations or contradictions as separate history,
+    // while an identical channel event remains idempotent on retry.
+    const identity = [tenantId, agentId, actorId, occurredAt, value].join('\0');
+    const candidateId = crypto.createHash('sha256').update(identity).digest('hex').slice(0, 32);
+    const target = path.resolve(realRoot, 'agents', agentId, 'relationship-candidates', `${candidateId}.json`);
+    if (!isInside(realRoot, target)) return undefined;
+    const candidate = {
+      version: 1,
+      candidate_id: candidateId,
+      status: 'pending',
+      kind: 'explicit_relationship_note',
+      tenant_id: tenantId,
+      agent_id: agentId,
+      actor_id: actorId,
+      value,
+      source: 'explicit_statement',
+      context: {
+        channel: 'telegram',
+        conversation: 'direct',
+      },
+      confidence: 1,
+      scope: 'agent_relationship',
+      history_policy: 'append_only',
+      occurred_at: occurredAt,
+    };
+    return { candidate_id: candidateId, created: createJsonOnce(realRoot, target, candidate) };
+  } catch {
+    return undefined;
+  }
+}
+
+module.exports = { recordExplicitRelationshipCandidate };

package/package.json

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