blun-king-cli 9.1.567 → 9.1.569

package/bin/managed-context-startup-policy.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+const MANAGED_CONTEXT_MISMATCH = 'Runtime model context does not match the configured internal BLUN model.';
+
+function isManagedContextStartupRace(error) {
+  return error?.code === 'CONFIG_INVALID' && error?.message === MANAGED_CONTEXT_MISMATCH;
+}
+
+async function bindManagedContextWithRetry(options) {
+  const delaysMs = Array.isArray(options?.delaysMs) ? options.delaysMs : [100, 300];
+  const wait = options?.wait || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await options.bind();
+    } catch (error) {
+      if (!isManagedContextStartupRace(error) || attempt >= delaysMs.length) throw error;
+      await options.refresh();
+      await wait(delaysMs[attempt]);
+    }
+  }
+}
+
+module.exports = {
+  MANAGED_CONTEXT_MISMATCH,
+  bindManagedContextWithRetry,
+  isManagedContextStartupRace,
+};

package/bin/managed-plugin-selection.cjs

@@ -0,0 +1,116 @@
+'use strict';
+const { createHash, randomUUID } = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { ensurePrivateDirectory, securePrivateTree } = require('./private-paths');
+const SCHEMA = 'blun.managed-plugin-selection/v1';
+
+function snapshotPluginTree(root) {
+  const entries = [];
+  const rootStat = fs.lstatSync(root);
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return null;
+  const visit = (directory, relativeDirectory = '') => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
+      .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)) {
+      const relativePath = path.join(relativeDirectory, entry.name);
+      const absolutePath = path.join(directory, entry.name);
+      const stat = fs.lstatSync(absolutePath);
+      if (stat.isSymbolicLink()) return false;
+      if (stat.isDirectory()) {
+        entries.push({ kind: 'directory', path: relativePath });
+        if (!visit(absolutePath, relativePath)) return false;
+      } else if (stat.isFile()) {
+        entries.push({ kind: 'file', path: relativePath, content: fs.readFileSync(absolutePath) });
+      } else return false;
+    }
+    return true;
+  };
+  return visit(root) ? entries : null;
+}
+
+function digestPluginEntries(entries) {
+  if (entries === null) throw new Error('Invalid managed plugin tree');
+  const hash = createHash('sha256');
+  for (const entry of entries) {
+    hash.update(Buffer.from(`${entry.kind}\0${entry.path}\0`, 'utf8'));
+    if (entry.kind === 'file') {
+      const length = Buffer.allocUnsafe(8);
+      length.writeBigUInt64BE(BigInt(entry.content.length));
+      hash.update(length);
+      hash.update(entry.content);
+    }
+  }
+  return hash.digest('hex');
+}
+
+function samePath(left, right) {
+  const normalize = value => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value);
+  return normalize(left) === normalize(right);
+}
+
+function scopedPluginRoot(blunDir, pluginRoot) {
+  const managed = path.resolve(blunDir, 'plugins', 'managed');
+  const root = path.resolve(pluginRoot);
+  if (!samePath(path.dirname(root), managed)) throw new Error('Selected AgentSpine root is outside this profile');
+  for (const directory of [blunDir, path.dirname(managed), managed, root]) {
+    const stat = fs.lstatSync(directory);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error('Selected AgentSpine root contains a linked directory');
+  }
+  if (!samePath(path.dirname(fs.realpathSync(root)), fs.realpathSync(managed))) {
+    throw new Error('Selected AgentSpine root resolves outside this profile');
+  }
+  return root;
+}
+
+function describeAgentSpineSelection({ blunDir, pluginRoot }) {
+  const root = scopedPluginRoot(blunDir, pluginRoot);
+  const digest = digestPluginEntries(snapshotPluginTree(root));
+  if (path.basename(root) !== `agent-spine-${digest}`) throw new Error('Selected AgentSpine digest mismatch');
+  return { schema: SCHEMA, digest };
+}
+
+function selectedAgentSpineRoot({ installed, blunDir }) {
+  const records = installed.plugins.filter(record => record.id === 'agent-spine');
+  if (!records.some(record => Object.hasOwn(record, 'managedSelection'))) return null;
+  if (records.length !== 1) throw new Error('Ambiguous AgentSpine selection');
+  const [record] = records;
+  const selection = record.managedSelection;
+  if (!selection || selection.schema !== SCHEMA || !/^[a-f0-9]{64}$/.test(selection.digest || '')
+    || Object.keys(selection).sort().join(',') !== 'digest,schema' || typeof record.root !== 'string') {
+    throw new Error('Invalid AgentSpine selection');
+  }
+  const actual = describeAgentSpineSelection({ blunDir, pluginRoot: record.root });
+  if (actual.digest !== selection.digest) throw new Error('Selected AgentSpine digest mismatch');
+  return record.root;
+}
+
+function copySelectedAgentSpinePlugin({ blunDir, sourceRoot }) {
+  const plugins = path.resolve(blunDir, 'plugins');
+  const managed = path.join(plugins, 'managed');
+  ensurePrivateDirectory(plugins);
+  ensurePrivateDirectory(managed);
+  // Explicit installs must see current source bytes, not the bundled-source cache.
+  const digest = digestPluginEntries(snapshotPluginTree(sourceRoot));
+  const pluginRoot = path.join(managed, `agent-spine-${digest}`);
+  if (fs.existsSync(pluginRoot)) {
+    describeAgentSpineSelection({ blunDir, pluginRoot });
+    return pluginRoot;
+  }
+  const staging = path.join(managed, `.agent-spine-selected-${process.pid}-${randomUUID()}.tmp`);
+  try {
+    fs.cpSync(sourceRoot, staging, { recursive: true, errorOnExist: true, force: false });
+    securePrivateTree(staging);
+    if (digestPluginEntries(snapshotPluginTree(staging)) !== digest) throw new Error('AgentSpine source changed during installation');
+    fs.renameSync(staging, pluginRoot);
+    describeAgentSpineSelection({ blunDir, pluginRoot });
+    return pluginRoot;
+  } finally {
+    if (!samePath(path.dirname(staging), managed) || !path.basename(staging).startsWith('.agent-spine-selected-')) {
+      throw new Error('Invalid AgentSpine staging cleanup path');
+    }
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+module.exports = { snapshotPluginTree, digestPluginEntries, describeAgentSpineSelection,
+  selectedAgentSpineRoot, copySelectedAgentSpinePlugin };

package/bin/mistake-relevance-policy.cjs

@@ -32,7 +32,7 @@ const SEMANTIC_SIGNAL_RULES = Object.freeze([
   ['problem:protocol', /\b(?:schema|contract|payload|protocol|format|version mismatch|manifest mismatch|vertrag|protokoll|versionskonflikt)\b/iu],
   ['problem:capability', /\b(?:capabilit\w*|missing tool|not available|unsupported|fahigkeit\w*|werkzeug fehlt|nicht verfugbar)\b/iu],
   ['area:orchestration', /\b(?:agent\w*|worker\w*|queue\w*|checkpoint\w*|heartbeat\w*|delegat\w*|owner\w*|responsib\w*|task\w*|turn\w*|busy|group\w*|channel\w*|arbeiter\w*|warteschlange\w*|prufpunkt\w*|herzschlag\w*|zustandig\w*|auftrag\w*|zug\w*|beschaftigt|gruppe\w*|gruppen\w*|kanal\w*)\b/iu],
-  ['area:memory', /\b(?:memory|recall|remember\w*|context|history|resume|checkpoint|mnemo|gedachtnis|erinner\w*|kontext|verlauf|wiederaufnahme)\b/iu],
+  ['area:memory', /\b(?:memory|recall|remember\w*|context|history|resume|checkpoint|gedachtnis|erinner\w*|kontext|verlauf|wiederaufnahme)\b/iu],
   ['area:release', /\b(?:release\w*|rollout\w*|update\w*|updater\w*|npm|package\w*|manifest\w*|version\w*|veroffentlich\w*|paket\w*|integrity|integritat)\b/iu],
   ['area:media', /\b(?:image\w*|video\w*|audio\w*|portrait\w*|render\w*|pixel\w*|media|bild\w*|foto\w*|gesicht\w*|stimme\w*)\b/iu],
   ['risk:validation', /\b(?:verif\w*|validat\w*|test\w*|check\w*|gate\w*|rollback\w*|canary|proof|evidence|sha(?:256|512)?|measur\w*|inspect\w*|(?:ge)?pruf\w*|gegenprobe\w*|beleg\w*|evidenz\w*|mess\w*|kontroll\w*)\b/iu],

package/bin/observer-hooks.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+async function runHookPhases(hooks, run, signal) {
+  const regular = hooks.filter(hook => hook.observer !== true);
+  const results = await Promise.all(regular.map(run));
+  // A fail-open guard error is not proof that the event was accepted.
+  if (signal?.aborted || results.some(result => result.action === 'block'
+      || result.timedOut === true || result.exitCode !== 0)) return results;
+  await Promise.allSettled(hooks.filter(hook => hook.observer === true).map(run));
+  // Observers have no authority to deny work or add instructions to the agent.
+  return results;
+}
+
+module.exports = { runHookPhases };

package/bin/oversized-context-offload-policy.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+const OVERSIZED_CONTEXT_MESSAGE_MAX_CHARS = 200_000;
+const OVERSIZED_CONTEXT_TOOL_RESULT_MAX_CHARS = 200_000;
+
+function textContent(message) {
+  if (!Array.isArray(message?.content)) return undefined;
+  const textParts = message.content.filter(
+    (part) => part?.type === 'text' && typeof part.text === 'string',
+  );
+  if (textParts.length === 0) return undefined;
+  return textParts.map((part) => part.text).join('\n');
+}
+
+function oversizedItemKind(message) {
+  if (message?.role === 'tool') return 'tool-result';
+  if (message?.role === 'user') return 'user-message';
+  if (message?.role === 'assistant') return 'assistant-message';
+  return undefined;
+}
+
+function oversizedItemLimit(kind) {
+  return kind === 'tool-result'
+    ? OVERSIZED_CONTEXT_TOOL_RESULT_MAX_CHARS
+    : OVERSIZED_CONTEXT_MESSAGE_MAX_CHARS;
+}
+
+async function projectOversizedContextItems(messages, options = {}) {
+  if (!Array.isArray(messages) || typeof options.persistItem !== 'function') {
+    return {
+      messages,
+      offloadedCount: 0,
+      charsBefore: 0,
+      charsAfter: 0,
+      interventions: [],
+    };
+  }
+
+  const projected = messages.slice();
+  const interventions = [];
+  let charsBefore = 0;
+  let charsAfter = 0;
+
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    const kind = oversizedItemKind(message);
+    if (kind === undefined) continue;
+    const text = textContent(message);
+    if (text === undefined || text.length < oversizedItemLimit(kind)) continue;
+
+    const replacement = await options.persistItem({ index, kind, message, text });
+    if (!Array.isArray(replacement?.content)) continue;
+    const replacementChars = textContent({ content: replacement.content })?.length;
+    if (!Number.isSafeInteger(replacementChars) || replacementChars >= text.length) continue;
+
+    projected[index] = {
+      ...message,
+      content: replacement.content,
+    };
+    charsBefore += text.length;
+    charsAfter += replacementChars;
+    interventions.push({
+      index,
+      kind,
+      charsBefore: text.length,
+      charsAfter: replacementChars,
+      ...(typeof replacement.outputPath === 'string'
+        ? { outputPath: replacement.outputPath }
+        : {}),
+    });
+  }
+
+  return {
+    messages: interventions.length === 0 ? messages : projected,
+    offloadedCount: interventions.length,
+    charsBefore,
+    charsAfter,
+    interventions,
+  };
+}
+
+module.exports = {
+  OVERSIZED_CONTEXT_MESSAGE_MAX_CHARS,
+  OVERSIZED_CONTEXT_TOOL_RESULT_MAX_CHARS,
+  projectOversizedContextItems,
+};

package/bin/plugin-bootstrap.js

@@ -1,8 +1,9 @@
 'use strict';
 
-const { createHash, randomUUID } = require('node:crypto');
+const { randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
+const { snapshotPluginTree, digestPluginEntries, selectedAgentSpineRoot } = require('./managed-plugin-selection.cjs');
 
 const {
   ensurePrivateDirectory,
@@ -17,33 +18,6 @@ function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-function snapshotPluginTree(root) {
-  const entries = [];
-  const visit = (directory, relativeDirectory = '') => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
-      .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)) {
-      const relativePath = path.join(relativeDirectory, entry.name);
-      const absolutePath = path.join(directory, entry.name);
-      const stat = fs.lstatSync(absolutePath);
-      if (stat.isSymbolicLink()) return false;
-      if (stat.isDirectory()) {
-        entries.push({ kind: 'directory', path: relativePath });
-        if (!visit(absolutePath, relativePath)) return false;
-      } else if (stat.isFile()) {
-        entries.push({
-          kind: 'file',
-          path: relativePath,
-          content: fs.readFileSync(absolutePath),
-        });
-      } else {
-        return false;
-      }
-    }
-    return true;
-  };
-  return visit(root) ? entries : null;
-}
-
 function snapshotManagedPluginSource(root) {
   const resolvedRoot = path.resolve(root);
   const cacheKey = process.platform === 'win32' ? resolvedRoot.toLowerCase() : resolvedRoot;
@@ -72,18 +46,7 @@ function pluginTreesAreIdentical(sourceRoot, pluginRoot) {
 function pluginTreeDigest(root) {
   const entries = snapshotManagedPluginSource(root);
   if (entries === null) throw new Error(`Invalid managed plugin tree: ${root}`);
-  const hash = createHash('sha256');
-  for (const entry of entries) {
-    const metadata = Buffer.from(`${entry.kind}\0${entry.path}\0`, 'utf8');
-    hash.update(metadata);
-    if (entry.kind === 'file') {
-      const length = Buffer.allocUnsafe(8);
-      length.writeBigUInt64BE(BigInt(entry.content.length));
-      hash.update(length);
-      hash.update(entry.content);
-    }
-  }
-  return hash.digest('hex');
+  return digestPluginEntries(entries);
 }
 
 function hasCurrentPluginRecord(installed, pluginRoot, pluginId, mcpServerName) {
@@ -179,6 +142,10 @@ function installManagedPlugin({
   if (fs.existsSync(installedFile)) securePrivateFile(installedFile);
   const installed = readInstalledPlugins(installedFile);
   ensurePrivateDirectory(managedDir);
+  if (pluginId === 'agent-spine') {
+    const selected = selectedAgentSpineRoot({ installed, blunDir });
+    if (selected) return { installedFile, pluginRoot: selected, reused: true, selected: true };
+  }
   if (fs.existsSync(legacyPluginRoot)
     && pluginTreesAreIdentical(sourceRoot, legacyPluginRoot)) {
     if (!hasCurrentPluginRecord(installed, legacyPluginRoot, pluginId, mcpServerName)) {

package/bin/proactive-compaction-policy.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const PROACTIVE_COMPACTION_TRIGGER_FRACTION = 0.5;
+const PROACTIVE_COMPACTION_TRIGGER_FRACTION = 0.9;
 
 function proactiveCompactionEligibility({ usedTokens, budgetTokens, hasShrinkableHistory, isCompacting }) {
   const budget = Number(budgetTokens);

package/bin/provider-model-refresh-deadline.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+const DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS = 10_000;
+
+function providerModelRefreshAbortError(timedOut = false, cause) {
+  const error = new Error(timedOut ? 'Model catalog refresh timed out.' : 'Model catalog refresh was cancelled.', { cause });
+  error.code = timedOut ? 'PROVIDER_MODEL_REFRESH_TIMEOUT' : 'PROVIDER_MODEL_REFRESH_ABORTED';
+  return error;
+}
+
+function isProviderModelReadInterrupted(error) {
+  return error?.code === 'PROVIDER_MODEL_REFRESH_TIMEOUT' || error?.code === 'PROVIDER_MODEL_REFRESH_ABORTED';
+}
+
+// Bound only remote reads. The caller must await any config commit it has started.
+function withProviderModelReadDeadline(operation, options = {}) {
+  const { signal, timeoutMs = DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS } = options;
+  if (signal?.aborted) return Promise.reject(providerModelRefreshAbortError(false, signal.reason));
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647) {
+    return Promise.reject(new RangeError('Invalid provider model read timeout.'));
+  }
+  const controller = new AbortController();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    const finish = (complete, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      complete(value);
+    };
+    const abort = (timedOut) => {
+      const error = providerModelRefreshAbortError(timedOut, signal?.reason);
+      controller.abort(error);
+      finish(reject, error);
+    };
+    const onAbort = () => abort(false);
+    signal?.addEventListener('abort', onAbort, { once: true });
+    timer = setTimeout(() => abort(true), timeoutMs);
+    if (signal?.aborted) onAbort();
+    Promise.resolve().then(() => {
+      controller.signal.throwIfAborted();
+      return operation(controller.signal);
+    }).then(
+      (value) => controller.signal.aborted ? finish(reject, controller.signal.reason) : finish(resolve, value),
+      (error) => finish(reject, error),
+    );
+  });
+}
+
+module.exports = { DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS, providerModelRefreshAbortError,
+  isProviderModelReadInterrupted, withProviderModelReadDeadline };

package/bin/provider-model-refresh-policy.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const path = require('node:path');
+const { isDeepStrictEqual } = require('node:util');
+const providerId = 'managed:blun';
+const serviceKeys = ['blunSearch', 'blunFetch', 'blunMedia'];
+const writers = new Map();
+const jsonCopy = (value) => JSON.parse(JSON.stringify(value));
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+function providerModelRefreshSnapshot(config) {
+  return jsonCopy({
+    provider: config.providers?.[providerId] ?? null,
+    models: Object.fromEntries(Object.entries(config.models ?? {}).filter(([, model]) => model?.provider === providerId)),
+    defaultModel: config.defaultModel ?? null,
+    thinkingEnabled: config.thinking?.enabled ?? null,
+    services: Object.fromEntries(serviceKeys.map((key) => [key, config.services?.[key] ?? null])),
+  });
+}
+
+function exactKeys(value, keys) {
+  return record(value) && isDeepStrictEqual(Object.keys(value).sort(), [...keys].sort());
+}
+
+function checkCredentials(value) {
+  if (value?.oauth != null && (value.apiKey?.trim() || value.apiKeyFile?.trim())) {
+    throw new Error('Provider refresh cannot combine OAuth and API key credentials.');
+  }
+}
+
+function checkSnapshot(value) {
+  if (!exactKeys(value, ['provider', 'models', 'defaultModel', 'thinkingEnabled', 'services']) ||
+      !record(value.provider) || value.provider.type !== 'blun' || !record(value.models) ||
+      !(value.defaultModel === null || typeof value.defaultModel === 'string') ||
+      !(value.thinkingEnabled === null || typeof value.thinkingEnabled === 'boolean') ||
+      !exactKeys(value.services, serviceKeys)) throw new Error('Invalid provider refresh snapshot.');
+  checkCredentials(value.provider);
+  for (const [alias, model] of Object.entries(value.models)) {
+    if (['__proto__', 'prototype', 'constructor'].includes(alias) || !record(model) || model.provider !== providerId) {
+      throw new Error('Provider refresh contains a foreign or invalid model alias.');
+    }
+  }
+  for (const service of Object.values(value.services)) {
+    if (service !== null && !record(service)) throw new Error('Invalid provider refresh service.');
+    checkCredentials(service);
+  }
+}
+
+function applyProviderModelRefresh(config, envelope) {
+  if (!exactKeys(envelope, ['providerModelRefresh'])) throw new Error('Provider refresh cannot be combined with a config patch.');
+  const request = envelope.providerModelRefresh;
+  if (!exactKeys(request, ['version', 'before', 'after']) || request.version !== 1) throw new Error('Invalid provider refresh request.');
+  const { before, after } = request;
+  checkSnapshot(before);
+  checkSnapshot(after);
+  if (!Object.hasOwn(after.models, 'blun/king')) throw new Error('Provider refresh must retain the BLUN King model.');
+  const current = providerModelRefreshSnapshot(config);
+  if (!isDeepStrictEqual(current.provider, before.provider) || !isDeepStrictEqual(current.models, before.models)) {
+    throw new Error('Provider or models changed during refresh; existing configuration retained.');
+  }
+  const next = structuredClone(config);
+  next.providers[providerId] = jsonCopy(after.provider);
+  next.models ??= {};
+  // The TOML writer otherwise revives omitted fields from these old raw tables.
+  if (record(next.raw?.providers)) delete next.raw.providers[providerId];
+  for (const alias of new Set([...Object.keys(current.models), ...Object.keys(after.models)])) {
+    const existing = next.models[alias];
+    if (existing !== undefined && existing.provider !== providerId) throw new Error('Provider refresh conflicts with another provider model.');
+    delete next.models[alias];
+    if (record(next.raw?.models)) delete next.raw.models[alias];
+  }
+  Object.assign(next.models, jsonCopy(after.models));
+  if (current.defaultModel === before.defaultModel) {
+    if (after.defaultModel === null) delete next.defaultModel;
+    else next.defaultModel = after.defaultModel;
+  }
+  if (next.defaultModel !== undefined && !Object.hasOwn(next.models, next.defaultModel)) throw new Error('Provider refresh would invalidate the selected default model.');
+  if (current.defaultModel === before.defaultModel && current.thinkingEnabled === before.thinkingEnabled) {
+    if (after.thinkingEnabled === null) {
+      if (next.thinking) delete next.thinking.enabled;
+      if (record(next.raw?.thinking)) delete next.raw.thinking.enabled;
+    } else next.thinking = { ...next.thinking, enabled: after.thinkingEnabled };
+  }
+  for (const key of serviceKeys) {
+    if (!isDeepStrictEqual(current.services[key], before.services[key])) continue;
+    if (after.services[key] === null) {
+      if (next.services) delete next.services[key];
+    } else {
+      next.services ??= {};
+      next.services[key] = jsonCopy(after.services[key]);
+    }
+  }
+  return next;
+}
+
+// Share one read-modify-write queue across Core instances using the same file.
+function withProviderConfigWrite(filePath, operation) {
+  const resolved = path.resolve(filePath);
+  const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+  const run = (writers.get(key) ?? Promise.resolve()).then(operation);
+  const tail = run.then(() => undefined, () => undefined);
+  writers.set(key, tail);
+  void tail.then(() => { if (writers.get(key) === tail) writers.delete(key); });
+  return run;
+}
+
+module.exports = { providerModelRefreshSnapshot, applyProviderModelRefresh, withProviderConfigWrite };

package/bin/release-artifact-freeze-policy.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function sha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function copyFrozenArtifact(sourcePath, destinationPath) {
+  const source = path.resolve(sourcePath);
+  const destination = path.resolve(destinationPath);
+  const sourceSha256 = sha256(source);
+  if (fs.existsSync(destination)) {
+    const destinationSha256 = sha256(destination);
+    if (destinationSha256 !== sourceSha256) {
+      throw new Error(`FROZEN_ARTIFACT_NAME_CONFLICT:${destination}`);
+    }
+    return { status: 'already-frozen', path: destination, sha256: destinationSha256 };
+  }
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
+  return { status: 'created', path: destination, sha256: sourceSha256 };
+}
+
+module.exports = {
+  copyFrozenArtifact,
+  sha256,
+};

package/bin/repeated-user-message-projection.cjs

@@ -1,131 +1,8 @@
 'use strict';
 
-const LONG_DUPLICATE_MIN_CHARS = 512;
-const TELEGRAM_DELIVERY_LEDGER_LIMIT = 2_048;
-
-function userMessageText(message) {
-  if (
-    message?.role !== 'user'
-    || message.origin?.kind !== 'user'
-    || !Array.isArray(message.content)
-  ) return '';
-
-  const textParts = message.content
-    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text);
-  return textParts.length > 0 ? textParts.join('\n') : '';
-}
-
-function channelAttribute(attributes, name) {
-  const match = String(attributes).match(new RegExp(`(?:^|\\s)${name}="([^"]+)"`, 'u'));
-  return match?.[1] ?? '';
-}
-
-function telegramDeliveryIdentity(text) {
-  const channel = String(text).match(/<channel\b([^>]*)>/u);
-  if (channel === null) return '';
-
-  const source = channelAttribute(channel[1], 'source');
-  const chatId = channelAttribute(channel[1], 'chat_id');
-  const messageId = channelAttribute(channel[1], 'message_id');
-  if (source !== 'telegram' || !chatId || !messageId) return '';
-  return `${chatId}:${messageId}`;
-}
-
-function telegramDeliveryIdentityFromParts(input) {
-  if (!Array.isArray(input)) return '';
-  for (const part of input) {
-    if (part?.type !== 'text' || typeof part.text !== 'string') continue;
-    const identity = telegramDeliveryIdentity(part.text);
-    if (identity) return identity;
-  }
-  return '';
-}
-
-class TelegramDeliveryLedger {
-  constructor(limit = TELEGRAM_DELIVERY_LEDGER_LIMIT) {
-    this.limit = Math.max(1, Number.isInteger(limit) ? limit : TELEGRAM_DELIVERY_LEDGER_LIMIT);
-    this.identities = new Set();
-  }
-
-  identity(input, origin) {
-    if (origin?.kind !== 'user') return '';
-    return telegramDeliveryIdentityFromParts(input);
-  }
-
-  isDuplicate(input, origin) {
-    const identity = this.identity(input, origin);
-    return identity ? this.identities.has(identity) : false;
-  }
-
-  remember(input, origin) {
-    const identity = this.identity(input, origin);
-    if (!identity || this.identities.has(identity)) return identity;
-    this.identities.add(identity);
-    while (this.identities.size > this.limit) {
-      this.identities.delete(this.identities.values().next().value);
-    }
-    return identity;
-  }
-
-  forget(input, origin) {
-    const identity = this.identity(input, origin);
-    if (!identity) return false;
-    return this.identities.delete(identity);
-  }
-
-  snapshot() {
-    return [...this.identities];
-  }
-
-  restore(identities) {
-    this.identities.clear();
-    if (!Array.isArray(identities)) return;
-    for (const identity of identities) {
-      if (typeof identity !== 'string' || !identity || this.identities.has(identity)) continue;
-      this.identities.add(identity);
-      while (this.identities.size > this.limit) {
-        this.identities.delete(this.identities.values().next().value);
-      }
-    }
-  }
-}
-
-function repeatedUserMessageKey(message) {
-  const text = userMessageText(message);
-  if (!text) return '';
-
-  const telegramIdentity = telegramDeliveryIdentity(text);
-  if (telegramIdentity) return `telegram:${telegramIdentity}`;
-  return text.length >= LONG_DUPLICATE_MIN_CHARS ? `text:${text}` : '';
-}
-
 function dedupeRepeatedUserMessages(messages) {
-  if (!Array.isArray(messages) || messages.length < 2) return messages;
-
-  const lastIndexByKey = new Map();
-  const keys = messages.map((message, index) => {
-    const key = repeatedUserMessageKey(message);
-    if (key) lastIndexByKey.set(key, index);
-    return key;
-  });
-
-  let changed = false;
-  const projected = messages.filter((message, index) => {
-    const key = keys[index];
-    const keep = !key || lastIndexByKey.get(key) === index;
-    if (!keep) changed = true;
-    return keep;
-  });
-  return changed ? projected : messages;
+  // Repeated deliveries stay visible so the model can resolve them in context.
+  return messages;
 }
 
-module.exports = {
-  LONG_DUPLICATE_MIN_CHARS,
-  TELEGRAM_DELIVERY_LEDGER_LIMIT,
-  TelegramDeliveryLedger,
-  dedupeRepeatedUserMessages,
-  telegramDeliveryIdentity,
-  telegramDeliveryIdentityFromParts,
-  userMessageText,
-};
+module.exports = { dedupeRepeatedUserMessages };