talon-agent 1.48.0 → 1.50.0

package/src/cli/index.ts

@@ -31,6 +31,8 @@ import { runDoctor } from "./doctor.js";
 import { startChat } from "./chat.js";
 import { daemonStart, daemonStop, daemonRestart } from "./daemon.js";
 import { showTasks, killTask } from "./tasks.js";
+import { showEvents } from "./events.js";
+import { showLs, showCat } from "./fs.js";
 import { mainMenu } from "./menu.js";
 
 export * from "./context.js";
@@ -58,6 +60,9 @@ const CLI_COMMANDS = [
   "doctor",
   "ps",
   "kill",
+  "events",
+  "ls",
+  "cat",
 ];
 
 /** Route a `talon <command>` invocation. Called by the entry point. */
@@ -100,11 +105,29 @@ export async function runCli(): Promise<void> {
       runDoctor();
       break;
     case "ps":
-      await showTasks();
+      await showTasks(process.argv[3] === "--all" || process.argv[3] === "-a");
       break;
     case "kill":
       await killTask(process.argv[3]);
       break;
+    case "events": {
+      const args = process.argv.slice(3);
+      const historyAt = args.findIndex((a) => a === "--history");
+      const next = historyAt >= 0 ? Number(args[historyAt + 1]) : NaN;
+      await showEvents({
+        follow: args.includes("-f") || args.includes("--follow"),
+        ...(historyAt >= 0
+          ? { history: Number.isInteger(next) && next > 0 ? next : 100 }
+          : {}),
+      });
+      break;
+    }
+    case "ls":
+      await showLs(process.argv[3]);
+      break;
+    case "cat":
+      await showCat(process.argv[3]);
+      break;
     case "--version":
     case "-v": {
       console.log(pkg.version);
@@ -122,8 +145,19 @@ export async function runCli(): Promise<void> {
       console.log(`    ${pc.cyan("run")}        Run in foreground (attached)`);
       console.log(`    ${pc.cyan("chat")}       Terminal chat mode`);
       console.log(`    ${pc.cyan("status")}     Show bot health`);
-      console.log(`    ${pc.cyan("ps")}         List agent tasks (task table)`);
+      console.log(
+        `    ${pc.cyan("ps")}         List agent tasks (--all includes journal history)`,
+      );
       console.log(`    ${pc.cyan("kill")}       Abort a killable task by id`);
+      console.log(
+        `    ${pc.cyan("events")}     Tail the event bus (-f follows, --history [N] reads the journal)`,
+      );
+      console.log(
+        `    ${pc.cyan("ls")}         List the talon:// namespace (ls proc/tasks)`,
+      );
+      console.log(
+        `    ${pc.cyan("cat")}        Read a talon:// file (cat proc/events)`,
+      );
       console.log(`    ${pc.cyan("config")}     View/edit configuration`);
       console.log(`    ${pc.cyan("logs")}       Tail log file`);
       console.log(`    ${pc.cyan("doctor")}     Validate environment`);

package/src/cli/tasks.ts

@@ -2,21 +2,21 @@
  * `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,
   TaskRecord,
   TaskState,
 } from "../core/tasks/index.js";
 
-const REQUEST_TIMEOUT_MS = 3_000;
-
 function formatDuration(ms: number): string {
   const seconds = Math.floor(ms / 1000);
   if (seconds < 60) return `${seconds}s`;
@@ -66,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];
 }
 
@@ -107,56 +112,85 @@ function renderTable(tasks: TaskRecord[], now: number): void {
   console.log();
 }
 
-async function fetchGateway(
-  port: number,
-  path: string,
-  init?: RequestInit,
-): Promise<unknown> {
-  const response = await fetch(`http://127.0.0.1:${port}${path}`, {
-    ...init,
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-  });
-  if (!response.ok) throw new Error(`gateway answered ${response.status}`);
-  return response.json();
-}
-
-/** Find the daemon and return its gateway port, or render why not. */
-async function requireGatewayPort(): Promise<number | null> {
-  const instance = await findRunningInstance();
-  if (!instance) {
-    console.log(`  ${pc.red("●")} Talon is not running\n`);
-    return null;
+/** 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);
   }
-  if (!instance.port) {
-    console.log(
-      `  ${pc.yellow("●")} Talon is running (PID ${instance.pid}) but its gateway port is unknown — possibly still starting.\n`,
-    );
-    return null;
-  }
-  return instance.port;
+  return historical;
 }
 
-export async function showTasks(): Promise<void> {
+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;
   }
@@ -205,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/bus/bus.ts

@@ -0,0 +1,114 @@
+/**
+ * TalonBus — the daemon's internal event spine.
+ *
+ * One instance (`bus`) serves the whole process. Producers publish typed
+ * events (see events.ts); consumers subscribe by type. The bus is the seam
+ * that lets subsystems react to each other without importing each other —
+ * bootstrap wires dream and pulse as subscribers instead of threading
+ * callbacks through the Weaver, and future work (triggers as subscribers,
+ * companion task feeds, mesh presence) lands as more publishers/consumers.
+ *
+ * Delivery contract:
+ *   - Synchronous, in publish order, to every matching subscriber.
+ *   - Fire-and-forget: a subscriber that throws (or returns a rejecting
+ *     promise) is logged and never affects the publisher or its peers.
+ *   - Subscribers must not block: anything slow belongs behind its own
+ *     queue or timer, not inside a handler.
+ *
+ * The bus also keeps a bounded ring of recent events with monotonic ids —
+ * the observability surface behind the gateway's `/events/recent` and
+ * `talon events`. In-memory only, like the task table: events describe
+ * moments in a live process, so there is nothing truthful to persist.
+ */
+
+import { logError } from "../../util/log.js";
+import type { PublishedEvent, TalonEvent, TalonEventType } from "./events.js";
+
+/** Recent events kept for the tail surfaces. */
+const DEFAULT_RECENT_LIMIT = 200;
+
+type Handler<T extends TalonEventType> = (
+  event: Extract<PublishedEvent, { type: T }>,
+) => void | Promise<void>;
+
+type AnyHandler = (event: PublishedEvent) => void | Promise<void>;
+
+export class TalonBus {
+  private readonly byType = new Map<TalonEventType, Set<AnyHandler>>();
+  private readonly all = new Set<AnyHandler>();
+  private readonly ring: PublishedEvent[] = [];
+  private readonly recentLimit: number;
+  private nextId = 1;
+
+  constructor(recentLimit = DEFAULT_RECENT_LIMIT) {
+    this.recentLimit = recentLimit;
+  }
+
+  /** Subscribe to one event type. Returns the unsubscribe function. */
+  subscribe<T extends TalonEventType>(
+    type: T,
+    handler: Handler<T>,
+  ): () => void {
+    const set = this.byType.get(type) ?? new Set<AnyHandler>();
+    this.byType.set(type, set);
+    const anyHandler = handler as AnyHandler;
+    set.add(anyHandler);
+    return () => {
+      set.delete(anyHandler);
+    };
+  }
+
+  /** Subscribe to every event (tails, forwarders). Returns unsubscribe. */
+  subscribeAll(handler: AnyHandler): () => void {
+    this.all.add(handler);
+    return () => {
+      this.all.delete(handler);
+    };
+  }
+
+  /** Stamp and deliver an event. Never throws. */
+  publish(event: TalonEvent): PublishedEvent {
+    const published: PublishedEvent = {
+      ...event,
+      id: this.nextId++,
+      at: Date.now(),
+    };
+    this.ring.push(published);
+    if (this.ring.length > this.recentLimit) {
+      this.ring.splice(0, this.ring.length - this.recentLimit);
+    }
+    for (const handler of this.byType.get(event.type) ?? []) {
+      this.deliver(handler, published);
+    }
+    for (const handler of this.all) {
+      this.deliver(handler, published);
+    }
+    return published;
+  }
+
+  /**
+   * Recent events, id-ascending — all of the ring, or only those after
+   * `sinceId` (the tail-follow cursor).
+   */
+  recent(sinceId = 0): PublishedEvent[] {
+    return sinceId > 0
+      ? this.ring.filter((event) => event.id > sinceId)
+      : [...this.ring];
+  }
+
+  private deliver(handler: AnyHandler, event: PublishedEvent): void {
+    try {
+      const result = handler(event);
+      if (result instanceof Promise) {
+        result.catch((err: unknown) => {
+          logError("bus", `Subscriber for ${event.type} rejected`, err);
+        });
+      }
+    } catch (err) {
+      logError("bus", `Subscriber for ${event.type} threw`, err);
+    }
+  }
+}
+
+/** The daemon-wide bus. Tests needing isolation construct their own. */
+export const bus = new TalonBus();

package/src/core/bus/events.ts

@@ -0,0 +1,64 @@
+/**
+ * Event vocabulary — every event the Talon bus carries.
+ *
+ * The union is deliberately small and honest: a type exists here only when
+ * something in the runtime actually publishes it. Growing the vocabulary is
+ * a one-line union change; each addition should land together with its
+ * publisher (and ideally its first subscriber).
+ *
+ * Two families exist today:
+ *
+ *   - `task.*` — lifecycle of agent work, published by the task table
+ *     (core/tasks). Uniform across kinds: a heartbeat pass, a dream run, an
+ *     isolated cron/trigger job, and a chat turn all surface here.
+ *   - `turn.*` — the chat-domain moments inside a turn that other
+ *     subsystems key off: `turn.started` fires once the warp is bound and
+ *     the backend is about to run (never for a no-model refusal);
+ *     `turn.completed` fires only for a successfully finished turn.
+ */
+
+import type { TaskRecord } from "../tasks/types.js";
+
+/** A task left the queue and began running. */
+export interface TaskStartedEvent {
+  readonly type: "task.started";
+  readonly task: TaskRecord;
+}
+
+/** A task reached a terminal state (done / failed / killed). */
+export interface TaskSettledEvent {
+  readonly type: "task.settled";
+  readonly task: TaskRecord;
+}
+
+/** A chat turn bound its warp and is about to run on the backend. */
+export interface TurnStartedEvent {
+  readonly type: "turn.started";
+  readonly chatId: string;
+  readonly source: string;
+  readonly model: string;
+  readonly backendId: string;
+}
+
+/** A chat turn finished successfully (refusals and failures never emit this). */
+export interface TurnCompletedEvent {
+  readonly type: "turn.completed";
+  readonly chatId: string;
+  readonly source: string;
+  readonly durationMs: number;
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+}
+
+export type TalonEvent =
+  TaskStartedEvent | TaskSettledEvent | TurnStartedEvent | TurnCompletedEvent;
+
+export type TalonEventType = TalonEvent["type"];
+
+/** What subscribers receive: the event plus its bus stamp. */
+export type PublishedEvent = TalonEvent & {
+  /** Monotonic per-process sequence number — the tail cursor. */
+  readonly id: number;
+  /** Publish time, epoch ms. */
+  readonly at: number;
+};

package/src/core/bus/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Event bus — public surface.
+ *
+ * See bus.ts for the spine and events.ts for the vocabulary. Publishers
+ * today: the task table (task.*) and the Weaver (turn.*). Subscribers are
+ * wired at the composition root (bootstrap: dream on turn.started, pulse on
+ * turn.completed); read surfaces: gateway `GET /events/recent`, CLI
+ * `talon events`.
+ */
+
+export { TalonBus, bus } from "./bus.js";
+export type {
+  PublishedEvent,
+  TalonEvent,
+  TalonEventType,
+  TaskSettledEvent,
+  TaskStartedEvent,
+  TurnCompletedEvent,
+  TurnStartedEvent,
+} from "./events.js";

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(