blun-king-cli 9.1.563 → 9.1.565

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

@@ -1 +1 @@
-export const VERSION = "0.49.0";
+export const VERSION = "0.54.0";

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

@@ -1,195 +1,202 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { watch } from "node:fs";
-import { lstat, realpath } from "node:fs/promises";
-import { isAbsolute, join, 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"]);
-
-async function wakeSnapshot(directory) {
-  return Promise.all([...WAKE_FILES].sort().map(async (name) => {
-    try {
-      const metadata = await lstat(join(directory, name), { bigint: true });
-      return `${name}:${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeNs}`;
-    } catch (error) {
-      if (error.code === "ENOENT") return `${name}:missing`;
-      throw error;
-    }
-  })).then((entries) => entries.join("\n"));
-}
-
-export async function waitForGatewayWake(root, delayMs, { watchFactory = watch, realpathFactory = realpath, onReady = null } = {}) {
-  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"; }
-  let before;
-  try { before = await wakeSnapshot(watchPath); } 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"));
-      Promise.resolve().then(() => onReady?.(watchPath)).then(() => wakeSnapshot(watchPath)).then((after) => {
-        if (after !== before) finish("event");
-      }).catch(() => 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; });
-}
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { watch } from "node:fs";
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, join, 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"]);
+
+async function wakeSnapshot(directory) {
+  return Promise.all([...WAKE_FILES].sort().map(async (name) => {
+    try {
+      const metadata = await lstat(join(directory, name), { bigint: true });
+      return `${name}:${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeNs}`;
+    } catch (error) {
+      if (error.code === "ENOENT") return `${name}:missing`;
+      throw error;
+    }
+  })).then((entries) => entries.join("\n"));
+}
+
+export async function waitForGatewayWake(root, delayMs, { watchFactory = watch, realpathFactory = realpath, onReady = null } = {}) {
+  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"; }
+  let before;
+  try { before = await wakeSnapshot(watchPath); } 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"));
+      Promise.resolve().then(() => onReady?.(watchPath)).then(() => wakeSnapshot(watchPath)).then((after) => {
+        if (after !== before) finish("event");
+      }).catch(() => 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 goalStep = item.goalStepId === null || item.goalStepId === undefined ? null
+    : goal?.plan?.steps.find((entry) => entry.stepId === item.goalStepId) || null;
+  if (item.goalStepId && !goalStep) throw new Error("claimed work lost its exact goal-plan step");
+  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, goalStep: goalStep ? structuredClone(goalStep) : 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.clarification ? "needs-clarification" : completed.item.status,
+    processed: true, queueId: completed.item.queueId,
+    ...(completed.clarification ? { clarification: completed.clarification } : {})
+  };
+  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/active-steer-priority-policy.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const ACTIVE_STEER_INTERRUPT_CODE = 'BLUN_ACTIVE_STEER_INTERRUPT';
+const ACTIVE_STEER_PRIORITY_REMINDER = [
+  'A newer user steer is the highest-priority next action.',
+  'Act on it now with the available tools. Do not continue an idle prompt or ask for another task.',
+].join(' ');
+
+function createActiveSteerInterrupt() {
+  const error = new Error('Active model request superseded by a newer user steer');
+  error.code = ACTIVE_STEER_INTERRUPT_CODE;
+  return error;
+}
+
+function isActiveSteerInterrupt(error) {
+  return error?.code === ACTIVE_STEER_INTERRUPT_CODE;
+}
+
+module.exports = {
+  ACTIVE_STEER_INTERRUPT_CODE,
+  ACTIVE_STEER_PRIORITY_REMINDER,
+  createActiveSteerInterrupt,
+  isActiveSteerInterrupt,
+};

package/bin/launcher-runtime.js

@@ -31,7 +31,10 @@ const {
 const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
-const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
+const {
+  resolveMnemoProfileConnectConfig,
+  startMnemoConnectHeartbeat,
+} = require('./mnemo-connect-heartbeat.cjs');
 const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 const { acquireSharedRuntimeLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
@@ -539,10 +542,14 @@ async function runLauncher(options = {}) {
     env.BLUN_SHARED_HOME = privatePaths.sharedHome;
     env.BLUN_LOG_HOME = privatePaths.sharedHome;
     env.BLUN_PROFILE = PROFILE.profileName;
+    const mnemoProfileConfig = resolveMnemoProfileConnectConfig(path.join(profilePaths.home, 'mcp.json'));
+    if (mnemoProfileConfig?.agentName) env.MNEMO_AGENT = mnemoProfileConfig.agentName;
+    if (mnemoProfileConfig?.baseUrl) env.BLUN_MNEMO_HUB_URL = mnemoProfileConfig.baseUrl;
     const mnemoConnect = startMnemoConnectHeartbeat({
       env,
       profileName: PROFILE.profileName,
       mcpConfigPath: path.join(profilePaths.home, 'mcp.json'),
+      profileConfig: mnemoProfileConfig,
       version: readPackageVersion(),
     });
     try {

package/bin/mnemo-tool-agent-policy.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const MNEMO_TOOL_PREFIX = 'mcp__mnemo__';
+
+function configuredMnemoAgent(env = process.env) {
+  const value = typeof env.MNEMO_AGENT === 'string' ? env.MNEMO_AGENT.trim() : '';
+  return value && !/[\u0000-\u001f\u007f]/u.test(value) && value.length <= 128 ? value : null;
+}
+
+function applyMnemoAgentToToolArgs(toolName, args, env = process.env) {
+  if (typeof toolName !== 'string' || !toolName.toLowerCase().startsWith(MNEMO_TOOL_PREFIX)) return args;
+  if (!args || typeof args !== 'object' || Array.isArray(args) || !Object.hasOwn(args, 'agent_name')) return args;
+  const agentName = configuredMnemoAgent(env);
+  if (!agentName || args.agent_name === agentName) return args;
+  return { ...args, agent_name: agentName };
+}
+
+module.exports = {
+  MNEMO_TOOL_PREFIX,
+  applyMnemoAgentToToolArgs,
+  configuredMnemoAgent,
+};

package/bin/thinking-activity-status-policy.cjs

@@ -0,0 +1,132 @@
+'use strict';
+
+const ACTIVITY_CHANGE_INTERVAL_MS = 3_000;
+
+const THINKING_ACTIVITY_WORDS = Object.freeze({
+  Thinking: Object.freeze([
+    'Thinkering', 'Reasoning', 'Pondering', 'Analyzing', 'Exploring',
+    'Connecting', 'Unraveling', 'Imagining', 'Envisioning', 'Strategizing',
+    'Deciphering', 'Framing', 'Ideating', 'Synthesizing', 'Reflecting',
+  ]),
+  Planning: Object.freeze([
+    'Architecting', 'Blueprinting', 'Structuring', 'Orchestrating', 'Sequencing',
+    'Scoping', 'Prioritizing', 'Coordinating', 'Decomposing', 'Aligning',
+    'Roadmapping', 'Modeling', 'Designing', 'Drafting', 'Preparing',
+  ]),
+  Researching: Object.freeze([
+    'Searching', 'Browsing', 'Discovering', 'Investigating', 'Examining',
+    'Inspecting', 'Tracing', 'Comparing', 'Verifying', 'Cross-checking',
+    'Fact-finding', 'Source-hunting', 'Deep-diving', 'Contextualizing', 'Evidence-gathering',
+  ]),
+  Building: Object.freeze([
+    'Building', 'Crafting', 'Coding', 'Engineering', 'Assembling',
+    'Integrating', 'Implementing', 'Wiring', 'Configuring', 'Compiling',
+    'Rendering', 'Generating', 'Prototyping', 'Shaping', 'Forging',
+  ]),
+  Solving: Object.freeze([
+    'Debugging', 'Diagnosing', 'Troubleshooting', 'Untangling', 'Repairing',
+    'Patching', 'Resolving', 'Reworking', 'Refining', 'Optimizing',
+    'Simplifying', 'Stabilizing', 'Recovering', 'Calibrating', 'Tuning',
+  ]),
+  Validating: Object.freeze([
+    'Testing', 'Validating', 'Reviewing', 'Auditing', 'Proofreading',
+    'Measuring', 'Benchmarking', 'Stress-testing', 'Safeguarding', 'Hardening',
+    'Polishing', 'Fine-tuning', 'Checking', 'Confirming', 'Certifying',
+  ]),
+  Processing: Object.freeze([
+    'Reading', 'Parsing', 'Indexing', 'Remembering', 'Recalling',
+    'Organizing', 'Classifying', 'Filtering', 'Sorting', 'Matching',
+    'Merging', 'Summarizing', 'Compressing', 'Transforming', 'Learning',
+  ]),
+  Collaborating: Object.freeze([
+    'Delegating', 'Collaborating', 'Consulting', 'Briefing', 'Dispatching',
+    'Synchronizing', 'Negotiating', 'Handshaking', 'Queuing', 'Routing',
+    'Supervising', 'Monitoring', 'Reconciling', 'Reporting', 'Converging',
+  ]),
+  Creating: Object.freeze([
+    'Writing', 'Rewriting', 'Translating', 'Localizing', 'Narrating',
+    'Explaining', 'Illustrating', 'Visualizing', 'Formatting', 'Styling',
+    'Presenting', 'Documenting', 'Captioning', 'Storyboarding', 'Publishing',
+  ]),
+  'BLUN Magic': Object.freeze([
+    'BLUNing', 'Sparkering', 'Wondermaking', 'Dreamweaving', 'Futurecrafting',
+    'Brightening', 'Flowing', 'Accelerating', 'Automating', 'Empowering',
+    'Launching', 'Scaling', 'Evolving', 'Delivering', 'Finishing',
+  ]),
+});
+
+const EVIDENCE_KEYS = new Set([
+  'command', 'cmd', 'description', 'file', 'file_path', 'path', 'pattern',
+  'prompt', 'query', 'task', 'title', 'url',
+]);
+
+function activityEvidence(toolCall) {
+  if (!toolCall || typeof toolCall !== 'object') return '';
+  const values = [toolCall.name];
+  const args = toolCall.args;
+  if (args && typeof args === 'object' && !Array.isArray(args)) {
+    for (const [key, value] of Object.entries(args)) {
+      if (!EVIDENCE_KEYS.has(key.toLowerCase())) continue;
+      if (typeof value === 'string') values.push(value.slice(0, 2_000));
+    }
+  } else if (typeof toolCall.argumentsText === 'string') {
+    values.push(toolCall.argumentsText.slice(0, 2_000));
+  }
+  return values.filter(Boolean).join(' ').toLowerCase();
+}
+
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => text.includes(pattern));
+}
+
+function inferThinkingActivityGroup(toolCall, options = {}) {
+  if (options.completing === true) return 'BLUN Magic';
+  if (options.retrying === true || options.failed === true) return 'Solving';
+
+  const name = typeof toolCall?.name === 'string' ? toolCall.name.toLowerCase() : '';
+  const evidence = activityEvidence(toolCall);
+  if (!name) return 'Thinking';
+  if (name === 'todolist' || matchesAny(evidence, [' plan', 'roadmap', 'architect', 'scope'])) return 'Planning';
+  if (matchesAny(name, ['agent', 'swarm', 'telegram']) || matchesAny(evidence, ['delegate', 'handoff', 'telegram', 'report to'])) return 'Collaborating';
+  if (matchesAny(name, ['mnemo', 'memory', 'compact']) || matchesAny(evidence, ['memory', 'mnemo', 'compact', 'summar', 'index'])) return 'Processing';
+  if (matchesAny(name, ['grep', 'glob', 'search', 'webfetch', 'web_fetch', 'websearch', 'web_search', 'ls']) || matchesAny(evidence, ['search', 'find ', 'inspect', 'trace'])) return 'Researching';
+  if (matchesAny(evidence, ['publish', 'release', 'deploy', 'launch', 'deliver', 'finish'])) return 'BLUN Magic';
+  if (matchesAny(evidence, ['error', 'fail', 'debug', 'diagnos', 'repair', 'patch', 'fix ', 'recover', 'troubleshoot'])) return 'Solving';
+  if (matchesAny(evidence, ['test', 'check', 'verify', 'validat', 'audit', 'benchmark', 'measure', 'compare', 'sha256', 'diff '])) return 'Validating';
+  if (name === 'read' || name === 'readbatch') return 'Processing';
+  if (name === 'write' || name === 'edit') {
+    if (matchesAny(evidence, ['.md', '.txt', 'readme', 'changelog', 'document', 'translat', 'localiz'])) return 'Creating';
+    return 'Building';
+  }
+  if (matchesAny(name, ['bash', 'shell', 'programmatictool']) || matchesAny(evidence, ['build', 'compile', 'npm ', 'node ', 'code'])) return 'Building';
+  return 'Processing';
+}
+
+class ThinkingActivityRotator {
+  constructor(changeIntervalMs = ACTIVITY_CHANGE_INTERVAL_MS) {
+    this.changeIntervalMs = Math.max(ACTIVITY_CHANGE_INTERVAL_MS, Number(changeIntervalMs) || 0);
+    this.currentWord = undefined;
+    this.changedAtMs = undefined;
+    this.nextIndexByGroup = new Map();
+  }
+
+  resolve(group, nowMs = Date.now()) {
+    const safeGroup = Object.hasOwn(THINKING_ACTIVITY_WORDS, group) ? group : 'Thinking';
+    const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+    if (this.currentWord !== undefined && now - this.changedAtMs < this.changeIntervalMs) return this.currentWord;
+
+    const words = THINKING_ACTIVITY_WORDS[safeGroup];
+    const index = this.nextIndexByGroup.get(safeGroup) ?? 0;
+    this.currentWord = words[index % words.length];
+    this.nextIndexByGroup.set(safeGroup, (index + 1) % words.length);
+    this.changedAtMs = now;
+    return this.currentWord;
+  }
+}
+
+module.exports = {
+  ACTIVITY_CHANGE_INTERVAL_MS,
+  THINKING_ACTIVITY_WORDS,
+  ThinkingActivityRotator,
+  inferThinkingActivityGroup,
+};