blun-king-cli 9.1.550 → 9.1.562

package/LIESMICH.txt

@@ -1,7 +1,7 @@
-BLUN Code 9.1.550
+BLUN Code 9.1.561
 
 Installation:
-  npm install -g blun-king-cli@9.1.550
+  npm install -g blun-king-cli@9.1.561
 
 Start:
   blun

package/README.md

@@ -11,7 +11,7 @@ web tools, MCP servers, and an optional Telegram channel.
 ## Install
 
 ```sh
-npm install -g blun-king-cli@9.1.550
+npm install -g blun-king-cli@9.1.561
 ```
 
 Start the local console with:

package/agent-spine-plugin/scripts/check-hosts.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function json(root, path) {
+  return JSON.parse(await readFile(resolve(root, path), "utf8"));
+}
+
+function expand(value, variable, root) {
+  assert(typeof value === "string" && value.length > 0, "host command values must be non-empty strings");
+  return value.split(`\${${variable}}`).join(root);
+}
+
+async function validateEntrypoint(root, value) {
+  const target = resolve(value);
+  const within = relative(root, target);
+  assert(within && !within.startsWith("..") && !isAbsolute(within), "MCP entrypoint must remain inside the plugin");
+  const metadata = await stat(target);
+  assert(metadata.isFile(), "MCP entrypoint must be a regular file");
+}
+
+function validateHooks(root, hooks, { required, commandRoot }) {
+  assert(hooks && typeof hooks === "object" && !Array.isArray(hooks), "hook bundle is missing");
+  assert(Object.keys(hooks).every((key) => ["description", "hooks"].includes(key)), "hook bundle contains unsupported top-level metadata");
+  assert(hooks.description && typeof hooks.description === "string", "hook bundle description is missing");
+  for (const event of required) {
+    const registrations = hooks.hooks?.[event];
+    assert(Array.isArray(registrations) && registrations.length === 1, `${event} must have exactly one registration`);
+    assert(Array.isArray(registrations[0].hooks) && registrations[0].hooks.length === 1, `${event} must have exactly one hook command`);
+    const command = registrations[0].hooks[0];
+    assert(command.type === "command", `${event} must use a command hook`);
+    assert(command.command === `node "\${${commandRoot}}/src/hook.js"`, `${event} must use the bundled lifecycle adapter`);
+    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} timeout is unsafe`);
+  }
+  const extras = Object.keys(hooks.hooks || {}).filter((event) => !required.includes(event));
+  assert(extras.length === 0, `unknown hook events: ${extras.join(", ")}`);
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+function validateBlunHooks(root, hooks) {
+  const required = [
+    "SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse",
+    "PreCompact", "PostCompact", "Stop", "SubagentStop"
+  ];
+  assert(Array.isArray(hooks), "BLUN hook bundle is missing");
+  assert(hooks.length === required.length, "BLUN must register exactly one command per lifecycle event");
+  assert(JSON.stringify(hooks.map(({ event }) => event)) === JSON.stringify(required),
+    "BLUN lifecycle events must remain complete and ordered");
+  for (const event of required) {
+    const registrations = hooks.filter((hook) => hook.event === event);
+    assert(registrations.length === 1, `${event} must have exactly one BLUN registration`);
+    const command = registrations[0];
+    assert(command.command === 'node "./src/hook.js"', `${event} must use the bundled BLUN lifecycle adapter`);
+    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} BLUN timeout is unsafe`);
+  }
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+async function initializeServer({ label, root, variable, server, version }) {
+  assert(server && typeof server === "object" && !Array.isArray(server), `${label} MCP registration is missing`);
+  assert(server.command === "node", `${label} MCP registration must use the Node.js runtime`);
+  assert(Array.isArray(server.args) && server.args.length === 1, `${label} MCP registration must name exactly one entrypoint`);
+  const command = process.execPath;
+  const args = server.args.map((value) => {
+    const expanded = expand(value, variable, root);
+    return isAbsolute(expanded) ? expanded : resolve(root, expanded);
+  });
+  assert(!args.some((value) => value.includes("${")), `${label} MCP registration contains an unresolved variable`);
+  await validateEntrypoint(root, args[0]);
+
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(command, args, {
+      cwd: root,
+      env: { ...process.env, CLAUDE_PLUGIN_ROOT: root, PLUGIN_ROOT: root },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const settle = () => {
+        if (error) reject(error);
+        else resolveResult(value);
+      };
+      if (child.exitCode !== null || child.signalCode !== null) return settle();
+      child.once("close", settle);
+      child.kill();
+    };
+    const timer = setTimeout(() => {
+      finish(new Error(`${label} MCP initialize timed out${stderr ? `: ${stderr.trim()}` : ""}`));
+    }, 3000);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      const newline = stdout.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        const message = JSON.parse(stdout.slice(0, newline));
+        assert(message.id === 1, `${label} MCP initialize returned the wrong request id`);
+        assert(message.result?.serverInfo?.name === "agent-spine", `${label} MCP initialize returned the wrong server identity`);
+        assert(message.result?.serverInfo?.version === version, `${label} MCP initialize returned a stale server version`);
+        finish(null, { label, server: message.result.serverInfo.name, entrypoint: relative(root, args[0]) });
+      } catch (error) {
+        finish(error);
+      }
+    });
+    child.once("error", (error) => finish(error));
+    child.once("close", (code) => {
+      if (!settled) finish(new Error(`${label} MCP server exited with ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+    // A real MCP host keeps stdio open after initialization. Closing stdin
+    // here let macOS and Windows terminate the server before its queued reply.
+    child.stdin.write(`${JSON.stringify({
+      jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" }
+    })}\n`);
+  });
+}
+
+export async function checkHosts(root = process.cwd()) {
+  root = resolve(root);
+  const [pkg, blunManifest, claudeManifest, claudeMcp, codexManifest, claudeHooks, codexHooks, hookVersion] = await Promise.all([
+    json(root, "package.json"),
+    json(root, "blun.plugin.json"),
+    json(root, ".claude-plugin/plugin.json"),
+    json(root, ".mcp.json"),
+    json(root, ".codex-plugin/plugin.json"),
+    json(root, "hooks/hooks.json"),
+    json(root, "hooks/codex.json"),
+    json(root, "hooks/version.json")
+  ]);
+  assert(blunManifest.version === pkg.version && claudeManifest.version === pkg.version && codexManifest.version === pkg.version,
+    "host manifests must use the package cache version");
+  assert(hookVersion.schema === "agentspine.hook-bundle/v1" && hookVersion.version === pkg.version,
+    "hook bundle version must match the package cache version");
+  assert(hookVersion.contract === "agentspine.preflight/v2", "hook bundle preflight contract is missing");
+  assert(pkg.bin?.["agentspine-worker"] === "./src/worker.js", "package must register exactly one gateway worker entrypoint");
+  await validateEntrypoint(root, resolve(root, pkg.bin["agentspine-worker"]));
+  assert(claudeManifest.mcpServers === "./.mcp.json", "Claude manifest must explicitly reference ./.mcp.json");
+  assert(claudeManifest.hooks === undefined, "default hooks/hooks.json must not also be registered through a supplemental manifest path");
+  assert(codexManifest.hooks === undefined, "Codex manifest must omit unsupported hook registration fields");
+  assert(claudeMcp.mcpServers && Object.keys(claudeMcp.mcpServers).length === 1, "Claude MCP file must contain one mcpServers registration");
+  assert(codexManifest.mcpServers && Object.keys(codexManifest.mcpServers).length === 1, "Codex manifest must contain one MCP registration");
+  const commonEvents = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Stop", "SubagentStop"];
+  const claudeHookInventory = validateHooks(root, claudeHooks, {
+    required: [...commonEvents, "InstructionsLoaded"], commandRoot: "CLAUDE_PLUGIN_ROOT"
+  });
+  const codexHookInventory = validateHooks(root, codexHooks, { required: commonEvents, commandRoot: "PLUGIN_ROOT" });
+  const blunHookInventory = validateBlunHooks(root, blunManifest.hooks);
+  const registrations = await Promise.all([
+    initializeServer({ label: "blun", root, variable: "BLUN_PLUGIN_ROOT", server: blunManifest.mcpServers["agent-spine"], version: pkg.version }),
+    initializeServer({ label: "claude", root, variable: "CLAUDE_PLUGIN_ROOT", server: claudeMcp.mcpServers["agent-spine"], version: pkg.version }),
+    initializeServer({ label: "codex", root, variable: "PLUGIN_ROOT", server: codexManifest.mcpServers["agent-spine"], version: pkg.version })
+  ]);
+  return {
+    ok: true, root, version: pkg.version, registrations,
+    hooks: { blun: blunHookInventory, claude: claudeHookInventory, codex: codexHookInventory },
+    hookDiscovery: {
+      blun: "plugin-manifest", claude: "default-hooks-directory", codex: "bundled-host-adapter",
+      trust: "host-user-required", liveTrustVerified: false
+    },
+    worker: { entrypoint: pkg.bin["agentspine-worker"], setsPerInstall: 1 },
+    exactlyOnce: { mcpServersPerHost: 1, hookSetsPerHost: 1, workerSetsPerInstall: 1 },
+    authority: "registration-check-only"
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let root = process.cwd();
+  let pretty = false;
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--root") root = args[++index];
+    else if (args[index] === "--json") pretty = true;
+    else throw new Error(`unknown host-check argument: ${args[index]}`);
+  }
+  process.stdout.write(`${JSON.stringify(await checkHosts(root), null, pretty ? 2 : 0)}\n`);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    process.stderr.write(`AgentSpine host check failed: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}
+

package/bin/compaction-transaction-policy.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+
+function toolCallId(call) {
+  return typeof call?.id === 'string' && call.id.length > 0 ? call.id : undefined;
+}
+
+function assertBalancedToolPairs(messages, label = 'compaction history') {
+  const pending = new Set();
+  for (const message of messages) {
+    if (message?.role === 'assistant') {
+      for (const call of message.toolCalls ?? []) {
+        const id = toolCallId(call);
+        if (id === undefined) throw new Error(`${label} contains a tool call without an id`);
+        if (pending.has(id)) throw new Error(`${label} contains duplicate tool call id ${id}`);
+        pending.add(id);
+      }
+      continue;
+    }
+    if (message?.role !== 'tool') continue;
+    const id = typeof message.toolCallId === 'string' ? message.toolCallId : undefined;
+    if (id === undefined || !pending.delete(id)) {
+      throw new Error(`${label} contains an orphan tool result${id ? ` ${id}` : ''}`);
+    }
+  }
+  if (pending.size > 0) {
+    throw new Error(`${label} contains ${pending.size} tool call(s) without results`);
+  }
+  return true;
+}
+
+function createCompactionTransaction({ source, turnId, tokensBefore, messageCountBefore }) {
+  const transaction = {
+    id: randomUUID(),
+    source,
+    turnId: turnId ?? null,
+    tokensBefore: positiveInteger(tokensBefore, 'tokensBefore'),
+    messageCountBefore: positiveInteger(messageCountBefore, 'messageCountBefore'),
+    state: 'started',
+  };
+  return {
+    transaction,
+    record: {
+      type: 'compaction/start',
+      compaction_id: transaction.id,
+      source: transaction.source,
+      turn_id: transaction.turnId,
+      size_before: transaction.tokensBefore,
+      message_count_before: transaction.messageCountBefore,
+      unit: 'tokens',
+    },
+  };
+}
+
+function summarizeCompactionTransaction(transaction, input) {
+  if (transaction?.state !== 'started') {
+    throw new Error('compaction/summary requires exactly one open compaction/start');
+  }
+  if (typeof input.summary !== 'string' || input.summary.trim().length === 0) {
+    throw new Error('compaction/summary requires non-empty model-visible summary text');
+  }
+  assertBalancedToolPairs(input.historyBefore, 'history before compaction');
+  assertBalancedToolPairs(input.historyAfter, 'history after compaction');
+  transaction.state = 'summarized';
+  transaction.tokensAfter = positiveInteger(input.tokensAfter, 'tokensAfter');
+  transaction.messageCountAfter = positiveInteger(input.messageCountAfter, 'messageCountAfter');
+  return {
+    type: 'compaction/summary',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    summary: input.summary,
+    shadowed_token_count: transaction.tokensBefore,
+    size_before: transaction.tokensBefore,
+    size_after: transaction.tokensAfter,
+    message_count_before: transaction.messageCountBefore,
+    message_count_after: transaction.messageCountAfter,
+    tool_pairing_balanced_before: true,
+    tool_pairing_balanced_after: true,
+    unit: 'tokens',
+  };
+}
+
+function endCompactionTransaction(transaction, { status, error } = {}) {
+  if (transaction?.state === 'ended') return undefined;
+  if (transaction?.state !== 'started' && transaction?.state !== 'summarized') {
+    throw new Error('compaction/end requires an open compaction/start');
+  }
+  const normalizedStatus = status ?? 'success';
+  if (normalizedStatus === 'success' && transaction.state !== 'summarized') {
+    throw new Error('successful compaction/end requires one compaction/summary');
+  }
+  if (!['success', 'cancelled', 'failed'].includes(normalizedStatus)) {
+    throw new Error(`unsupported compaction status ${normalizedStatus}`);
+  }
+  transaction.state = 'ended';
+  return {
+    type: 'compaction/end',
+    compaction_id: transaction.id,
+    source: transaction.source,
+    turn_id: transaction.turnId,
+    status: normalizedStatus,
+    ...(transaction.tokensAfter === undefined ? {} : { size_after: transaction.tokensAfter }),
+    ...(typeof error === 'string' && error.length > 0 ? { error } : {}),
+    unit: 'tokens',
+  };
+}
+
+module.exports = {
+  assertBalancedToolPairs,
+  createCompactionTransaction,
+  endCompactionTransaction,
+  summarizeCompactionTransaction,
+};

package/bin/default-model-output-budget-policy.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const DEFAULT_MODEL_ALIAS = 'blun/king';
+const DEFAULT_MAX_OUTPUT_SIZE = 128000;
+
+function applyDefaultModelOutputBudget(config) {
+  const models = config?.models;
+  const model = models?.[DEFAULT_MODEL_ALIAS];
+
+  if (!model || model.maxOutputSize !== undefined) return config;
+
+  return {
+    ...config,
+    models: {
+      ...models,
+      [DEFAULT_MODEL_ALIAS]: {
+        ...model,
+        maxOutputSize: DEFAULT_MAX_OUTPUT_SIZE,
+      },
+    },
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_OUTPUT_SIZE,
+  DEFAULT_MODEL_ALIAS,
+  applyDefaultModelOutputBudget,
+};

package/bin/file-observation-policy.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+function versionFromStat(stat) {
+  if (!stat || typeof stat !== 'object') return null;
+  return [
+    stat.stDev ?? null,
+    stat.stIno ?? null,
+    stat.stSize ?? null,
+    stat.stMtime ?? null,
+  ].join(':');
+}
+
+function isNotFoundError(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
+}
+
+function createFileObservationPolicy(options = {}) {
+  const caseInsensitive = options.pathClass === 'win32';
+  const observations = new Map();
+
+  function key(filePath) {
+    const normalized = String(filePath).replaceAll('\\', '/');
+    return caseInsensitive ? normalized.toLowerCase() : normalized;
+  }
+
+  function recordPresent(filePath, stat) {
+    const version = versionFromStat(stat);
+    if (version === null) throw new TypeError('recordPresent requires a file stat');
+    observations.set(key(filePath), { kind: 'present', version });
+  }
+
+  function recordAbsent(filePath) {
+    observations.set(key(filePath), { kind: 'absent' });
+  }
+
+  function verifyStableRead(filePath, before, after) {
+    const beforeVersion = versionFromStat(before);
+    const afterVersion = versionFromStat(after);
+    if (beforeVersion === null || afterVersion === null || beforeVersion !== afterVersion) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `File changed while reading "${filePath}". Read it again before editing or overwriting it.`,
+      };
+    }
+    recordPresent(filePath, after);
+    return { allowed: true, version: afterVersion };
+  }
+
+  function authorizeEdit(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      return {
+        allowed: false,
+        code: prior?.kind === 'absent' ? 'FS_NOT_FOUND' : 'FS_NOT_OBSERVED',
+        error: prior?.kind === 'absent'
+          ? `Cannot edit "${filePath}": the last Read confirmed that it does not exist.`
+          : `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Edit.`,
+      };
+    }
+    return { allowed: true, version: prior.version };
+  }
+
+  function authorizeWrite(filePath, currentStat) {
+    const prior = observations.get(key(filePath));
+    if (currentStat === null) {
+      if (prior?.kind === 'present') {
+        return {
+          allowed: false,
+          code: 'FS_STALE_VERSION',
+          error: `"${filePath}" disappeared since the last Read. Read it again before recreating it.`,
+        };
+      }
+      return { allowed: true, version: null, create: true };
+    }
+    if (prior === undefined) {
+      return {
+        allowed: false,
+        code: 'FS_NOT_OBSERVED',
+        error: `Write would replace or append to existing file "${filePath}" without a prior Read. Read it first, then retry.`,
+      };
+    }
+    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
+      return {
+        allowed: false,
+        code: 'FS_STALE_VERSION',
+        error: `"${filePath}" changed since the last Read. Read it again, then retry the Write.`,
+      };
+    }
+    return { allowed: true, version: prior.version, create: false };
+  }
+
+  function verifyUnchanged(filePath, expectedVersion, currentStat) {
+    const currentVersion = versionFromStat(currentStat);
+    if (expectedVersion === currentVersion) return { allowed: true };
+    return {
+      allowed: false,
+      code: 'FS_STALE_VERSION',
+      error: expectedVersion === null
+        ? `"${filePath}" appeared before the new file could be created. Read it before deciding whether to overwrite it.`
+        : `"${filePath}" changed before the mutation was written. Read it again, then retry.`,
+    };
+  }
+
+  return {
+    authorizeEdit,
+    authorizeWrite,
+    recordAbsent,
+    recordPresent,
+    verifyStableRead,
+    verifyUnchanged,
+  };
+}
+
+module.exports = {
+  createFileObservationPolicy,
+  isNotFoundError,
+  versionFromStat,
+};

package/bin/launcher-runtime.js

@@ -539,7 +539,6 @@ async function runLauncher(options = {}) {
     env.BLUN_SHARED_HOME = privatePaths.sharedHome;
     env.BLUN_LOG_HOME = privatePaths.sharedHome;
     env.BLUN_PROFILE = PROFILE.profileName;
-    env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     const mnemoConnect = startMnemoConnectHeartbeat({
       env,
       profileName: PROFILE.profileName,

package/bin/micro-compaction-policy.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { createHash } = require('node:crypto');
+
 const MICRO_COMPACTION_PRESSURE_RATIO = 0.75;
 const MICRO_COMPACTION_MIN_ADVANCE_MESSAGES = 20;
 const MICRO_COMPACTION_RECENT_MESSAGES = 4;
@@ -46,6 +48,66 @@ function selectMicroCompactionCutoff(options = {}) {
   };
 }
 
+function redundantHistoricalToolResultIds(messages, cutoff) {
+  return new Set(redundantHistoricalToolResultReferences(messages, cutoff).keys());
+}
+
+function redundantHistoricalToolResultReferences(messages, cutoff) {
+  if (!Array.isArray(messages)) return new Map();
+
+  const historicalCutoff = Math.min(messages.length, nonNegativeInteger(cutoff));
+  const callSignatures = new Map();
+  for (const message of messages) {
+    if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      if (
+        typeof call?.id !== 'string'
+        || typeof call.name !== 'string'
+        || typeof call.arguments !== 'string'
+      ) {
+        continue;
+      }
+      callSignatures.set(call.id, JSON.stringify([call.name, call.arguments]));
+    }
+  }
+
+  const resultsBySignature = new Map();
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== 'tool' || typeof message.toolCallId !== 'string') continue;
+    const callSignature = callSignatures.get(message.toolCallId);
+    if (callSignature === undefined || !Array.isArray(message.content)) continue;
+
+    let resultSignature;
+    try {
+      resultSignature = createHash('sha256')
+        .update(callSignature)
+        .update('\0')
+        .update(JSON.stringify(message.content))
+        .digest('hex');
+    } catch {
+      continue;
+    }
+
+    const entries = resultsBySignature.get(resultSignature) ?? [];
+    entries.push({ index, toolCallId: message.toolCallId });
+    resultsBySignature.set(resultSignature, entries);
+  }
+
+  const redundantIds = new Map();
+  for (const entries of resultsBySignature.values()) {
+    if (entries.length < 2) continue;
+    const newestToolCallId = entries.at(-1)?.toolCallId;
+    if (newestToolCallId === undefined) continue;
+    for (const entry of entries.slice(0, -1)) {
+      if (entry.index < historicalCutoff) {
+        redundantIds.set(entry.toolCallId, newestToolCallId);
+      }
+    }
+  }
+  return redundantIds;
+}
+
 function finiteOr(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) ? number : fallback;
@@ -77,5 +139,7 @@ module.exports = {
   MICRO_COMPACTION_RECENT_MESSAGES,
   MICRO_COMPACTION_TOOL_ARGUMENTS_ENABLED,
   MICRO_COMPACTION_TOOL_ARGUMENT_MIN_TOKENS,
+  redundantHistoricalToolResultIds,
+  redundantHistoricalToolResultReferences,
   selectMicroCompactionCutoff,
 };

package/bin/mnemo-connect-heartbeat.cjs

@@ -5,7 +5,6 @@ const os = require('node:os');
 
 const DEFAULT_HEARTBEAT_MS = 60_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
-const DEFAULT_INTERNAL_HUB_URL = 'http://100.85.21.103:7117';
 
 function resolveMnemoHubUrl(env = process.env) {
   const raw = [
@@ -51,7 +50,7 @@ function resolveMnemoProfileConnectConfig(configPath) {
     ].some((value) => typeof value === 'string' && value.trim().length > 0);
     const baseUrl = resolveMnemoHubUrl(server.env);
     if (configuredUrl && !baseUrl) return null;
-    return { agentName, baseUrl: baseUrl || DEFAULT_INTERNAL_HUB_URL };
+    return baseUrl ? { agentName, baseUrl } : null;
   } catch {
     return null;
   }
@@ -196,7 +195,6 @@ function startMnemoConnectHeartbeat(options = {}) {
 
 module.exports = {
   DEFAULT_HEARTBEAT_MS,
-  DEFAULT_INTERNAL_HUB_URL,
   DEFAULT_TIMEOUT_MS,
   postMnemoTool,
   resolveMnemoAgentName,

package/bin/retry-checkpoint-policy.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+async function persistRetrySchedule(input = {}) {
+  const { dispatchRetrying, flush, event, signal } = input;
+  if (typeof dispatchRetrying !== 'function') throw new TypeError('persistRetrySchedule requires dispatchRetrying');
+  if (typeof flush !== 'function') throw new TypeError('persistRetrySchedule requires flush');
+  signal?.throwIfAborted?.();
+  await dispatchRetrying(event);
+  await flush();
+  signal?.throwIfAborted?.();
+}
+
+module.exports = { persistRetrySchedule };

package/bin/session-checkpoint-policy.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const TOOL_ABORTED_BEFORE_DISPATCH = 'TOOL_ABORTED_BEFORE_DISPATCH';
+
+async function checkpointBeforeExternalSideEffect(options = {}) {
+  const flush = options.flush;
+  const signal = options.signal;
+  if (typeof flush !== 'function') {
+    throw new TypeError('checkpointBeforeExternalSideEffect requires flush');
+  }
+  await flush();
+  if (signal?.aborted === true) {
+    return {
+      allowed: false,
+      code: TOOL_ABORTED_BEFORE_DISPATCH,
+      error: 'Tool call aborted before dispatch while its durable checkpoint was being written.',
+    };
+  }
+  return { allowed: true };
+}
+
+module.exports = {
+  TOOL_ABORTED_BEFORE_DISPATCH,
+  checkpointBeforeExternalSideEffect,
+};

package/bin/startup-preferences.cjs

@@ -125,6 +125,7 @@ function migrateLegacyStartupPreferences(profileHome, fsImpl = fs) {
 
 module.exports = {
   migrateLegacyStartupPreferences,
+  parseStartupPreferences,
   readStartupPreferences,
   resolveStartupUiLocale,
 };