blun-king-cli 9.1.486 → 9.1.488

package/agent-spine-plugin/src/worker.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { watch } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { claimGatewayWork, completeGatewayRun, deliverPrepared, failGatewayRun, loadGatewayRuntime, reconcileGateway, updateGatewayHealth } from "./lib/gateway-runtime.js";
+import { createTelegramAdapter } from "./lib/telegram-adapter.js";
+import { acknowledgeChannelDelivery, loadChannelRuntime } from "./lib/channel-runtime.js";
+import { loadPersonaRuntime, syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
+import { isMainModule } from "./lib/runtime.js";
+
+const MAX_FRAME = 64 * 1024;
+const WAKE_FILES = new Set(["attention.json", "channel-runtime.json", "gateway-policy.json", "persona-policy.json", "persona-runtime.json"]);
+
+export async function waitForGatewayWake(root, delayMs, { watchFactory = watch, realpathFactory = realpath } = {}) {
+  const delay = Math.max(250, Math.min(60000, Number(delayMs) || 60000));
+  const { directory } = await loadGatewayRuntime(root);
+  let watchPath;
+  try { watchPath = await realpathFactory(directory); } catch { return "watch-unavailable"; }
+  return new Promise((resolvePromise) => {
+    let settled = false; let watcher;
+    const finish = (reason) => {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      watcher?.close();
+      resolvePromise(reason);
+    };
+    const timer = setTimeout(() => finish("timer"), delay);
+    try {
+      watcher = watchFactory(watchPath, { persistent: true }, (_eventType, filename) => {
+        const name = filename === null ? null : String(filename);
+        if (name === null || WAKE_FILES.has(name)) finish("event");
+      });
+      watcher.on?.("error", () => finish("watch-error"));
+    } catch { finish("watch-unavailable"); }
+  });
+}
+
+function exactRunner(env) {
+  const runner = env.AGENTSPINE_HOST_RUNNER;
+  if (!runner || !isAbsolute(runner)) throw new Error("AGENTSPINE_HOST_RUNNER must be an absolute locally approved executable path");
+  return resolve(runner);
+}
+
+async function invokeHostRunner(item, { env = process.env, timeoutMs = 300000, spawnProcess = spawn } = {}) {
+  const executable = exactRunner(env);
+  return new Promise((resolvePromise, reject) => {
+    const child = spawnProcess(executable, [], {
+      shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"],
+      env: Object.fromEntries(["PATH", "Path", "HOME", "USERPROFILE", "SystemRoot", "SYSTEMROOT", "WINDIR",
+        "AGENTSPINE_STATE_DIR", "CLAUDE_CONFIG_DIR", "CODEX_HOME"].filter((key) => env[key] !== undefined).map((key) => [key, env[key]]))
+    });
+    let stdout = Buffer.alloc(0); let stderr = Buffer.alloc(0); let settled = false;
+    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); error ? reject(error) : resolvePromise(value); };
+    child.stdout.on("data", (chunk) => { stdout = Buffer.concat([stdout, chunk]); if (stdout.length > MAX_FRAME) child.kill(); });
+    child.stderr.on("data", (chunk) => { stderr = Buffer.concat([stderr, chunk]).subarray(0, 2048); });
+    child.on("error", (error) => finish(error));
+    child.on("close", (code) => {
+      if (stdout.length > MAX_FRAME) return finish(new Error("host runner response exceeds 64 KiB"));
+      if (code !== 0) return finish(new Error("host runner failed: " + stderr.toString("utf8").slice(0, 2048)));
+      try { finish(null, JSON.parse(stdout.toString("utf8"))); } catch { finish(new Error("host runner returned invalid JSON")); }
+    });
+    const timer = setTimeout(() => { child.kill(); finish(new Error("host runner exceeded its bounded timeout")); }, timeoutMs);
+    child.stdin.end(JSON.stringify({ schema: "agentspine.run-request/v1", item, authority: "execution-state-only" }) + "\n");
+  });
+}
+
+async function hostWorkItem(root, item) {
+  const [{ policy }, personas, channel] = await Promise.all([
+    loadGatewayRuntime(root), loadPersonaRuntime(root), loadChannelRuntime(root)
+  ]);
+  const persona = personas.runtime.personas.find((entry) => entry.personaId === item.agentId && entry.status === "active");
+  const identity = personas.policy.bindings.find((entry) => entry.id === persona?.bindingId && entry.active);
+  if (!persona || !identity) throw new Error("claimed work lost its authenticated agent identity");
+  const goal = item.goalId === null ? null : policy.goals.find((entry) => entry.goalId === item.goalId) || null;
+  const event = item.channelEventId === null ? null
+    : channel.runtime.events.find((entry) => entry.eventId === item.channelEventId) || null;
+  if (item.channelEventId && !event) throw new Error("claimed channel work lost its exact event");
+  return {
+    ...structuredClone(item), host: identity.host, profileId: identity.profileId, projectRoot: root,
+    goal: goal ? structuredClone(goal) : null,
+    hostEnvironment: {
+      AGENTSPINE_GATEWAY_CONTEXT: "agentspine.gateway-start/v1",
+      AGENTSPINE_ENTITY_ID: item.agentId,
+      AGENTSPINE_PROJECT_ID: item.projectId,
+      ...(item.groupId === null ? {} : { AGENTSPINE_GROUP_ID: item.groupId }),
+      ...(event ? {
+        AGENTSPINE_CHANNEL_EVENT_ID: event.eventId,
+        AGENTSPINE_CHANNEL_PROVIDER: event.provider
+      } : {})
+    },
+    channelStart: event ? {
+      agent_spine_scope: { entity_id: event.agentId, project_id: event.projectId, group_id: event.groupId },
+      agent_spine_channel_event: { event_id: event.eventId, provider: event.provider },
+      session_key: event.sessionKey,
+      authority: "explicit-local-channel-policy"
+    } : null
+  };
+}
+
+export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-worker:local", now = new Date(),
+  hostRunner = invokeHostRunner, adapter = null, env = process.env } = {}) {
+  const deliveryAdapter = adapter || createTelegramAdapter({ root, env });
+  await syncPersonaRosterFromEnvironment({ root, env, now });
+  const initial = await loadGatewayRuntime(root);
+  if (!initial.policy.enabled || initial.policy.killSwitch) return { status: "stopped", processed: false };
+  if (typeof deliveryAdapter.poll === "function") {
+    try { await deliveryAdapter.poll(); }
+    catch (error) {
+      await updateGatewayHealth({ root, worker: "degraded", adapter: "failed", now });
+      throw error;
+    }
+  }
+  await reconcileGateway({ root, now });
+  await updateGatewayHealth({ root, worker: "healthy", adapter: "healthy", now });
+  const afterReconcile = await loadGatewayRuntime(root);
+  const dueOutbox = afterReconcile.runtime.outbox.filter((item) => ["prepared", "failed"].includes(item.status)
+    && new Date(item.nextAttemptAt) <= new Date(now)).sort((a, b) => a.nextAttemptAt.localeCompare(b.nextAttemptAt)
+      || a.createdAt.localeCompare(b.createdAt) || a.outboxId.localeCompare(b.outboxId))[0] || null;
+  if (dueOutbox) {
+    const delivery = await deliverPrepared({ root, outboxId: dueOutbox.outboxId, adapter: deliveryAdapter, now });
+    if (delivery.outbox.status === "delivered") await acknowledgeChannelDelivery({ root,
+      eventId: delivery.outbox.eventId, bindingId: delivery.outbox.bindingId,
+      deliveryReceiptId: delivery.receipt.id, now });
+    return { status: delivery.outbox.status, processed: true, outboxId: delivery.outbox.outboxId,
+      recoveredDelivery: true };
+  }
+  const claim = await claimGatewayWork({ root, workerId, now });
+  if (!claim.item) return { status: claim.reason, processed: false };
+  let result;
+  try { result = await hostRunner(await hostWorkItem(root, claim.item), { env }); }
+  catch (error) {
+    const failed = await failGatewayRun({ root, queueId: claim.item.queueId, workerId,
+      error: "Host runtime unavailable: " + String(error.message).slice(0, 400), now });
+    return { status: failed.item.status, processed: true, queueId: failed.item.queueId, retryAt: failed.item.availableAt };
+  }
+  const completed = await completeGatewayRun({ root, queueId: claim.item.queueId, workerId, result, now });
+  if (!completed.outbox) return { status: completed.item.status, processed: true, queueId: completed.item.queueId };
+  const delivery = await deliverPrepared({ root, outboxId: completed.outbox.outboxId,
+    adapter: deliveryAdapter, now });
+  if (delivery.outbox.status === "delivered") await acknowledgeChannelDelivery({ root,
+    eventId: delivery.outbox.eventId, bindingId: delivery.outbox.bindingId,
+    deliveryReceiptId: delivery.receipt.id, now });
+  return { status: delivery.outbox.status, processed: true, queueId: completed.item.queueId, outboxId: delivery.outbox.outboxId };
+}
+
+export async function runWorker({ root = process.cwd(), once = false, env = process.env,
+  waitForWake = waitForGatewayWake } = {}) {
+  const workerId = "gateway-worker:" + process.pid;
+  do {
+    const result = await runWorkerTick({ root, workerId, env });
+    if (once) return result;
+    const { policy, runtime } = await loadGatewayRuntime(root);
+    if (!policy.enabled || policy.killSwitch) return { status: "stopped", processed: false };
+    const pending = [
+      ...runtime.queue.filter((item) => item.status === "pending").map((item) => new Date(item.availableAt).getTime()),
+      ...runtime.outbox.filter((item) => ["prepared", "failed"].includes(item.status))
+        .map((item) => new Date(item.nextAttemptAt).getTime())
+    ];
+    const delay = pending.length ? Math.max(250, Math.min(60000, Math.min(...pending) - Date.now())) : 60000;
+    await waitForWake(root, delay);
+  } while (true);
+}
+
+if (isMainModule(import.meta.url)) {
+  const args = process.argv.slice(2); const once = args.includes("--once");
+  const rootIndex = args.indexOf("--root");
+  if (rootIndex >= 0 && (!args[rootIndex + 1] || args[rootIndex + 1].startsWith("--"))) throw new Error("--root requires a path");
+  const root = rootIndex >= 0 ? args[rootIndex + 1] : process.cwd();
+  const rosterIndex = args.indexOf("--persona-roster");
+  if (rosterIndex >= 0 && (!args[rosterIndex + 1] || args[rosterIndex + 1].startsWith("--"))) {
+    throw new Error("--persona-roster requires a path");
+  }
+  const env = { ...process.env };
+  if (rosterIndex >= 0) env.AGENTSPINE_PERSONA_ROSTER_FILE = args[rosterIndex + 1];
+  runWorker({ root, once, env }).then((result) => process.stdout.write(JSON.stringify(result) + "\n"))
+    .catch((error) => { process.stderr.write("AgentSpine worker: " + String(error.message).slice(0, 2048) + "\n"); process.exitCode = 1; });
+}

package/bin/identity-context-policy.cjs

@@ -21,6 +21,7 @@ const ACTIVITY_FILE_RE = /^\d{4}-\d{2}-\d{2}\.json$/u;
 const RELATIONSHIP_CANDIDATE_FILE_RE = /^[a-f0-9]{32}\.json$/u;
 const ACTOR_FILE_RE = /^([A-Za-z0-9][A-Za-z0-9._-]{0,127})\.json$/u;
 const LONG_GAP_MS = 7 * 24 * 60 * 60 * 1000;
+const ESTABLISHED_INTERACTION_DAYS = 3;
 const MAX_COLLEAGUES_IN_CONTEXT = 12;
 
 function autoGraphEnabled(env) {
@@ -468,6 +469,52 @@ function recordInteractionActivity(root, agentId, actorId, interactedAt) {
   );
 }
 
+function trustedInteractionDayCount(root, agentId, actorId, limit) {
+  if (!actorId) return 0;
+  const activityRoot = path.resolve(root, 'agents', agentId, 'activity', actorId);
+  if (!isInside(root, activityRoot)) return 0;
+  try {
+    const stat = fs.lstatSync(activityRoot);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) return 0;
+    if (!isInside(root, fs.realpathSync(activityRoot))) return 0;
+    let count = 0;
+    for (const name of fs.readdirSync(activityRoot).filter((entry) => ACTIVITY_FILE_RE.test(entry)).sort()) {
+      const entry = readJson(root, ['agents', agentId, 'activity', actorId, name]);
+      const interactedAt = trustedTimestamp(entry?.interacted_at);
+      if (entry?.version !== 1
+          || entry?.actor_id !== actorId
+          || entry?.source !== 'trusted_channel_metadata'
+          || !interactedAt
+          || activityDate(interactedAt) !== name.slice(0, 10)) continue;
+      count += 1;
+      if (count >= limit) break;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+function promoteReturningRelationship(root, agentId, actorId) {
+  const relationship = readJson(root, ['agents', agentId, 'relationships', `${actorId}.json`]);
+  if (relationship?.version !== 1
+      || relationship.actor_id !== actorId
+      || relationship.status !== 'new') return false;
+  if (trustedInteractionDayCount(root, agentId, actorId, ESTABLISHED_INTERACTION_DAYS)
+      < ESTABLISHED_INTERACTION_DAYS) return false;
+  return updateJsonAtomically(
+    root,
+    ['agents', agentId, 'relationships', `${actorId}.json`],
+    (relationship) => (
+      relationship.version === 1
+        && relationship.actor_id === actorId
+        && relationship.status === 'new'
+        ? { ...relationship, status: 'established' }
+        : undefined
+    ),
+  );
+}
+
 function previousInteractionAfterLongGap(root, agentId, actorId) {
   if (!actorId) return undefined;
   const activityRoot = path.resolve(root, 'agents', agentId, 'activity', actorId);
@@ -598,7 +645,10 @@ function recordChannelIdentity(envelope, env = process.env) {
     messageId: safeId(meta.message_id),
     receivedAt,
   });
-  if (firstSeenAt) recordInteractionActivity(root, agentId, actorId, firstSeenAt);
+  if (firstSeenAt) {
+    recordInteractionActivity(root, agentId, actorId, firstSeenAt);
+    if (promoteReturningRelationship(root, agentId, actorId)) updated.push('relationship_status');
+  }
   let relationshipMemory;
   let relationshipMemoryUnavailable = false;
   let relationshipNotes = [];

package/bin/launcher-runtime.js

@@ -18,7 +18,10 @@ const {
   launcherHelpText,
   launcherModeFromArgv,
 } = require('./launcher-mode');
-const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
+const {
+  installManagedAgentSpinePlugin,
+  installManagedTelegramPlugin,
+} = require('./plugin-bootstrap');
 const {
   availableStandardToolNames,
   seedConfiguredMnemoMcp,
@@ -275,6 +278,10 @@ function installTelegramForProfile(packageRoot, blunDir) {
   }
 }
 
+function installAgentSpineForProfile(packageRoot, blunDir) {
+  installManagedAgentSpinePlugin({ packageRoot, blunDir });
+}
+
 function createManagedNodeEnvironment(binary, env = process.env, platform = process.platform) {
   const pathImpl = platform === 'win32' ? path.win32 : path.posix;
   const separator = platform === 'win32' ? path.win32.delimiter : path.posix.delimiter;
@@ -504,6 +511,7 @@ async function runLauncher(options = {}) {
     });
     seedConfiguredMnemoMcp({ blunDir, env: process.env });
     seedStandardSkills({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
+    installAgentSpineForProfile(PKG, blunDir);
     if (mode === LAUNCHER_MODES.KING) installTelegramForProfile(PKG, blunDir);
 
     const nativeModules = repairConfiguredNativeModules({

package/bin/plugin-bootstrap.js

@@ -75,14 +75,14 @@ function pluginTreeDigest(root) {
   return hash.digest('hex');
 }
 
-function hasCurrentTelegramRecord(installed, pluginRoot) {
-  const records = installed.plugins.filter((plugin) => plugin.id === 'telegram');
+function hasCurrentPluginRecord(installed, pluginRoot, pluginId, mcpServerName) {
+  const records = installed.plugins.filter((plugin) => plugin.id === pluginId);
   if (records.length !== 1) return false;
-  const [telegram] = records;
-  return telegram.root === pluginRoot
-    && telegram.source === 'local-path'
-    && telegram.enabled === true
-    && telegram.capabilities?.mcpServers?.telegram?.enabled === true;
+  const [plugin] = records;
+  return plugin.root === pluginRoot
+    && plugin.source === 'local-path'
+    && plugin.enabled === true
+    && plugin.capabilities?.mcpServers?.[mcpServerName]?.enabled === true;
 }
 
 function readInstalledPlugins(filePath) {
@@ -96,16 +96,16 @@ function readInstalledPlugins(filePath) {
   return parsed;
 }
 
-function updatedInstalledPlugins(installed, pluginRoot, now) {
-  const previous = installed.plugins.find((plugin) => plugin.id === 'telegram');
+function updatedInstalledPlugins(installed, pluginRoot, now, pluginId, mcpServerName) {
+  const previous = installed.plugins.find((plugin) => plugin.id === pluginId);
   const previousCapabilities = isObject(previous?.capabilities) ? previous.capabilities : {};
   const previousMcpServers = isObject(previousCapabilities.mcpServers)
     ? previousCapabilities.mcpServers : {};
-  const previousTelegramMcp = isObject(previousMcpServers.telegram)
-    ? previousMcpServers.telegram : {};
-  const telegram = {
+  const previousMcp = isObject(previousMcpServers[mcpServerName])
+    ? previousMcpServers[mcpServerName] : {};
+  const updatedPlugin = {
     ...previous,
-    id: 'telegram',
+    id: pluginId,
     root: pluginRoot,
     source: 'local-path',
     enabled: true,
@@ -116,7 +116,7 @@ function updatedInstalledPlugins(installed, pluginRoot, now) {
       ...previousCapabilities,
       mcpServers: {
         ...previousMcpServers,
-        telegram: { ...previousTelegramMcp, enabled: true },
+        [mcpServerName]: { ...previousMcp, enabled: true },
       },
     },
   };
@@ -124,14 +124,14 @@ function updatedInstalledPlugins(installed, pluginRoot, now) {
   const plugins = [];
   let replaced = false;
   for (const plugin of installed.plugins) {
-    if (plugin.id !== 'telegram') {
+    if (plugin.id !== pluginId) {
       plugins.push(plugin);
     } else if (!replaced) {
-      plugins.push(telegram);
+      plugins.push(updatedPlugin);
       replaced = true;
     }
   }
-  if (!replaced) plugins.push(telegram);
+  if (!replaced) plugins.push(updatedPlugin);
   return { ...installed, version: 1, plugins };
 }
 
@@ -149,11 +149,19 @@ function writeInstalledPlugins(filePath, installed) {
   }
 }
 
-function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().toISOString() }) {
-  const sourceRoot = path.join(packageRoot, 'telegram-plugin');
+function installManagedPlugin({
+  packageRoot,
+  blunDir,
+  now = new Date().toISOString(),
+  pluginId,
+  sourceDirectory,
+  mcpServerName,
+  displayName,
+}) {
+  const sourceRoot = path.join(packageRoot, sourceDirectory);
   const pluginsDir = path.join(blunDir, 'plugins');
   const managedDir = path.join(pluginsDir, 'managed');
-  const legacyPluginRoot = path.join(managedDir, 'telegram');
+  const legacyPluginRoot = path.join(managedDir, pluginId);
   const installedFile = path.join(pluginsDir, 'installed.json');
 
   ensurePrivateDirectory(pluginsDir);
@@ -162,26 +170,38 @@ function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().t
   ensurePrivateDirectory(managedDir);
   if (fs.existsSync(legacyPluginRoot)
     && pluginTreesAreIdentical(sourceRoot, legacyPluginRoot)) {
-    if (!hasCurrentTelegramRecord(installed, legacyPluginRoot)) {
-      const updatedInstalled = updatedInstalledPlugins(installed, legacyPluginRoot, now);
+    if (!hasCurrentPluginRecord(installed, legacyPluginRoot, pluginId, mcpServerName)) {
+      const updatedInstalled = updatedInstalledPlugins(
+        installed,
+        legacyPluginRoot,
+        now,
+        pluginId,
+        mcpServerName,
+      );
       writeInstalledPlugins(installedFile, updatedInstalled);
     }
     return { installedFile, pluginRoot: legacyPluginRoot, reused: true };
   }
   const sourceDigest = pluginTreeDigest(sourceRoot);
-  const pluginRoot = path.join(managedDir, `telegram-${sourceDigest}`);
-  const updatedInstalled = updatedInstalledPlugins(installed, pluginRoot, now);
+  const pluginRoot = path.join(managedDir, `${pluginId}-${sourceDigest}`);
+  const updatedInstalled = updatedInstalledPlugins(
+    installed,
+    pluginRoot,
+    now,
+    pluginId,
+    mcpServerName,
+  );
   if (fs.existsSync(pluginRoot)) {
     if (!pluginTreesAreIdentical(sourceRoot, pluginRoot)) {
-      throw new Error(`Managed Telegram plugin digest mismatch: ${pluginRoot}`);
+      throw new Error(`Managed ${displayName} plugin digest mismatch: ${pluginRoot}`);
     }
-    if (!hasCurrentTelegramRecord(installed, pluginRoot)) {
+    if (!hasCurrentPluginRecord(installed, pluginRoot, pluginId, mcpServerName)) {
       writeInstalledPlugins(installedFile, updatedInstalled);
     }
     return { installedFile, pluginRoot, reused: true };
   }
   const nonce = `${process.pid}-${randomUUID()}`;
-  const stagingRoot = path.join(managedDir, `.telegram-${nonce}.tmp`);
+  const stagingRoot = path.join(managedDir, `.${pluginId}-${nonce}.tmp`);
   let installedNewPlugin = false;
   try {
     fs.cpSync(sourceRoot, stagingRoot, { recursive: true, force: true });
@@ -201,7 +221,28 @@ function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().t
   return { installedFile, pluginRoot, reused: false };
 }
 
+function installManagedTelegramPlugin(options) {
+  return installManagedPlugin({
+    ...options,
+    pluginId: 'telegram',
+    sourceDirectory: 'telegram-plugin',
+    mcpServerName: 'telegram',
+    displayName: 'Telegram',
+  });
+}
+
+function installManagedAgentSpinePlugin(options) {
+  return installManagedPlugin({
+    ...options,
+    pluginId: 'agent-spine',
+    sourceDirectory: 'agent-spine-plugin',
+    mcpServerName: 'agent-spine',
+    displayName: 'AgentSpine',
+  });
+}
+
 module.exports = {
+  installManagedAgentSpinePlugin,
   installManagedTelegramPlugin,
   readInstalledPlugins,
 };

package/bin/turn-thinking-policy.cjs

@@ -38,10 +38,11 @@ function shouldEnableThinkingForTurn(text, originKind) {
   return selectThinkingEffortForTurn(text, originKind) !== "off";
 }
 
-function selectThinkingEffortForWorkStep(stepNumber, previousToolOutcome) {
-  const normalizedStep = Number(stepNumber);
-  if (!Number.isInteger(normalizedStep) || normalizedStep <= 1) return undefined;
-  return previousToolOutcome === "success" ? "low" : undefined;
+function selectThinkingEffortForWorkStep(_stepNumber, _previousToolOutcome) {
+  // A successful tool call does not make the next agent decision routine.
+  // Preserve the turn-selected effort; short chat and lightweight steers are
+  // classified independently before the work loop starts.
+  return undefined;
 }
 
 function capCompletionBudgetForAdaptiveEffort(budget, thinkingEffort) {

package/bin/turn-tool-performance-policy.cjs

@@ -17,6 +17,12 @@ const TOOL_SEARCH_INTENT_WORDS = new Set([
   'find', 'fetch', 'get', 'holen', 'list', 'read', 'search', 'show', 'anzeigen', 'lesen', 'suchen',
 ]);
 const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
+  Object.freeze([
+    'checklist', 'list', 'liste', 'listen',
+  ]),
+  Object.freeze([
+    'aufgabe', 'aufgaben', 'aufgabenliste', 'todo', 'todos',
+  ]),
   Object.freeze([
     'current', 'inbox', 'latest', 'message', 'messages', 'nachricht', 'nachrichten', 'queue', 'queued',
     'recent', 'letzte', 'letzten', 'letzter', 'vergangen', 'update', 'updates',
@@ -195,7 +201,10 @@ function rankingTokens(value) {
 function toolRankingDocument(tool) {
   const name = String(tool?.name || '');
   const leaf = name.split(/__|:/).at(-1) || name;
-  const nameTokens = rankingTokens(`${name.replaceAll('_', ' ')} ${leaf.replaceAll('_', ' ')}`);
+  const splitToolName = (value) => String(value || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replaceAll('_', ' ');
+  const nameTokens = rankingTokens(`${splitToolName(name)} ${splitToolName(leaf)}`);
   const descriptionTokens = rankingTokens(tool?.description);
   const parameterText = [];
   const properties = tool?.parameters?.properties;
@@ -247,14 +256,18 @@ function rankedToolNamesForTurnText(tools, value, options = {}) {
     let score = 0;
     let matchedTokens = 0;
     let exactNameMatches = 0;
+    let relatedNameMatches = 0;
     for (const token of queryTokens) {
       const tokenScore = tokenMatchScore(document, token);
       if (tokenScore === 0) continue;
       score += tokenScore;
       matchedTokens += 1;
       if (document.nameTokens.has(token)) exactNameMatches += 1;
+      else if (relatedSearchTerms(token).some((term) => document.nameTokens.has(term))) relatedNameMatches += 1;
     }
-    const highConfidence = matchedTokens >= 2 || (exactNameMatches >= 1 && score >= 10);
+    const highConfidence = matchedTokens >= 2
+      || (exactNameMatches >= 1 && score >= 10)
+      || (relatedNameMatches >= 1 && score >= 5);
     return highConfidence ? { name: document.name, score, matchedTokens, exactNameMatches } : null;
   }).filter(Boolean).sort((left, right) => (
     right.matchedTokens - left.matchedTokens