@lumi.ai/runner 0.15.18 → 0.15.20

package/dist/cli.js

@@ -63,6 +63,9 @@ var ENGINES = {
   claude: CLAUDE_ENGINE
 };
 var DEFAULT_ENGINE_ID = "claude";
+function listEngines() {
+  return Object.values(ENGINES);
+}
 function isKnownEngine(id) {
   return !!id && Object.hasOwn(ENGINES, id);
 }
@@ -82,6 +85,8 @@ function estimateCostUsd(engineId, modelId, tokens) {
   const fresh = Math.max(0, tokens.inputTokens - tokens.cachedInputTokens);
   return (fresh * model.rates.input + tokens.cachedInputTokens * model.rates.cachedInput + tokens.outputTokens * model.rates.output) / 1e6;
 }
+var AGENT_ENGINE_IDS = Object.freeze(listEngines().map((e) => e.id));
+var AGENT_MODEL_IDS = Object.freeze(listEngines().flatMap((e) => e.models.map((m) => m.id)));
 
 // ../shared/dist/agent.js
 var DEFAULT_AGENT_TOOLS = {
@@ -144,6 +149,41 @@ var ASSISTANT_PROFILE = Object.freeze({
   })
 });
 
+// ../shared/dist/assistantAuthority.js
+var ASSISTANT_TOOL_AUTHORITY = Object.freeze({
+  // Reads. Everything the asker could open in the app.
+  ship_info: "member",
+  agent_list: "member",
+  task_list: "member",
+  task_get: "member",
+  knowledge_get: "member",
+  chat_get: "member",
+  // Writes a member can already make by clicking.
+  task_create: "member",
+  task_comment: "member",
+  task_update_status: "member",
+  task_relate: "member",
+  task_assign: "member",
+  knowledge_write: "member",
+  chat_send: "member",
+  // Captain-only, because the rules say so for a direct write — and `agent_write` also bills.
+  agent_write: "captain",
+  workflow_write: "captain",
+  knowledge_folder: "captain"
+});
+var ASSISTANT_NEVER_REGISTER = Object.freeze([
+  "approval_decide",
+  "approval_request",
+  "memory_write",
+  "media_attach"
+]);
+var ASSISTANT_FROZEN_ARGS = Object.freeze({
+  agent_write: Object.freeze(["tools"])
+});
+
+// ../shared/dist/toolStats.js
+var TOOL_STATS_HALF_LIFE_MS = 14 * 24 * 60 * 60 * 1e3;
+
 // ../shared/dist/browser.js
 var BROWSER_ONLINE_WINDOW_MS = 9e4;
 var DEFAULT_BROWSER_CONSENT_MS = 60 * 60 * 1e3;
@@ -332,6 +372,8 @@ var COLLECTIONS = {
   engineLimits: "engine_limits",
   /** `ships/{shipId}/events/{id}` — append-only Ship-level audit log. */
   events: "events",
+  /** §15.70: per-actor tool usage, so the assistant declares what it actually reaches for. */
+  toolStats: "toolStats",
   /** `ships/{shipId}/secrets/{docId}` — runner creds + MCP token hash (see secrets.ts). */
   secrets: "secrets",
   /**
@@ -1023,7 +1065,7 @@ function mcpUrl(config2) {
 }
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.15.18" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.15.20" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -2085,16 +2127,40 @@ function detectClaudeLimit(text, now, fallbackMs) {
     detail: text.trim().slice(0, 300)
   };
 }
-function workspaceMcpProblem(initEvent, required) {
-  if (!required) return null;
+function expectedMcpServers(agent, extraServers = []) {
+  const out = [];
+  if (effectiveAgentTools(agent).workspaceMcp) {
+    out.push({ key: WORKSPACE_MCP_KEY, label: "the Workspace MCP" });
+  }
+  for (const s of extraServers) out.push({ key: s.key, label: s.name || s.key });
+  return out;
+}
+function mcpConnectionFailures(initEvent, expected) {
+  if (expected.length === 0) return [];
+  const byKey = new Map(expected.map((e) => [e.key, e]));
+  const found = /* @__PURE__ */ new Map();
   const errors = initEvent.mcp_server_errors;
-  if (!Array.isArray(errors)) return null;
-  const mine = errors.find(
-    (e) => e && typeof e === "object" && e.name === WORKSPACE_MCP_KEY
-  );
-  if (!mine) return null;
-  const detail = mine.message || mine.type || "no reason given";
-  return `The Claude CLI refused to load the Workspace MCP ("${WORKSPACE_MCP_KEY}"): ${detail}. The session would have had none of this Ship's tools \u2014 no task_comment, no run_report, no chat_send \u2014 so it was stopped instead of run blind. This is a runner/CLI mismatch on this machine: update the daemon (\`npm i -g @lumi.ai/runner\`) and the Claude CLI, then retry.`;
+  if (Array.isArray(errors)) {
+    for (const e of errors) {
+      if (!e || typeof e !== "object" || typeof e.name !== "string") continue;
+      const want = byKey.get(e.name);
+      if (want) found.set(want.key, { ...want, detail: e.message || e.type || "no reason given" });
+    }
+  }
+  const servers = initEvent.mcp_servers;
+  if (Array.isArray(servers)) {
+    for (const s of servers) {
+      if (!s || typeof s !== "object" || typeof s.name !== "string") continue;
+      const want = byKey.get(s.name);
+      if (want && s.status !== "connected" && !found.has(want.key)) {
+        found.set(want.key, { ...want, detail: `status "${s.status ?? "unknown"}"` });
+      }
+    }
+  }
+  return [...found.values()];
+}
+function workspaceRefusal(failure) {
+  return `The Claude CLI did not load ${failure.label} ("${failure.key}"): ${failure.detail}. The session would have had none of this Ship's tools \u2014 no task_comment, no run_report, no chat_send \u2014 so it was stopped instead of run blind. If this keeps happening, update the daemon (\`npm i -g @lumi.ai/runner\`) and the Claude CLI on this machine.`;
 }
 function allowedTools(agent, extraServers = []) {
   const granted = effectiveAgentTools(agent);
@@ -2202,6 +2268,21 @@ async function runSession(input, bin, dirs) {
   const claudeToken = input.secrets?.claudeToken;
   const env = {
     ...process.env,
+    // THE INIT EVENT MUST BE TRUTHFUL, and one inherited variable is enough to make it lie.
+    //
+    // `MCP_CONNECTION_NONBLOCKING` lets the CLI start before its MCP servers have settled. The init
+    // event then reports `mcp_servers: []` with no status and no error — indistinguishable from a
+    // server that failed — while the connection completes moments later. `mcpConnectionFailures`
+    // reads that event and can only be as honest as it is, so a daemon started from a shell that
+    // happens to set this would either miss every blind session or refuse every healthy one.
+    //
+    // It is DELETED rather than set to a value, because "off" for these is absence: the CLI reads
+    // the variable's presence. A daemon is a long-lived process started from somebody's terminal,
+    // an npm script, or a launchd unit, and it must not inherit a decision about its own
+    // observability from any of them. Found the hard way — every local session for a day reported
+    // an empty server list because the shell that launched the daemon set this.
+    MCP_CONNECTION_NONBLOCKING: void 0,
+    MCP_SERVER_CONNECTION_BATCH_SIZE: void 0,
     ...claudeToken ? { CLAUDE_CODE_OAUTH_TOKEN: claudeToken } : {},
     ...input.githubToken ? {
       GH_TOKEN: input.githubToken,
@@ -2222,6 +2303,8 @@ async function runSession(input, bin, dirs) {
   let resultEvent = null;
   let mcpProblem = null;
   const workspaceRequired = effectiveAgentTools(input.agent).workspaceMcp;
+  const expectedServers = expectedMcpServers(input.agent, input.extraMcpServers ?? []);
+  const mcpFailed = [];
   const mcpWatch = createWorkspaceMcpWatch();
   const exitCode = await new Promise((resolve) => {
     const child = spawn3(bin, args, { cwd: dirs.workdir, env, stdio: ["ignore", "pipe", "pipe"] });
@@ -2259,7 +2342,14 @@ async function runSession(input, bin, dirs) {
           if (event.type === "result") resultEvent = event;
           if (event.type === "assistant") input.log("claude: assistant turn");
           if (event.type === "system" && event.subtype === "init" && !mcpProblem) {
-            stopBlindSession(workspaceMcpProblem(event, workspaceRequired));
+            for (const failure of mcpConnectionFailures(event, expectedServers)) {
+              if (failure.key === WORKSPACE_MCP_KEY) {
+                stopBlindSession(workspaceRefusal(failure));
+                continue;
+              }
+              input.log(`MCP connection "${failure.key}" did not load: ${failure.detail}.`);
+              if (!mcpFailed.includes(failure.key)) mcpFailed.push(failure.key);
+            }
           }
           if (workspaceRequired && !mcpProblem) {
             stopBlindSession(mcpWatch.observe(event));
@@ -2307,7 +2397,8 @@ ${stderrLines.slice(-20).join("\n")}`,
 `,
     usage,
     resultText: resultText2,
-    ...limit3 ? { limit: limit3 } : {}
+    ...limit3 ? { limit: limit3 } : {},
+    ...mcpFailed.length ? { mcpFailed } : {}
   };
 }
 var CLAUDE_DRIVER_ID = "claude";
@@ -3106,7 +3197,7 @@ async function markChatFailed(db, shipId, job, error) {
 ${error.slice(0, 500)}
 \`\`\`
 
-Write again to start a fresh run.`;
+Use Try again above to run it once more.`;
   await addDoc(collection6(chatRef, COLLECTIONS.chatMessages), {
     author: { type: "agent", id: job.agentId },
     content,
@@ -3116,8 +3207,45 @@ Write again to start a fresh run.`;
   });
 }
 var REPLY_SCAN_LIMIT = 20;
+var NARRATION_MARKERS = [
+  // Our own heading and the harness's own word for the block above it — see `chatStandingRules`.
+  /\bsystem prompt\b/i,
+  /\bstanding rules\b/i,
+  // "Based on my available tools, …"
+  /\bmy (?:available |current )?tools?\b/i,
+  // "Let me check what tools I do have access to."
+  /\btools?\b[^.?!]{0,40}\bI (?:do )?have access to\b/i,
+  // Both orders of "<the toolbox> is <missing>", bounded to one sentence so a paragraph that
+  // merely mentions tools and, later, something being unavailable does not match.
+  /\b(?:mcp|tools?)\b[^.?!]{0,60}\b(?:not available|unavailable|(?:are|is)n'?t available|not connected|not loaded|no access)\b/i,
+  /\b(?:not available|unavailable|no access|(?:do not|don'?t|does not|doesn'?t) have access)\b[^.?!]{0,60}\b(?:mcp|tools?)\b/i
+];
+function isSessionNarration(paragraph) {
+  if (paragraph.includes("```")) return false;
+  if (!/\b(?:i|i'm|i'll|i've|my|me)\b/i.test(paragraph)) return false;
+  return NARRATION_MARKERS.some((re) => re.test(paragraph));
+}
+function paragraphsWithOffsets(text) {
+  const out = [];
+  const breaks = /\n{2,}/g;
+  let start = 0;
+  let m;
+  while ((m = breaks.exec(text)) !== null) {
+    out.push({ text: text.slice(start, m.index), start });
+    start = m.index + m[0].length;
+  }
+  out.push({ text: text.slice(start), start });
+  return out;
+}
+function stripSessionNarration(text) {
+  const paragraphs = paragraphsWithOffsets(text);
+  let dropped = 0;
+  while (dropped < paragraphs.length && isSessionNarration(paragraphs[dropped].text)) dropped += 1;
+  if (dropped === 0 || dropped === paragraphs.length) return text;
+  return text.slice(paragraphs[dropped].start).trim();
+}
 function backstopReplyContent(resultText2) {
-  const text = resultText2.trim();
+  const text = stripSessionNarration(resultText2.trim());
   if (!text) {
     return "I finished that run without writing a reply. Write again to start a fresh one.";
   }
@@ -4402,6 +4530,7 @@ async function startDaemon() {
     let engineId = DEFAULT_ENGINE_ID;
     let transcript = "";
     let resultText2 = "";
+    let mcpConnected = [];
     let usage = {
       engine: DEFAULT_ENGINE_ID,
       inputTokens: 0,
@@ -4574,6 +4703,8 @@ async function startDaemon() {
         armLimitTimer();
       }
       resultText2 = session.resultText;
+      const failed = new Set(session.mcpFailed ?? []);
+      mcpConnected = extraMcpServers.map((s) => s.key).filter((k) => !failed.has(k));
       if (!session.ok) failure = session.resultText || "Session failed.";
     } catch (e) {
       failure = e instanceof Error ? e.message : String(e);
@@ -4597,7 +4728,7 @@ async function startDaemon() {
           // mid-thought, so it almost certainly never reached `run_report` — and whatever it had
           // got to is what the next run on this task would otherwise have to rediscover.
           resultText: resultText2,
-          mcpServers: extraMcpServers.map((s) => s.key)
+          mcpServers: mcpConnected
         });
         const by = slot.stop.by;
         if (target.kind === "chat") {
@@ -4647,7 +4778,7 @@ async function startDaemon() {
           // §15.41. Only used when the session never called `run_report` — the ordinary path is
           // that it did, and a real report always wins inside the transaction.
           resultText: resultText2,
-          mcpServers: extraMcpServers.map((s) => s.key)
+          mcpServers: mcpConnected
         });
         log2(`Job ${job.id} done (${usage.inputTokens}in/${usage.outputTokens}out tokens).`);
         let delivery = "agent-replied";
@@ -4704,7 +4835,7 @@ async function startDaemon() {
           // is spent — starts from the context pack alone. `error` is the tail for a human; this
           // is the continuity for the next session, and they are read by different readers.
           resultText: resultText2,
-          mcpServers: extraMcpServers.map((s) => s.key)
+          mcpServers: mcpConnected
         });
         if (target.kind === "chat") {
           await markChatFailed(sess(shipId).fb.db, shipId, { ...job, chatId: target.chatId }, failure);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi.ai/runner",
-  "version": "0.15.18",
+  "version": "0.15.20",
   "type": "module",
   "description": "Lumi Crew runner daemon — claims jobs from your Ships and executes them as headless Claude sessions on your own machine.",
   "//name": "The ONLY package in this monorepo published to the public registry, so it is the one that does not follow the internal @lumi/crew-* convention: `@lumi` is not a scope we own, `@lumi.ai` is (the npm org). The workspace DIRECTORY stays packages/crew/runner — renaming the package is not renaming the folder.",