talon-agent 1.49.0 → 1.50.0

package/src/cli/tasks.ts

@@ -2,12 +2,14 @@
  * `talon ps` / `talon kill` — the task table from the outside.
  *
  * Data comes from the running daemon's gateway (`GET /tasks`,
- * `POST /tasks/kill`); discovery finds the instance the same way
- * `talon status` does. This module only renders — the table itself
- * lives in core/tasks/.
+ * `POST /tasks/kill`); `--all` also folds in settled runs from the
+ * durable journal in talon.db, which answers across restarts — with or
+ * without a daemon. This module only renders — the table lives in
+ * core/tasks/, the journal in storage/journal.ts.
  */
 
 import pc from "picocolors";
+import { findRunningInstance } from "../core/daemon/discovery.js";
 import { fetchGateway, requireGatewayPort } from "./daemon-api.js";
 import type {
   KillOutcome,
@@ -64,7 +66,12 @@ function displayOrder(tasks: TaskRecord[]): TaskRecord[] {
     (t) => t.state !== "running" && t.state !== "queued",
   );
   live.sort((a, b) => a.id - b.id);
-  settled.sort((a, b) => b.id - a.id);
+  // By time, not id: journal history spans daemon restarts, and per-process
+  // ids restart with the daemon.
+  settled.sort(
+    (a, b) =>
+      (b.endedAt ?? b.queuedAt) - (a.endedAt ?? a.queuedAt) || b.id - a.id,
+  );
   return [...live, ...settled];
 }
 
@@ -105,27 +112,85 @@ function renderTable(tasks: TaskRecord[], now: number): void {
   console.log();
 }
 
-export async function showTasks(): Promise<void> {
+/** Settled runs from the journal, minus any already in the live table. */
+async function journalTasks(
+  liveTasks: readonly TaskRecord[],
+  limit: number,
+): Promise<TaskRecord[]> {
+  const { readJournal } = await import("../storage/journal.js");
+  const seen = new Set(liveTasks.map((t) => `${t.id}:${t.queuedAt}`));
+  const historical: TaskRecord[] = [];
+  for (const entry of readJournal({ type: "task.settled", limit })) {
+    if (entry.event.type !== "task.settled") continue;
+    const task = entry.event.task;
+    // (id, queuedAt) identifies a run across surfaces — per-process ids
+    // repeat between daemon runs, enqueue times don't.
+    if (seen.has(`${task.id}:${task.queuedAt}`)) continue;
+    seen.add(`${task.id}:${task.queuedAt}`);
+    historical.push(task);
+  }
+  return historical;
+}
+
+export async function showTasks(all = false): Promise<void> {
   console.log();
-  const port = await requireGatewayPort();
-  if (port === null) return;
 
-  let tasks: TaskRecord[];
-  try {
-    const body = (await fetchGateway(port, "/tasks")) as {
-      tasks?: TaskRecord[];
-    };
-    tasks = body.tasks ?? [];
-  } catch (err) {
-    console.log(
-      `  ${pc.red("✖")} Could not read the task table: ${err instanceof Error ? err.message : err}\n`,
-    );
-    return;
+  let tasks: TaskRecord[] = [];
+  let daemonUp = true;
+  if (all) {
+    // History works without a daemon — fold in the live table only when
+    // one is actually running.
+    const instance = await findRunningInstance();
+    if (instance?.port) {
+      try {
+        const body = (await fetchGateway(instance.port, "/tasks")) as {
+          tasks?: TaskRecord[];
+        };
+        tasks = body.tasks ?? [];
+      } catch {
+        daemonUp = false;
+      }
+    } else {
+      daemonUp = false;
+    }
+  } else {
+    const port = await requireGatewayPort();
+    if (port === null) return;
+    try {
+      const body = (await fetchGateway(port, "/tasks")) as {
+        tasks?: TaskRecord[];
+      };
+      tasks = body.tasks ?? [];
+    } catch (err) {
+      console.log(
+        `  ${pc.red("✖")} Could not read the task table: ${err instanceof Error ? err.message : err}\n`,
+      );
+      return;
+    }
+  }
+
+  if (all) {
+    if (!daemonUp) {
+      console.log(
+        `  ${pc.dim("Talon is not running — journal history only.")}`,
+      );
+    }
+    try {
+      tasks = [...tasks, ...(await journalTasks(tasks, 200))];
+    } catch (err) {
+      console.log(
+        `  ${pc.red("✖")} Could not read the journal: ${err instanceof Error ? err.message : err}\n`,
+      );
+      process.exitCode = 1;
+      return;
+    }
   }
 
   if (tasks.length === 0) {
     console.log(
-      `  ${pc.dim("No tasks — the table starts empty on each daemon start.")}\n`,
+      all
+        ? `  ${pc.dim("No tasks — nothing live and the journal is empty.")}\n`
+        : `  ${pc.dim("No tasks — the table starts empty on each daemon start. Older runs: talon ps --all")}\n`,
     );
     return;
   }
@@ -174,7 +239,7 @@ export async function killTask(rawId: string | undefined): Promise<void> {
       return;
     case "not-killable":
       console.log(
-        `  ${pc.yellow("!")} Task ${id} has no abort hook (chat turns run to completion) — it cannot be killed.\n`,
+        `  ${pc.yellow("!")} Task ${id} has no abort hook — its backend can't interrupt a running turn.\n`,
       );
       return;
   }

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

@@ -17,6 +17,7 @@
  *   - `plugins`   — plugin hot-reload
  *   - `models`    — model / backend discovery
  *   - `mesh`      — companion device mesh (presence + location)
+ *   - `vfs`       — the unified talon:// namespace (list/read/write)
  */
 
 import type { ActionResult } from "../../types.js";
@@ -33,6 +34,7 @@ import { pluginHandlers } from "./plugins.js";
 import { modelHandlers } from "./models.js";
 import { meshHandlers } from "./mesh.js";
 import { nativeHandlers } from "./native.js";
+import { vfsHandlers } from "./vfs.js";
 
 // Null-prototype so a request `action` of "toString" / "constructor" / etc.
 // can't resolve an inherited Object.prototype method — `handlers[action]` only
@@ -49,6 +51,7 @@ const handlers: SharedActionHandlers = Object.assign(Object.create(null), {
   ...modelHandlers,
   ...meshHandlers,
   ...nativeHandlers,
+  ...vfsHandlers,
 });
 
 export async function handleSharedAction(

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

@@ -33,6 +33,7 @@ import {
   setTeleport,
   setTeleportCwd,
 } from "../../mesh/teleport.js";
+import { getVfs } from "../../vfs/index.js";
 import {
   clampExecOutput,
   createOutputCapture,
@@ -447,6 +448,65 @@ async function bashTeleported(
   };
 }
 
+// ── talon:// address resolution ─────────────────────────────────────────────
+
+const NAMESPACE_SCHEME = "talon://";
+
+type AddressResolution =
+  | { kind: "disk"; path: string }
+  | { kind: "virtual" }
+  | { kind: "error"; text: string };
+
+/**
+ * Native fs tools accept talon:// addresses: `Vfs.locate` maps them to the
+ * disk location the address names, and the tool then operates on the real
+ * file. Synthetic nodes (proc/, plugins/) have no disk location — reads are
+ * served straight from the namespace, mutation refuses honestly. Teleport
+ * can't cross address spaces: talon:// names daemon state, and a teleported
+ * chat's paths belong to the device, so the combination is refused rather
+ * than resolved against the wrong filesystem.
+ */
+function resolveNamespaceAddress(
+  address: string,
+  teleportedTo: string | undefined,
+): AddressResolution {
+  if (teleportedTo !== undefined) {
+    return {
+      kind: "error",
+      text:
+        `${address} names the daemon's namespace, but native tools are ` +
+        `teleported onto ${teleportedTo} — teleport_back first, or use a device path.`,
+    };
+  }
+  const located = getVfs().locate(address);
+  if (!located.ok) {
+    return {
+      kind: "error",
+      text: `Cannot resolve ${address}: ${located.error}${located.detail ? ` — ${located.detail}` : ""}`,
+    };
+  }
+  return located.value === undefined
+    ? { kind: "virtual" }
+    : { kind: "disk", path: located.value };
+}
+
+/** glob/search root: a talon:// address must name a disk-backed directory. */
+function resolveSearchRoot(
+  path: string | undefined,
+  teleportedTo: string | undefined,
+): { root: string } | { error: string } {
+  const root = path ?? ".";
+  if (!root.startsWith(NAMESPACE_SCHEME)) return { root };
+  const resolved = resolveNamespaceAddress(root, teleportedTo);
+  if (resolved.kind === "error") return { error: resolved.text };
+  if (resolved.kind === "virtual") {
+    return {
+      error: `${root} is a synthetic view with no files on disk — browse it with vfs_list instead.`,
+    };
+  }
+  return { root: resolved.path };
+}
+
 // ── read / write / edit ─────────────────────────────────────────────────────
 
 async function read(
@@ -455,15 +515,38 @@ async function read(
   offset: unknown,
   limit: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
   const active = await getTeleport(chatId);
   const where = active ? active.deviceName : "local";
 
+  let p = address;
+  let virtualContent: string | undefined;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "disk") {
+      p = resolved.path;
+    } else {
+      const served = getVfs().read(address);
+      if (!served.ok) {
+        return {
+          ok: false,
+          text: `Cannot read ${address}: ${served.error}${served.detail ? ` — ${served.detail}` : ""}`,
+        };
+      }
+      virtualContent = served.value;
+    }
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
+
   // Image files: return a viewable image block, not the raw bytes decoded as
   // UTF-8. Without this, `read`ing a photo/screenshot/design hands the model
   // mojibake and it can't see the picture at all.
-  const mime = IMAGE_MIME[extname(p).toLowerCase()];
+  const mime =
+    virtualContent === undefined
+      ? IMAGE_MIME[extname(p).toLowerCase()]
+      : undefined;
   if (mime) {
     let bytes: Buffer;
     if (active) {
@@ -476,7 +559,7 @@ async function read(
       } catch (err) {
         return {
           ok: false,
-          text: `Cannot read ${p}: ${(err as Error).message}`,
+          text: `Cannot read ${shown}: ${(err as Error).message}`,
         };
       }
     }
@@ -484,14 +567,14 @@ async function read(
       return {
         ok: false,
         text:
-          `${p} [${where}] is ${(bytes.length / 1_048_576).toFixed(1)}MB — over the ` +
+          `${shown} [${where}] is ${(bytes.length / 1_048_576).toFixed(1)}MB — over the ` +
           `${MAX_IMAGE_BYTES / 1_048_576}MB image limit. Downscale it first ` +
           `(e.g. \`convert '${p}' -resize 1568x /tmp/small.jpg\`) and read that.`,
       };
     }
     return {
       ok: true,
-      text: `${p} [${where}] — image (${mime}, ${bytes.length} bytes)`,
+      text: `${shown} [${where}] — image (${mime}, ${bytes.length} bytes)`,
       image: { data: bytes.toString("base64"), mimeType: mime },
     };
   }
@@ -499,7 +582,9 @@ async function read(
   const start = num(offset) ?? 0;
   const max = Math.min(num(limit) ?? MAX_READ_LINES, MAX_READ_LINES);
   let content: string;
-  if (active) {
+  if (virtualContent !== undefined) {
+    content = virtualContent;
+  } else if (active) {
     const res = await getMeshService().readFileBytes(active.deviceId, p);
     if ("error" in res) return { ok: false, text: res.error };
     content = res.data.toString("utf8");
@@ -507,7 +592,10 @@ async function read(
     try {
       content = await readFile(p, "utf8");
     } catch (err) {
-      return { ok: false, text: `Cannot read ${p}: ${(err as Error).message}` };
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
     }
   }
   const lines = content.split("\n");
@@ -521,7 +609,7 @@ async function read(
       : "";
   return {
     ok: true,
-    text: `${p} [${where}] — ${lines.length} lines\n${numbered}${more}`,
+    text: `${shown} [${where}] — ${lines.length} lines\n${numbered}${more}`,
   };
 }
 
@@ -530,10 +618,23 @@ async function write(
   path: unknown,
   content: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
   const body = typeof content === "string" ? content : "";
   const active = await getTeleport(chatId);
+  let p = address;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "virtual") {
+      return {
+        ok: false,
+        text: `${address} is a synthetic view — there is no file on disk to write. Writable mounts: vfs_list "" shows where each lives.`,
+      };
+    }
+    p = resolved.path;
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
   if (active) {
     return getMeshService().writeFileToDevice(active.deviceId, p, body);
   }
@@ -541,9 +642,12 @@ async function write(
     await mkdir(dirname(p), { recursive: true });
     await writeFile(p, body);
   } catch (err) {
-    return { ok: false, text: `Cannot write ${p}: ${(err as Error).message}` };
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
   }
-  return { ok: true, text: `Wrote ${body.length} bytes to ${p} [local].` };
+  return { ok: true, text: `Wrote ${body.length} bytes to ${shown} [local].` };
 }
 
 async function edit(
@@ -553,13 +657,26 @@ async function edit(
   newString: unknown,
   replaceAll: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
   const from = typeof oldString === "string" ? oldString : "";
   const to = typeof newString === "string" ? newString : "";
   if (from === to)
     return { ok: false, text: "old_string and new_string are identical." };
   const active = await getTeleport(chatId);
+  let p = address;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "virtual") {
+      return {
+        ok: false,
+        text: `${address} is a synthetic view — there is no file on disk to edit. Read it with vfs_read instead.`,
+      };
+    }
+    p = resolved.path;
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
   const svc = getMeshService();
 
   let content: string;
@@ -571,7 +688,10 @@ async function edit(
     try {
       content = await readFile(p, "utf8");
     } catch (err) {
-      return { ok: false, text: `Cannot read ${p}: ${(err as Error).message}` };
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
     }
   }
 
@@ -579,13 +699,13 @@ async function edit(
   if (count === 0) {
     return {
       ok: false,
-      text: `old_string not found in ${p}.${nearMissHint(content, from)}`,
+      text: `old_string not found in ${shown}.${nearMissHint(content, from)}`,
     };
   }
   if (count > 1 && replaceAll !== true) {
     return {
       ok: false,
-      text: `old_string appears ${count}× in ${p}; pass replace_all or make it unique.`,
+      text: `old_string appears ${count}× in ${shown}; pass replace_all or make it unique.`,
     };
   }
   const updated =
@@ -598,18 +718,21 @@ async function edit(
     return res.ok
       ? {
           ok: true,
-          text: `Edited ${p} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}).`,
+          text: `Edited ${shown} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}).`,
         }
       : res;
   }
   try {
     await writeFile(p, updated);
   } catch (err) {
-    return { ok: false, text: `Cannot write ${p}: ${(err as Error).message}` };
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
   }
   return {
     ok: true,
-    text: `Edited ${p} [local] (${count} replacement${count === 1 ? "" : "s"}).`,
+    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}).`,
   };
 }
 
@@ -622,8 +745,10 @@ async function glob(
 ): 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(chatId);
+  const rooted = resolveSearchRoot(str(path), active?.deviceName);
+  if ("error" in rooted) return { ok: false, text: rooted.error };
+  const root = rooted.root;
   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
@@ -669,7 +794,10 @@ async function search(
 ): Promise<Result> {
   const pat = str(pattern);
   if (!pat) return { ok: false, text: "A search pattern is required." };
-  const root = str(path) ?? ".";
+  const active = await getTeleport(chatId);
+  const rooted = resolveSearchRoot(str(path), active?.deviceName);
+  if ("error" in rooted) return { ok: false, text: rooted.error };
+  const root = rooted.root;
   const g = str(globPat);
   const ci = caseInsensitive === true;
   // `-e` keeps a pattern that starts with "-" from being parsed as a flag
@@ -680,7 +808,6 @@ async function search(
     ...(ci ? ["-i"] : []),
     ...(g ? ["-g", g] : []),
   ];
-  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.

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

@@ -0,0 +1,69 @@
+/**
+ * VFS — the `talon://` namespace over the gateway: list / read / write.
+ * Formatting only; the namespace itself lives in core/vfs.
+ */
+
+import { getVfs, type VfsResult, type VfsStat } from "../../vfs/index.js";
+import { log } from "../../../util/log.js";
+import type { SharedActionHandlers } from "./types.js";
+
+function describeError(
+  path: string,
+  result: { error: string; detail?: string },
+): string {
+  return `talon://${path}: ${result.error}${result.detail ? ` — ${result.detail}` : ""}`;
+}
+
+function formatSize(entry: VfsStat): string {
+  return entry.kind === "dir" ? "-" : String(entry.size ?? "?");
+}
+
+function formatEntry(entry: VfsStat): string {
+  const kind = entry.kind === "dir" ? "d" : "-";
+  const write = entry.writable ? "w" : "-";
+  const suffix = entry.kind === "dir" ? "/" : "";
+  // Root entries (single-segment paths) show where the mount lives on
+  // disk — the bridge for OS-level tools, which can't read talon://.
+  const mapping =
+    entry.osPath !== undefined && !entry.path.includes("/")
+      ? `  → ${entry.osPath}`
+      : "";
+  return `${kind}${write} ${formatSize(entry).padStart(9)}  ${entry.name}${suffix}${mapping}`;
+}
+
+function normalize(body: Record<string, unknown>): string {
+  return String(body.path ?? "").trim();
+}
+
+export const vfsHandlers: SharedActionHandlers = {
+  vfs_list: (body) => {
+    const path = normalize(body);
+    const result = getVfs().list(path);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    const header = `talon://${path.replace(/\/+$/, "")}${path ? "/" : ""} (${result.value.length} entries)`;
+    const lines = result.value.map(formatEntry);
+    return {
+      ok: true,
+      text: [header, ...(lines.length > 0 ? lines : ["(empty)"])].join("\n"),
+    };
+  },
+
+  vfs_read: (body) => {
+    const path = normalize(body);
+    const result = getVfs().read(path);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    return { ok: true, text: result.value };
+  },
+
+  vfs_write: (body) => {
+    const path = normalize(body);
+    const content = String(body.content ?? "");
+    const result: VfsResult<VfsStat> = getVfs().write(path, content);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    log("gateway", `vfs_write: talon://${result.value.path}`);
+    return {
+      ok: true,
+      text: `Wrote ${result.value.size ?? content.length} bytes to talon://${result.value.path}`,
+    };
+  },
+};

package/src/core/engine/gateway.ts

@@ -414,6 +414,34 @@ export class Gateway {
           return;
         }
 
+        if (
+          req.method === "GET" &&
+          (req.url?.startsWith("/vfs/list") || req.url?.startsWith("/vfs/read"))
+        ) {
+          // The talon:// namespace — the transport for `talon ls` /
+          // `talon cat`, which need the daemon's live synthetic mounts
+          // (proc, plugins). Same 127.0.0.1 trust boundary as /action.
+          const url = new URL(req.url, "http://gateway");
+          const path = url.searchParams.get("path") ?? "";
+          const { getVfs } = await import("../vfs/index.js");
+          const vfs = getVfs();
+          let result: Record<string, unknown>;
+          if (url.pathname === "/vfs/list") {
+            const listed = vfs.list(path);
+            result = listed.ok
+              ? { ok: true, entries: listed.value }
+              : { ok: false, error: listed.error, detail: listed.detail };
+          } else {
+            const content = vfs.read(path);
+            result = content.ok
+              ? { ok: true, content: content.value }
+              : { ok: false, error: content.error, detail: content.detail };
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+          return;
+        }
+
         if (req.method === "GET" && req.url === "/tasks") {
           // The task table — every live/recent unit of agent work. Read by
           // `talon ps`. Same 127.0.0.1 trust boundary as /action.

package/src/core/tasks/table.ts

@@ -92,7 +92,7 @@ export class TaskTable {
       start: () => this.start(id),
       bind: (binding) => this.bind(id, binding),
       succeed: (usage) => this.settle(id, "done", undefined, usage),
-      fail: (error) => this.settle(id, "failed", error),
+      fail: (error, usage) => this.settle(id, "failed", error, usage),
     };
   }
 

package/src/core/tasks/types.ts

@@ -87,8 +87,12 @@ export interface TaskHandle {
   bind(binding: TaskBinding): void;
   /** Settle as `done`, optionally recording token usage. */
   succeed(usage?: TaskUsage): void;
-  /** Settle as `failed` — or `killed` when a kill was requested first. */
-  fail(error: unknown): void;
+  /**
+   * Settle as `failed` — or `killed` when a kill was requested first.
+   * Usage is recorded when the owner knows what the run burned before it
+   * died (an interrupted turn still spent real tokens).
+   */
+  fail(error: unknown, usage?: TaskUsage): void;
 }
 
 /** Result of `TaskTable.kill`. */

package/src/core/tools/index.ts

@@ -23,6 +23,7 @@ import { adminTools } from "./admin.js";
 import { modelTools } from "./models.js";
 import { meshTools } from "./mesh.js";
 import { nativeTools } from "./native.js";
+import { vfsTools } from "./vfs.js";
 
 /** All built-in tool definitions. */
 export const ALL_TOOLS: readonly ToolDefinition[] = [
@@ -41,6 +42,7 @@ export const ALL_TOOLS: readonly ToolDefinition[] = [
   ...adminTools,
   ...modelTools,
   ...meshTools,
+  ...vfsTools,
 ];
 
 /**