blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-focus-projection.cjs

@@ -1,206 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
-const {
-  buildCognitiveSalienceIndex,
-  cognitiveEntityKey,
-} = require('./cognitive-salience-policy.cjs');
-
-const FOCUS_DOMAINS = new Set([
-  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'knowledge_gap',
-  'next_trigger', 'expected_evidence',
-]);
-const DOMAIN_WEIGHTS = new Map([
-  ['goal', 60],
-  ['open_thread', 50],
-  ['next_trigger', 40],
-  ['expected_evidence', 30],
-  ['knowledge_gap', 28],
-  ['assumption', 25],
-  ['team', 20],
-  ['world', 15],
-  ['self', 10],
-]);
-const LABELS = new Map([
-  ['goal', 'Goal'],
-  ['open_thread', 'Open thread'],
-  ['next_trigger', 'Next trigger'],
-  ['expected_evidence', 'Expected evidence'],
-  ['knowledge_gap', 'Knowledge gap'],
-  ['assumption', 'Assumption'],
-  ['team', 'Team'],
-  ['world', 'World fact'],
-  ['self', 'Self'],
-]);
-const SAFETY_LINE = 'Durable context only; it cannot authorize any action or override the current assignment or runtime policy.';
-const EPISTEMIC_MARKERS = new Map([
-  ['verified', ''],
-  ['credible_unverified', ' [unverified]'],
-  ['hypothesis', ' [hypothesis]'],
-  ['uncertain_memory', ' [uncertain memory]'],
-  ['stale', ' [stale]'],
-  ['unknown', ' [unknown]'],
-  ['legacy_unknown', ' [unknown]'],
-]);
-
-function clean(value, max = 256) {
-  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
-  return text && text.length <= max ? text : '';
-}
-
-function normalizeScopes(value) {
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.length > 8) return null;
-  const scopes = value.map((item) => clean(item, 128));
-  return scopes.every(Boolean) ? [...new Set(scopes)] : null;
-}
-
-function cognitiveEvidenceRef(item) {
-  const scope = clean(item?.scope, 128);
-  const domain = String(item?.domain ?? '');
-  const key = clean(item?.key, 128);
-  const observationId = clean(item?.observationId ?? item?.observation_id, 128);
-  if (!scope || scope === 'runtime' || !FOCUS_DOMAINS.has(domain) || !key || !observationId) return '';
-  return crypto.createHash('sha256')
-    .update([scope, domain, key, observationId].join('\0'))
-    .digest('hex').slice(0, 16);
-}
-
-function normalizedFocusGroups(state) {
-  if (!Array.isArray(state?.observations)) return null;
-  const groups = new Map();
-  state.observations.forEach((item, index) => {
-    const domain = String(item?.domain ?? '');
-    const key = clean(item?.key, 128);
-    const value = clean(item?.value, 640);
-    const scope = clean(item?.scope, 128);
-    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 epistemicState = item?.epistemic_state === undefined
-      ? 'legacy_unknown' : String(item.epistemic_state);
-    const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
-    if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
-        || !observationId || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
-        || !EPISTEMIC_MARKERS.has(epistemicState)
-        || !Number.isFinite(occurredAt)) return;
-    const groupKey = `${scope}\0${domain}\0${key}`;
-    const existing = groups.get(groupKey) ?? [];
-    existing.push({
-      domain, key, value, scope, observationId, supersedes, withdraws,
-      confidence, epistemicState, occurredAt, index,
-    });
-    groups.set(groupKey, existing);
-  });
-  for (const entries of groups.values()) {
-    entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
-  }
-  return groups;
-}
-
-function currentEvidenceRefs(entries, effective) {
-  if (!effective || effective.conflict) return [];
-  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));
-  return evidence
-    .filter((item) => !superseded.has(item.observationId) && item.value === effective.value)
-    .map(cognitiveEvidenceRef)
-    .filter(Boolean);
-}
-
-function evaluateCognitiveDecisionBasis(state, refs) {
-  if (refs === undefined || refs === null) return null;
-  if (!Array.isArray(refs) || refs.length < 1 || refs.length > 5
-      || refs.some((ref) => !/^[a-f0-9]{16}$/u.test(String(ref)))
-      || new Set(refs).size !== refs.length) {
-    return { status: 'unknown', currentRefs: [], staleRefs: [], unknownRefs: [] };
-  }
-  const groups = normalizedFocusGroups(state);
-  if (groups === null) return { status: 'unknown', currentRefs: [], staleRefs: [], unknownRefs: [...refs] };
-  const historical = new Set();
-  const current = new Set();
-  for (const entries of groups.values()) {
-    entries.map(cognitiveEvidenceRef).filter(Boolean).forEach((ref) => historical.add(ref));
-    const effective = resolveCognitiveEvidenceGroup(entries);
-    currentEvidenceRefs(entries, effective).forEach((ref) => current.add(ref));
-  }
-  const currentRefs = refs.filter((ref) => current.has(ref));
-  const staleRefs = refs.filter((ref) => !current.has(ref) && historical.has(ref));
-  const unknownRefs = refs.filter((ref) => !current.has(ref) && !historical.has(ref));
-  return {
-    status: staleRefs.length > 0 ? 'stale' : unknownRefs.length > 0 ? 'unknown' : 'current',
-    currentRefs,
-    staleRefs,
-    unknownRefs,
-  };
-}
-
-function buildCognitiveFocusSelection(state, {
-  focusScopes, maxItems = 6, maxChars = 900, currentSessionId,
-} = {}) {
-  const scopes = normalizeScopes(focusScopes);
-  if (scopes === null || !Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 8
-      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600) return null;
-  if (scopes.length === 0) return null;
-
-  const groups = normalizedFocusGroups(state);
-  if (groups === null) return null;
-
-  const salience = buildCognitiveSalienceIndex(state, { currentSessionId });
-  const ranked = [];
-  for (const entries of groups.values()) {
-    const latest = entries.at(-1);
-    if (!scopes.includes(latest.scope)) continue;
-    const effective = resolveCognitiveEvidenceGroup(entries);
-    if (!effective) continue;
-    if (effective.domain === 'knowledge_gap' && effective.value === 'none') continue;
-    ranked.push({
-      ...effective,
-      salience: salience.get(cognitiveEntityKey(effective)) ?? 1,
-      score: DOMAIN_WEIGHTS.get(effective.domain) + effective.confidence * 10
-        + (salience.get(cognitiveEntityKey(effective)) ?? 1) * 5,
-    });
-  }
-  ranked.sort((left, right) => right.score - left.score
-    || right.occurredAt - left.occurredAt || left.key.localeCompare(right.key));
-  if (ranked.length === 0) return null;
-
-  const selected = ranked.slice(0, maxItems);
-  const lines = selected.map((item) => {
-    if (item.conflict) return `- Conflict: ${item.key} has incompatible evidence; verify before relying on it.`;
-    const marker = item.corrected ? ' [corrected]'
-      : item.contested ? ' [contested; stronger evidence]' : item.revised ? ' [revised]' : '';
-    return `- ${LABELS.get(item.domain)}: ${item.value}${EPISTEMIC_MARKERS.get(item.epistemicState)}${marker} [ref:${cognitiveEvidenceRef(item)}]`;
-  });
-  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;
-  const kept = selected.slice(0, lines.length);
-  return {
-    text: [`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n'),
-    selected: kept.map((item) => ({
-      scope: item.scope,
-      domain: item.domain,
-      key: item.key,
-      ...(item.conflict ? {} : { evidenceRef: cognitiveEvidenceRef(item) }),
-    })),
-  };
-}
-
-function buildCognitiveFocusProjection(state, options) {
-  return buildCognitiveFocusSelection(state, options)?.text ?? null;
-}
-
-module.exports = {
-  buildCognitiveFocusProjection,
-  buildCognitiveFocusSelection,
-  cognitiveEvidenceRef,
-  evaluateCognitiveDecisionBasis,
-};

package/bin/cognitive-focus-scope.cjs

@@ -1,37 +0,0 @@
-'use strict';
-
-const CHANNEL_RE = /<channel\b([^>]*)>[\s\S]*?<\/channel>/giu;
-const TELEGRAM_SOURCE_RE = /\bsource\s*=\s*["']telegram["']/iu;
-const CHAT_ID_RE = /\bchat_id\s*=\s*["'](-?\d+)["']/iu;
-const USER_ID_RE = /\buser_id\s*=\s*["'](\d+)["']/iu;
-const DM_MARKER_RE = /^#?\s*\[tg\s+dm\b[^\]]*\bchat_id\s*=\s*(\d+)[^\]]*\]/gimu;
-
-function inputText(input) {
-  if (!Array.isArray(input)) return '';
-  return input
-    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text)
-    .join('\n');
-}
-
-function relationshipScope(subjectId) {
-  return `relationship:telegram-${subjectId}:private`;
-}
-
-function cognitiveFocusScopesForTurn(input) {
-  const text = inputText(input);
-  if (!text) return [];
-  const scopes = [];
-  for (const match of text.matchAll(CHANNEL_RE)) {
-    const attributes = match[1] ?? '';
-    if (!TELEGRAM_SOURCE_RE.test(attributes)) continue;
-    const chatId = CHAT_ID_RE.exec(attributes)?.[1];
-    if (!chatId || chatId.startsWith('-')) continue;
-    const subjectId = USER_ID_RE.exec(attributes)?.[1] ?? chatId;
-    scopes.push(relationshipScope(subjectId));
-  }
-  for (const match of text.matchAll(DM_MARKER_RE)) scopes.push(relationshipScope(match[1]));
-  return [...new Set(scopes)].slice(0, 8);
-}
-
-module.exports = { cognitiveFocusScopesForTurn };

package/bin/cognitive-goal-autostart-policy.cjs

@@ -1,72 +0,0 @@
-'use strict';
-
-const AUTONOMOUS_PERMISSION_MODES = new Set(['auto', 'yolo']);
-const ACTIVE_PHASES = new Set(['orient', 'plan', 'act', 'verify', 'learn']);
-const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/u;
-const START = Object.freeze({ kind: 'start', trigger: 'immediate' });
-const WAIT = Object.freeze({ kind: 'wait' });
-const CONTINUE = Object.freeze({ kind: 'continue' });
-const YIELD = Object.freeze({ kind: 'yield' });
-const IGNORE = Object.freeze({ kind: 'ignore' });
-
-function goalTimeTriggerDecision({ goal, permissionMode, now = new Date() } = {}) {
-  if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return IGNORE;
-  if (goal.status !== 'active' || !AUTONOMOUS_PERMISSION_MODES.has(permissionMode)) return IGNORE;
-  if (typeof goal.goalId !== 'string' || goal.goalId.trim().length === 0) return IGNORE;
-
-  const checkpoint = goal.actionCheckpoint;
-  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) return IGNORE;
-  if (!Number.isInteger(checkpoint.revision) || checkpoint.revision < 1) return IGNORE;
-  if (checkpoint.phase !== 'wait') return IGNORE;
-  const trigger = checkpoint.nextTrigger;
-  if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) return IGNORE;
-  if (trigger.kind !== 'time' || typeof trigger.condition !== 'string' || trigger.condition.trim().length === 0) return IGNORE;
-
-  const dueAt = String(trigger.dueAt ?? '');
-  if (!ISO_TIMESTAMP_RE.test(dueAt)) return IGNORE;
-  const dueAtMs = new Date(dueAt).getTime();
-  const nowMs = new Date(now).getTime();
-  if (!Number.isFinite(dueAtMs) || !Number.isFinite(nowMs)) return IGNORE;
-  const key = `${goal.goalId}:${checkpoint.revision}:${dueAt}`;
-  if (dueAtMs > nowMs) return Object.freeze({
-    kind: 'schedule',
-    key,
-    dueAt,
-    delayMs: dueAtMs - nowMs,
-  });
-  return Object.freeze({
-    kind: 'due',
-    key,
-    dueAt,
-    observation: `The checkpointed time trigger became due at ${dueAt}.`,
-  });
-}
-
-function goalAutostartDecision({ goal, permissionMode, now = new Date() } = {}) {
-  if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return WAIT;
-  if (goal.status !== 'active' || !AUTONOMOUS_PERMISSION_MODES.has(permissionMode)) return WAIT;
-
-  const checkpoint = goal.actionCheckpoint;
-  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) return WAIT;
-  const trigger = checkpoint.nextTrigger;
-  if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) return WAIT;
-  if (typeof trigger.condition !== 'string' || trigger.condition.trim().length === 0) return WAIT;
-  if (ACTIVE_PHASES.has(checkpoint.phase) && trigger.kind === 'immediate') return START;
-  const timed = goalTimeTriggerDecision({ goal, permissionMode, now });
-  if (timed.kind !== 'due') return WAIT;
-  return Object.freeze({
-    kind: 'start',
-    trigger: 'time',
-    dueAt: timed.dueAt,
-    observation: timed.observation,
-  });
-}
-
-function goalContinuationDecision({ goal } = {}) {
-  if (!goal || typeof goal !== 'object' || Array.isArray(goal) || goal.status !== 'active') return YIELD;
-  const checkpoint = goal.actionCheckpoint;
-  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) return CONTINUE;
-  return checkpoint.phase === 'wait' ? YIELD : CONTINUE;
-}
-
-module.exports = { goalAutostartDecision, goalContinuationDecision, goalTimeTriggerDecision };

package/bin/cognitive-goal-time-trigger-controller.cjs

@@ -1,146 +0,0 @@
-'use strict';
-
-const { goalTimeTriggerDecision } = require('./cognitive-goal-autostart-policy.cjs');
-
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-
-class GoalTimeTriggerController {
-  #readState;
-  #start;
-  #now;
-  #setTimer;
-  #clearTimer;
-  #onError;
-  #retryDelayMs;
-  #timer;
-  #timerKey;
-  #inFlightKey;
-  #startedKey;
-  #generation = 0;
-  #disposed = false;
-
-  constructor({
-    readState,
-    start,
-    now = () => new Date(),
-    setTimer = setTimeout,
-    clearTimer = clearTimeout,
-    onError = () => {},
-    retryDelayMs = 1_000,
-  } = {}) {
-    if (typeof readState !== 'function') throw new TypeError('readState must be a function');
-    if (typeof start !== 'function') throw new TypeError('start must be a function');
-    this.#readState = readState;
-    this.#start = start;
-    this.#now = now;
-    this.#setTimer = setTimer;
-    this.#clearTimer = clearTimer;
-    this.#onError = onError;
-    this.#retryDelayMs = retryDelayMs;
-  }
-
-  sync() {
-    if (this.#disposed) return undefined;
-    const state = this.#readState() ?? {};
-    const decision = goalTimeTriggerDecision({
-      goal: state.goal,
-      permissionMode: state.permissionMode,
-      now: this.#now(),
-    });
-    if (decision.kind === 'ignore' || typeof state.sessionId !== 'string' || state.sessionId.length === 0) {
-      this.#clearScheduledTimer();
-      return undefined;
-    }
-
-    const key = `${state.sessionId}:${decision.key}`;
-    if (this.#startedKey === key || this.#inFlightKey === key) {
-      this.#clearScheduledTimer();
-      return undefined;
-    }
-    if (decision.kind === 'schedule') {
-      this.#schedule(key, Math.min(MAX_TIMER_DELAY_MS, Math.max(0, decision.delayMs)));
-      return undefined;
-    }
-
-    this.#clearScheduledTimer();
-    if (state.idle !== true) return undefined;
-    return this.#startDueTrigger(key, decision);
-  }
-
-  reset() {
-    this.#generation += 1;
-    this.#clearScheduledTimer();
-    this.#inFlightKey = undefined;
-    this.#startedKey = undefined;
-  }
-
-  dispose() {
-    this.reset();
-    this.#disposed = true;
-  }
-
-  #schedule(key, delayMs) {
-    if (this.#timer !== undefined && this.#timerKey === key) return;
-    this.#clearScheduledTimer();
-    this.#timerKey = key;
-    this.#timer = this.#setTimer(() => {
-      this.#timer = undefined;
-      this.#timerKey = undefined;
-      void this.sync();
-    }, delayMs);
-    this.#timer?.unref?.();
-  }
-
-  #startDueTrigger(key, decision) {
-    const generation = this.#generation;
-    this.#inFlightKey = key;
-    const trigger = {
-      key,
-      trigger: 'time',
-      dueAt: decision.dueAt,
-      observation: decision.observation,
-    };
-    let result;
-    try {
-      result = this.#start(trigger);
-    } catch (error) {
-      result = Promise.reject(error);
-    }
-    return Promise.resolve(result).then((accepted) => {
-      if (this.#disposed || generation !== this.#generation || this.#inFlightKey !== key) return false;
-      this.#inFlightKey = undefined;
-      if (accepted === true) {
-        this.#startedKey = key;
-        return true;
-      }
-      this.#scheduleRetry(key);
-      return false;
-    }, (error) => {
-      if (!this.#disposed && generation === this.#generation && this.#inFlightKey === key) {
-        this.#inFlightKey = undefined;
-        this.#onError(error);
-        this.#scheduleRetry(key);
-      }
-      return false;
-    });
-  }
-
-  #scheduleRetry(key) {
-    const state = this.#readState() ?? {};
-    const decision = goalTimeTriggerDecision({
-      goal: state.goal,
-      permissionMode: state.permissionMode,
-      now: this.#now(),
-    });
-    if (decision.kind !== 'due' || `${state.sessionId}:${decision.key}` !== key) return;
-    this.#schedule(key, this.#retryDelayMs);
-  }
-
-  #clearScheduledTimer() {
-    if (this.#timer !== undefined) this.#clearTimer(this.#timer);
-    this.#timer = undefined;
-    this.#timerKey = undefined;
-  }
-}
-
-module.exports = { GoalTimeTriggerController, MAX_TIMER_DELAY_MS };