talon-agent 1.36.0 → 1.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.36.0",
+  "version": "1.37.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/backend/claude-sdk/handler.ts

@@ -336,7 +336,7 @@ export async function* runChatTurn(
         }
 
         for (const tool of result.tools) {
-          recordToolCall(tool.name, "claude");
+          recordToolCall(chatId, tool.name, "claude");
           captureIntoState(tool.name, tool.input);
           if (isTurnTerminator(tool.name, tool.input)) {
             state.turnTerminated = true;
@@ -487,6 +487,7 @@ export async function* runChatTurn(
 
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "claude",
     durationMs,
     toolCalls: state.toolCalls,
@@ -543,7 +544,10 @@ export async function* runChatTurn(
     : ({ violated: false } as const);
 
   if (violation.violated) {
-    recordFlowViolation(violation.shouldRetry ? "retried" : "cap_exhausted");
+    recordFlowViolation(
+      chatId,
+      violation.shouldRetry ? "retried" : "cap_exhausted",
+    );
     log(
       "agent",
       `[${chatId}] flow violation: ${violation.reason}. ${

package/src/backend/codex/handler/events.ts

@@ -182,7 +182,7 @@ function recordCodexToolMetric(
   // Shared vocabulary: `tool_calls.<bare>` (prefix-stripped, so codex
   // MCP calls land on the same keys as every other backend) plus the
   // `backend.codex.tool_calls` dimension.
-  recordToolCall(toolName, "codex");
+  recordToolCall(ctx.chatId, toolName, "codex");
   ctx.codexToolMetrics.count += 1;
 }
 

package/src/backend/codex/handler/message.ts

@@ -571,6 +571,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(streamState);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "codex",
     durationMs,
     toolCalls: codexToolMetrics.count,

package/src/backend/kilo/handler/message.ts

@@ -220,6 +220,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(state);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "kilo",
     durationMs,
     toolCalls: state.toolCalls,

package/src/backend/kilo/handler/turn.ts

@@ -289,6 +289,7 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
       }
 
       const outcome = await processStreamEvent(event, {
+        chatId,
         sessionId,
         state,
         seenToolCallIds,

package/src/backend/openai-agents/handler/events.ts

@@ -103,7 +103,7 @@ function handleToolCalled(item: unknown, ctx: HandleRunItemContext): void {
     }
   }
 
-  recordToolCall(toolName, "openai-agents");
+  recordToolCall(ctx.chatId, toolName, "openai-agents");
   recordToolUse(ctx.state, toolName, input);
 
   if (ctx.onToolUse) {

package/src/backend/openai-agents/handler/message.ts

@@ -398,6 +398,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(streamState);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "openai-agents",
     durationMs,
     toolCalls: streamState.toolCalls,
@@ -443,7 +444,10 @@ export async function handleMessage(
       : ({ violated: false } as const);
 
   if (violation.violated) {
-    recordFlowViolation(violation.shouldRetry ? "retried" : "cap_exhausted");
+    recordFlowViolation(
+      chatId,
+      violation.shouldRetry ? "retried" : "cap_exhausted",
+    );
     log(
       "agent",
       `[${chatId}] flow violation: trailing prose (${violation.trailing.length} chars) without end_turn/send. ${

package/src/backend/opencode/handler/message.ts

@@ -232,6 +232,7 @@ export async function handleMessage(
   const responseText = finalizeResponseText(state);
   const durationMs = Date.now() - t0;
   recordTurnMetrics({
+    chatId,
     backend: "opencode",
     durationMs,
     toolCalls: state.toolCalls,

package/src/backend/opencode/handler/turn.ts

@@ -277,6 +277,7 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
       }
 
       const outcome = await processStreamEvent(event, {
+        chatId,
         sessionId,
         state,
         seenToolCallIds,

package/src/backend/remote-server/events.ts

@@ -63,6 +63,8 @@ export type ProcessEventOutcome =
 
 /** Common context passed to the per-event helper. */
 export interface EventProcessingContext {
+  /** Chat id for session-scoped metrics. */
+  chatId: string;
   /** Session id we're scoped to — events for other sessions are dropped. */
   sessionId: string;
   /** Stream state accumulator (shared/). */
@@ -277,7 +279,7 @@ async function processPartUpdate(
   }
   // Count every tool the model calls — shared vocabulary across
   // backends (prefix-stripped name + backend dimension).
-  recordToolCall(toolName, ctx.backendLabel.toLowerCase());
+  recordToolCall(ctx.chatId, toolName, ctx.backendLabel.toLowerCase());
   recordToolUse(ctx.state, toolName, input);
   if (ctx.onToolUse) {
     try {

package/src/backend/shared/metrics.ts

@@ -38,10 +38,14 @@
  * registry. Never interpolate chat ids, model ids, or user input.
  */
 
-import { incrementCounter, recordHistogram } from "../../util/metrics.js";
 import { stripMcpPrefix } from "../../core/tools/index.js";
-import { cacheHitPercent, type TokenUsageSnapshot } from "./usage.js";
-import { clearLiveTurn, recordUsage } from "../../storage/sessions.js";
+import type { TokenUsageSnapshot } from "./usage.js";
+import {
+  clearLiveTurn,
+  recordSessionMetricEvent,
+  recordSessionMetrics,
+  recordUsage,
+} from "../../storage/sessions.js";
 
 /**
  * Count one tool call. `toolName` may be raw from any backend —
@@ -49,13 +53,21 @@ import { clearLiveTurn, recordUsage } from "../../storage/sessions.js";
  * (`talon-tools-123_send`), or bare — it is normalised so every
  * backend lands on the same `tool_calls.<bare>` key.
  */
-export function recordToolCall(toolName: string, backend?: string): void {
-  incrementCounter(`tool_calls.${stripMcpPrefix(toolName)}`);
-  if (backend) incrementCounter(`backend.${backend}.tool_calls`);
+export function recordToolCall(
+  chatId: string,
+  toolName: string,
+  backend?: string,
+): void {
+  recordSessionMetricEvent(chatId, {
+    toolCalls: 1,
+    toolName: stripMcpPrefix(toolName),
+    backend,
+  });
 }
 
 /** Per-turn rollup recorded once at the end of every chat turn. */
 export type TurnMetricInputs = {
+  chatId: string;
   /** Backend id, e.g. "claude", "codex", "kilo", "openai-agents", "opencode". */
   backend: string;
   durationMs: number;
@@ -78,45 +90,7 @@ export type TurnMetricInputs = {
  * ("queries_total")` pairs (and codex's private `codex.*` family).
  */
 export function recordTurnMetrics(inputs: TurnMetricInputs): void {
-  recordHistogram("response_latency_ms", inputs.durationMs);
-  recordHistogram(
-    `backend.${inputs.backend}.response_latency_ms`,
-    inputs.durationMs,
-  );
-  incrementCounter("queries_total");
-  incrementCounter(`backend.${inputs.backend}.queries`);
-
-  if (inputs.failed) incrementCounter(`backend.${inputs.backend}.turn_failed`);
-
-  if (inputs.toolCalls !== undefined) {
-    recordHistogram("tool_calls_per_turn", inputs.toolCalls);
-    if (inputs.toolCalls > 0) incrementCounter("turns_with_tools_total");
-  }
-  if (inputs.apiCalls !== undefined && inputs.apiCalls > 0) {
-    incrementCounter("api_calls_total", inputs.apiCalls);
-    recordHistogram("api_calls_per_turn", inputs.apiCalls);
-  }
-
-  if (inputs.usage) {
-    const u = inputs.usage;
-    const b = `backend.${inputs.backend}`;
-    incrementCounter("tokens.input_total", u.inputTokens);
-    incrementCounter("tokens.output_total", u.outputTokens);
-    incrementCounter("tokens.cache_read_total", u.cacheRead);
-    incrementCounter("tokens.cache_write_total", u.cacheWrite);
-    incrementCounter(`${b}.tokens.input`, u.inputTokens);
-    incrementCounter(`${b}.tokens.output`, u.outputTokens);
-    incrementCounter(`${b}.tokens.cache_read`, u.cacheRead);
-    incrementCounter(`${b}.tokens.cache_write`, u.cacheWrite);
-    // Only meaningful when the turn actually consumed input — an
-    // all-zero snapshot (failed turn, usage-less backend) would skew
-    // the distribution with hard zeros.
-    if (u.inputTokens + u.cacheRead > 0) {
-      const pct = cacheHitPercent(u);
-      recordHistogram("cache_hit_percent", pct);
-      recordHistogram(`${b}.cache_hit_percent`, pct);
-    }
-  }
+  recordSessionMetrics(inputs.chatId, inputs);
 }
 
 /**
@@ -152,6 +126,7 @@ export function recordFailedTurnAccounting(inputs: {
   contextWindow?: number;
 }): void {
   recordTurnMetrics({
+    chatId: inputs.chatId,
     backend: inputs.backend,
     durationMs: inputs.durationMs,
     toolCalls: inputs.toolCalls,
@@ -188,12 +163,12 @@ export function recordFailedTurnAccounting(inputs: {
  * reminder" unanswerable for that backend.
  */
 export function recordFlowViolation(
+  chatId: string,
   outcome: "retried" | "cap_exhausted",
 ): void {
-  incrementCounter("scratchpad.trailing_text_dropped");
-  incrementCounter(
-    outcome === "retried"
-      ? "scratchpad.flow_violation_retried"
-      : "scratchpad.flow_violation_cap_exhausted",
-  );
+  recordSessionMetricEvent(chatId, {
+    trailingTextDropped: 1,
+    flowViolationRetries: outcome === "retried" ? 1 : 0,
+    flowViolationCapExhausted: outcome === "cap_exhausted" ? 1 : 0,
+  });
 }

package/src/core/engine/gateway-actions/native.ts

@@ -2,11 +2,11 @@
  * Native tools — Talon's own shell/filesystem tools, replacing the SDK's
  * built-in Bash/Read/Write/Edit/Glob/Grep when `config.nativeTools` is on.
  *
- * Their defining feature: every one checks the active `teleport` target. With
- * no teleport, they run on the daemon host (local spawn / local fs / local
- * ripgrep). With a teleport engaged, they run ON the companion device via the
- * mesh exec/fs channel — so `bash`/`read`/`write`/… transparently operate on
- * the phone. Talon acts as if it were running on whichever node is active.
+ * Their defining feature: every one checks the current chat's active
+ * `teleport` target. With no teleport for that chat, they run on the daemon
+ * host (local spawn / local fs / local ripgrep). With a teleport engaged, they
+ * run ON the companion device via the mesh exec/fs channel — so
+ * `bash`/`read`/`write`/… transparently operate on the phone for that chat.
  *
  *   teleport(device)  → native tools target that device
  *   teleport_back()   → native tools run locally again
@@ -31,6 +31,10 @@ import {
   setTeleport,
   setTeleportCwd,
 } from "../../mesh/teleport.js";
+import {
+  clampExecOutput,
+  createOutputCapture,
+} from "../../../util/exec-output.js";
 import type { SharedActionHandlers } from "./types.js";
 
 type Result = { ok: boolean; text: string };
@@ -56,33 +60,28 @@ const CWD_OPEN = "__TALON_CWD__";
 const CWD_CLOSE = "__TALON_CWD_END__";
 
 export const nativeHandlers: SharedActionHandlers = {
-  teleport: (body) => teleport(body.device),
-  teleport_back: () => teleportBack(),
-  native_bash: (body) => bash(body.command, body.cwd, body.timeout_sec),
-  native_read: (body) => read(body.path, body.offset, body.limit),
-  native_write: (body) => write(body.path, body.content),
-  native_edit: (body) =>
-    edit(body.path, body.old_string, body.new_string, body.replace_all),
-  native_glob: (body) => glob(body.pattern, body.path),
-  native_search: (body) =>
-    search(body.pattern, body.path, body.glob, body.case_insensitive),
+  teleport: (body, chatId) => teleport(chatId, body.device),
+  teleport_back: (_body, chatId) => teleportBack(chatId),
+  native_bash: (body, chatId) =>
+    bash(chatId, body.command, body.cwd, body.timeout_sec),
+  native_read: (body, chatId) =>
+    read(chatId, body.path, body.offset, body.limit),
+  native_write: (body, chatId) => write(chatId, body.path, body.content),
+  native_edit: (body, chatId) =>
+    edit(chatId, body.path, body.old_string, body.new_string, body.replace_all),
+  native_glob: (body, chatId) => glob(chatId, body.pattern, body.path),
+  native_search: (body, chatId) =>
+    search(chatId, body.pattern, body.path, body.glob, body.case_insensitive),
 };
 
 // ── Teleport control ────────────────────────────────────────────────────────
 
-async function teleport(query: unknown): Promise<Result> {
+async function teleport(chatId: number, query: unknown): Promise<Result> {
   const svc = getMeshService();
   await svc.list();
-  const target = svc.chooseDevice(query);
-  if (!target) {
-    return {
-      ok: false,
-      text:
-        typeof query === "string" && query.trim()
-          ? `No mesh device matches "${query}". Use list_devices to see them.`
-          : "No mesh device to teleport to. Register a companion first.",
-    };
-  }
+  const resolved = svc.resolveDevice(query);
+  if ("error" in resolved) return { ok: false, text: resolved.error };
+  const target = resolved.target;
   if (!target.online) {
     return {
       ok: false,
@@ -95,7 +94,7 @@ async function teleport(query: unknown): Promise<Result> {
       text: `${target.name} does not advertise the "exec" capability, so teleport can't run commands on it.`,
     };
   }
-  await setTeleport(target.id, target.name);
+  await setTeleport(chatId, target.id, target.name);
   return {
     ok: true,
     text: [
@@ -106,8 +105,8 @@ async function teleport(query: unknown): Promise<Result> {
   };
 }
 
-async function teleportBack(): Promise<Result> {
-  const prior = await clearTeleport();
+async function teleportBack(chatId: number): Promise<Result> {
+  const prior = await clearTeleport(chatId);
   return {
     ok: true,
     text: prior
@@ -119,6 +118,7 @@ async function teleportBack(): Promise<Result> {
 // ── bash ────────────────────────────────────────────────────────────────────
 
 async function bash(
+  chatId: number,
   command: unknown,
   cwd: unknown,
   timeoutSec: unknown,
@@ -126,8 +126,8 @@ async function bash(
   const cmd = typeof command === "string" ? command : "";
   if (!cmd.trim()) return { ok: false, text: "No command given." };
   const timeoutMs = clampTimeout(timeoutSec);
-  const active = await getTeleport();
-  if (active) return bashTeleported(active.deviceId, cmd, timeoutMs);
+  const active = await getTeleport(chatId);
+  if (active) return bashTeleported(chatId, active.deviceId, cmd, timeoutMs);
   return bashLocal(cmd, typeof cwd === "string" ? cwd : undefined, timeoutMs);
 }
 
@@ -145,8 +145,8 @@ function bashLocal(
       env: process.env,
       detached,
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout = createOutputCapture();
+    const stderr = createOutputCapture();
     let killed = false;
     const timer = setTimeout(() => {
       killed = true;
@@ -160,8 +160,8 @@ function bashLocal(
       }
       child.kill("SIGKILL");
     }, timeoutMs);
-    child.stdout.on("data", (d) => (stdout += d.toString()));
-    child.stderr.on("data", (d) => (stderr += d.toString()));
+    child.stdout.on("data", stdout.push);
+    child.stderr.on("data", stderr.push);
     child.on("error", (err) => {
       clearTimeout(timer);
       resolvePromise({ ok: false, text: `Failed to run: ${err.message}` });
@@ -173,18 +173,19 @@ function bashLocal(
         : `exit ${code ?? 0}`;
       resolvePromise({
         ok: !killed && (code ?? 0) === 0,
-        text: renderExec("local", exit, stdout, stderr),
+        text: renderExec("local", exit, stdout.value(), stderr.value()),
       });
     });
   });
 }
 
 async function bashTeleported(
+  chatId: number,
   deviceId: string,
   cmd: string,
   timeoutMs: number,
 ): Promise<Result> {
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   const cwd = active?.cwd;
   // Wrap so the resulting working dir is reported back and persists across
   // calls (a `cd` in `cmd` carries forward), while the real exit code is
@@ -204,6 +205,8 @@ async function bashTeleported(
   const data = result.data ?? {};
   let stdout = typeof data.stdout === "string" ? data.stdout : "";
   const stderr = typeof data.stderr === "string" ? data.stderr : "";
+  const via =
+    typeof data.via === "string" && data.via ? ` via ${data.via}` : "";
   const exitCode =
     typeof data.exitCode === "number" ? data.exitCode : undefined;
   // Recover + strip the trailing cwd marker.
@@ -213,7 +216,7 @@ async function bashTeleported(
     if (close !== -1) {
       const newCwd = stdout.slice(open + CWD_OPEN.length, close).trim();
       stdout = stdout.slice(0, open);
-      if (newCwd) await setTeleportCwd(newCwd);
+      if (newCwd) await setTeleportCwd(chatId, newCwd);
     }
   }
   if (!result.ok && exitCode === undefined) {
@@ -224,13 +227,19 @@ async function bashTeleported(
   }
   return {
     ok: exitCode === 0,
-    text: renderExec(target.name, `exit ${exitCode ?? "?"}`, stdout, stderr),
+    text: renderExec(
+      `${target.name}${via}`,
+      `exit ${exitCode ?? "?"}`,
+      stdout,
+      stderr,
+    ),
   };
 }
 
 // ── read / write / edit ─────────────────────────────────────────────────────
 
 async function read(
+  chatId: number,
   path: unknown,
   offset: unknown,
   limit: unknown,
@@ -239,7 +248,7 @@ async function read(
   if (!p) return { ok: false, text: "A file path is required." };
   const start = num(offset) ?? 0;
   const max = Math.min(num(limit) ?? MAX_READ_LINES, MAX_READ_LINES);
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   let content: string;
   let where: string;
   if (active) {
@@ -270,11 +279,15 @@ async function read(
   };
 }
 
-async function write(path: unknown, content: unknown): Promise<Result> {
+async function write(
+  chatId: number,
+  path: unknown,
+  content: unknown,
+): Promise<Result> {
   const p = str(path);
   if (!p) return { ok: false, text: "A file path is required." };
   const body = typeof content === "string" ? content : "";
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   if (active) {
     return getMeshService().writeFileToDevice(active.deviceId, p, body);
   }
@@ -288,6 +301,7 @@ async function write(path: unknown, content: unknown): Promise<Result> {
 }
 
 async function edit(
+  chatId: number,
   path: unknown,
   oldString: unknown,
   newString: unknown,
@@ -299,7 +313,7 @@ async function edit(
   const to = typeof newString === "string" ? newString : "";
   if (from === to)
     return { ok: false, text: "old_string and new_string are identical." };
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   const svc = getMeshService();
 
   let content: string;
@@ -350,11 +364,15 @@ async function edit(
 
 // ── glob / search ───────────────────────────────────────────────────────────
 
-async function glob(pattern: unknown, path: unknown): Promise<Result> {
+async function glob(
+  chatId: number,
+  pattern: unknown,
+  path: unknown,
+): Promise<Result> {
   const pat = str(pattern);
   if (!pat) return { ok: false, text: "A glob pattern is required." };
   const root = str(path) ?? ".";
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   if (active) {
     // Prefer rg on the device; fall back to find (basename patterns via
     // -name, path patterns via -path). `command -v` gates the choice so a
@@ -366,7 +384,7 @@ async function glob(pattern: unknown, path: unknown): Promise<Result> {
       `if command -v rg >/dev/null 2>&1; ` +
       `then rg --files -g ${shellQuote(pat)} ${shellQuote(root)}; ` +
       `else find ${shellQuote(root)} ${findExpr} 2>/dev/null; fi`;
-    return bashTeleported(active.deviceId, cmd, 30_000);
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
   }
   const res = await runLocal(rgBin(), ["--files", "-g", pat, root]);
   let files: string[];
@@ -392,6 +410,7 @@ async function glob(pattern: unknown, path: unknown): Promise<Result> {
 }
 
 async function search(
+  chatId: number,
   pattern: unknown,
   path: unknown,
   globPat: unknown,
@@ -410,7 +429,7 @@ async function search(
     ...(ci ? ["-i"] : []),
     ...(g ? ["-g", g] : []),
   ];
-  const active = await getTeleport();
+  const active = await getTeleport(chatId);
   if (active) {
     // Prefer rg on the device, fall back to grep (Android toybox has grep
     // but rarely rg). --include is grep's closest analogue of -g.
@@ -423,7 +442,7 @@ async function search(
       `if command -v rg >/dev/null 2>&1; ` +
       `then rg ${flags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)}; ` +
       `else grep ${grepFlags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)} 2>/dev/null; fi`;
-    return bashTeleported(active.deviceId, cmd, 30_000);
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
   }
   const res = await runLocal(rgBin(), [...flags, "-e", pat, root]);
   let lines: string[];
@@ -525,13 +544,23 @@ function runLocal(
 ): Promise<{ code: number; stdout: string; stderr: string }> {
   return new Promise((resolvePromise) => {
     const child = spawn(bin, args, { env: process.env });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (d) => (stdout += d.toString()));
-    child.stderr.on("data", (d) => (stderr += d.toString()));
-    child.on("error", () => resolvePromise({ code: 127, stdout, stderr }));
+    const stdout = createOutputCapture();
+    const stderr = createOutputCapture();
+    child.stdout.on("data", stdout.push);
+    child.stderr.on("data", stderr.push);
+    child.on("error", () =>
+      resolvePromise({
+        code: 127,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
+    );
     child.on("close", (code) =>
-      resolvePromise({ code: code ?? 0, stdout, stderr }),
+      resolvePromise({
+        code: code ?? 0,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
     );
   });
 }
@@ -544,9 +573,13 @@ function renderExec(
 ): string {
   const parts = [`[${where}] ${status}`];
   if (stdout.trim())
-    parts.push(`--- stdout ---\n${stdout.replace(/\s+$/, "")}`);
+    parts.push(
+      `--- stdout ---\n${clampExecOutput(stdout.replace(/\s+$/, ""))}`,
+    );
   if (stderr.trim())
-    parts.push(`--- stderr ---\n${stderr.replace(/\s+$/, "")}`);
+    parts.push(
+      `--- stderr ---\n${clampExecOutput(stderr.replace(/\s+$/, ""))}`,
+    );
   if (!stdout.trim() && !stderr.trim()) parts.push("(no output)");
   return parts.join("\n");
 }