talon-agent 5.18.2 → 5.19.0

package/src/core/plugin/registry.ts

@@ -27,42 +27,29 @@ class PluginRegistry {
     return this.plugins.length;
   }
 
-  private getRegistrationSource(name: string): string | undefined {
-    const existingPlugin = this.plugins.find(
-      (entry) => entry.plugin.name === name,
+  /** True when `name` is free; warns and returns false on a duplicate. */
+  private isNameFree(name: string): boolean {
+    const source =
+      this.plugins.find((entry) => entry.plugin.name === name)?.path ??
+      (this.standaloneMcpServers.some((entry) => entry.name === name)
+        ? "standalone MCP entry"
+        : undefined);
+    if (!source) return true;
+    logWarn(
+      "plugin",
+      `Duplicate plugin/MCP name "${name}" — skipping (already registered from ${source})`,
     );
-    if (existingPlugin) return existingPlugin.path;
-
-    const existingMcpEntry = this.standaloneMcpServers.find(
-      (entry) => entry.name === name,
-    );
-    if (existingMcpEntry) return "standalone MCP entry";
-
-    return undefined;
+    return false;
   }
 
   register(loaded: LoadedPlugin): boolean {
-    const existingSource = this.getRegistrationSource(loaded.plugin.name);
-    if (existingSource) {
-      logWarn(
-        "plugin",
-        `Duplicate plugin/MCP name "${loaded.plugin.name}" — skipping (already registered from ${existingSource})`,
-      );
-      return false;
-    }
+    if (!this.isNameFree(loaded.plugin.name)) return false;
     this.plugins.push(loaded);
     return true;
   }
 
   registerMcpEntry(entry: PluginMcpEntry): boolean {
-    const existingSource = this.getRegistrationSource(entry.name);
-    if (existingSource) {
-      logWarn(
-        "plugin",
-        `Duplicate plugin/MCP name "${entry.name}" — skipping (already registered from ${existingSource})`,
-      );
-      return false;
-    }
+    if (!this.isNameFree(entry.name)) return false;
     this.standaloneMcpServers.push(entry);
     return true;
   }
@@ -98,14 +85,12 @@ class PluginRegistry {
   }
 }
 
-// Module-level singleton
 export const registry = new PluginRegistry();
 
 /**
- * Tracks the last reload timestamp. Injected into every MCP subprocess env as
- * TALON_RELOAD_AT so the Claude SDK sees a changed env on each reload and
- * spawns a fresh subprocess — picking up source-file changes without a full
- * Talon restart. On a holder object so other modules can read/update it.
+ * The last plugin reload time: the module cache-bust key (see
+ * `_deps.importModule`), also passed to every MCP child as TALON_RELOAD_AT.
+ * On a holder object so other modules can read/update it.
  */
 export const reloadState: { lastReloadAt: string } = {
   lastReloadAt: new Date().toISOString(),
@@ -125,9 +110,8 @@ export const _deps = {
     // URL forever, so without a changing query a hot reload re-imports the
     // *old* module object and the plugin's own source edits are invisible
     // until a full restart — silently, since the stale module still loads
-    // fine (observed 2026-09-16: a rewritten plugin kept reporting its
-    // previous version through three reloads). The timestamp only moves per
-    // reload, so every module in one load cycle shares a key.
+    // fine. The timestamp only moves per reload, so every module in one
+    // load cycle shares a key.
     const url = pathToFileURL(path);
     url.searchParams.set("talonReloadAt", reloadState.lastReloadAt);
     return import(url.href);

package/src/core/plugin/types.ts

@@ -35,10 +35,7 @@ export function isMcpPlugin(entry: PluginEntry): entry is PluginMcpEntry {
   return "command" in entry && "name" in entry && !("path" in entry);
 }
 
-/**
- * Core plugin interface — only `name` is required.
- * All other capabilities are optional (Interface Segregation).
- */
+/** Core plugin interface — only `name` is required. */
 export interface TalonPlugin {
   /** Unique plugin identifier. Used as MCP server name prefix. */
   readonly name: string;
@@ -134,7 +131,7 @@ export interface LoadedPlugin {
   readonly path: string;
 }
 
-/** MCP server configuration for the Claude Agent SDK. */
+/** Stdio MCP server spec (command, args, env). */
 export interface McpServerConfig {
   command: string;
   args: string[];

package/src/core/prompt/assemble.ts

@@ -63,7 +63,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { dirs, files as pathFiles } from "../../util/paths.js";
 import { todayAndYesterday } from "../../util/time.js";
-import { log } from "../../util/log.js";
+import { log, logWarn } from "../../util/log.js";
 import { loadSystemTemplate } from "./templates.js";
 import { renderMemoryView } from "./memory-view.js";
 import { renderWorkspaceListing } from "./workspace-listing.js";
@@ -125,11 +125,23 @@ const MEMORY_CHARS_METRIC = "prompt.memory_chars";
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
+/** Unreadable prompt files already reported (path + error code). */
+const reportedUnreadable = new Set<string>();
+
 function readOptionalFile(path: string): string {
   try {
     if (existsSync(path)) return readFileSync(path, "utf-8").trim();
-  } catch {
-    /* ignore */
+  } catch (err) {
+    // Absent is fine (existsSync above); present-but-unreadable silently
+    // drops a prompt section, so say which — once, not every assembly.
+    const key = `${path}\0${(err as NodeJS.ErrnoException).code ?? ""}`;
+    if (!reportedUnreadable.has(key)) {
+      reportedUnreadable.add(key);
+      logWarn(
+        "workspace",
+        `Prompt file unreadable, section omitted path=${path}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
   }
   return "";
 }

package/src/core/scripts/lua.ts

@@ -1,7 +1,7 @@
 /**
  * Lua trigger runner — executes a trigger script inside a WASM-sandboxed
  * Lua 5.4 VM (wasmoon), speaking the same stdout protocol bash/python/node
- * triggers use (see core/background/triggers.ts).
+ * triggers use (see core/background/triggers/).
  *
  * Why a separate process at all: the trigger supervisor's whole contract
  * (kill/respawn, SIGTERM grace, log streaming, TALON_FIRE line scanning)
@@ -62,7 +62,11 @@ import { basename } from "node:path";
  *  Dispatched by src/index.ts and src/cli.ts before the app graph loads. */
 export const LUA_RUN_SUBCOMMAND = "_lua-run";
 
-/** Must match FIRE_PREFIX in core/background/triggers.ts. */
+/**
+ * Must match FIRE_PREFIX in core/background/triggers/state.ts. Copied,
+ * not imported: that module pulls in the dispatcher, and the `_lua-run`
+ * helper process must stay light.
+ */
 const FIRE_PREFIX = "TALON_FIRE:";
 
 /**

package/src/core/tasks/table.ts

@@ -13,6 +13,7 @@
  */
 
 import { bus } from "../bus/index.js";
+import { logWarn } from "../../util/log.js";
 import type { TaskSettledEvent, TaskStartedEvent } from "../bus/events.js";
 import type {
   KillOutcome,
@@ -114,9 +115,14 @@ export class TaskTable {
       task.killRequested = true;
       try {
         task.abort();
-      } catch {
+      } catch (err) {
         // The abort hook contract is "must not throw" — a violation must
-        // not break the kill path for the caller.
+        // not break the kill path for the caller, but the run may now
+        // never settle, so leave a trace of why.
+        logWarn(
+          "tasks",
+          `Abort hook threw task=${id} kind=${task.record.kind} label=${JSON.stringify(task.record.label)}: ${err instanceof Error ? err.message : String(err)}`,
+        );
       }
     }
     return { ok: true };

package/src/core/tools/bridge.ts

@@ -1,8 +1,6 @@
 /**
- * Bridge utilities — shared by the unified MCP server.
- *
- * Extracted from the old per-backend tools.ts files so there's
- * exactly one copy of callBridge / textResult.
+ * Bridge utilities — the one copy of callBridge / textResult, shared by
+ * the unified MCP server.
  *
  * At the tools root, not in `ops/`: the group directories hold tool
  * DOMAINS (one file per family of tool definitions), and this is the

package/src/core/tools/chat/cross-send.ts

@@ -25,7 +25,7 @@ Media: give file_path (a workspace file) or url (a public URL, fetched by the pl
 Examples:
   send_via(frontend="whatsapp", target="+353871234567", text="On my way")
   send_via(frontend="whatsapp", target="+353871234567", file_path="media/plot.png", text="here's the chart")
-  send_via(frontend="telegram", target="-1001426819337", text="Build is green")
+  send_via(frontend="telegram", target="-1009876543210", text="Build is green")
 
 Fails with a clear error when the named frontend is not enabled or not connected.`,
     schema: {

package/src/core/tools/chat/messaging.ts

@@ -257,7 +257,7 @@ Examples:
       chat_id: chatIdSchema
         .optional()
         .describe(
-          "Target chat ID. Omit to send to the current chat (chat mode). Required from heartbeat mode where there is no ambient chat — use list_chats or known IDs from memory. Telegram supergroup/channel IDs are negative (e.g. -1001426819337); user DMs are positive.",
+          "Target chat ID. Omit to send to the current chat (chat mode). Required from heartbeat mode where there is no ambient chat — use list_chats or known IDs from memory. Telegram supergroup/channel IDs are negative (e.g. -1009876543210); user DMs are positive.",
         ),
       silent: z
         .boolean()

package/src/core/tools/index.ts

@@ -112,7 +112,7 @@ const ALL_TOOL_NAMES: ReadonlySet<string> = new Set(
  *      e.g. `mcp__telegram-tools__end_turn` → `end_turn`.
  *
  *   2. **Kilo / OpenCode:** `<server>_<tool>` (single underscore boundary,
- *      no `mcp__` prefix). e.g. `talon-tools-352042062_send` → `send`,
+ *      no `mcp__` prefix). e.g. `talon-tools-424242420_send` → `send`,
  *      `talon-tools-heartbeat_end_turn` → `end_turn`. Bare names that
  *      contain underscores (`end_turn`) make a "split on _" approach
  *      ambiguous, so we resolve by checking whether the trailing segment
@@ -132,7 +132,7 @@ export function stripMcpPrefix(toolName: string): string {
 
   // Kilo / OpenCode `<server>_<bare>` form. Walk underscore boundaries
   // from the right; the longest tail that matches a registered tool name
-  // is the bare name. Prevents `talon-tools-352042062_end_turn` from
+  // is the bare name. Prevents `talon-tools-424242420_end_turn` from
   // resolving to `turn` (which isn't a tool).
   const segments = toolName.split("_");
   for (let i = 1; i < segments.length; i++) {

package/src/core/tools/mcp-env.ts

@@ -1,70 +1,13 @@
 /**
- * Talon MCP server environment — the single place that defines the
- * env-var contract between backends (which spawn `mcp-server.ts` as a
- * subprocess) and the server itself (which reads these vars at boot).
- *
- * Before this helper, four backends (claude-sdk, codex, openai-agents,
- * kilo/opencode via remote-server) each hand-built the same
- * `{TALON_BRIDGE_URL, TALON_CHAT_ID, TALON_FRONTEND}` literal —
- * adding a variable meant editing all four. Now they call
- * `buildTalonMcpEnv` and new vars propagate everywhere.
- *
  * Tool-surface trimming: every registered MCP tool costs context
  * tokens in EVERY session (name + description + schema). Deployments
  * that never use whole tool groups (stickers, polls, triggers, …) can
  * reclaim that budget via `disabledToolTags` / `disabledTools` in
- * talon.json — carried to the subprocess as comma-separated env vars.
+ * talon.json.
  */
 
-// ── Env-var names (shared constants, not stringly-typed call sites) ────────
-
-const ENV_BRIDGE_URL = "TALON_BRIDGE_URL";
-const ENV_CHAT_ID = "TALON_CHAT_ID";
-const ENV_FRONTEND = "TALON_FRONTEND";
-export const ENV_DISABLED_TOOLS = "TALON_DISABLED_TOOLS";
-export const ENV_DISABLED_TOOL_TAGS = "TALON_DISABLED_TOOL_TAGS";
-
-// ── Builder (backend side) ──────────────────────────────────────────────────
-
-/** The slice of TalonConfig the MCP env cares about. */
+/** The slice of TalonConfig the tool exclusions care about. */
 export type ToolExclusionConfig = {
   disabledTools?: readonly string[];
   disabledToolTags?: readonly string[];
 };
-
-export type TalonMcpEnvInputs = {
-  bridgeUrl: string;
-  chatId: string;
-  frontend: string;
-  /** Pass the Talon config (or the exclusion slice of it) when available. */
-  config?: ToolExclusionConfig | null;
-};
-
-/** Build the env map for spawning Talon's unified MCP tool server. */
-export function buildTalonMcpEnv(
-  inputs: TalonMcpEnvInputs,
-): Record<string, string> {
-  const env: Record<string, string> = {
-    [ENV_BRIDGE_URL]: inputs.bridgeUrl,
-    [ENV_CHAT_ID]: inputs.chatId,
-    [ENV_FRONTEND]: inputs.frontend,
-  };
-  const tools = inputs.config?.disabledTools;
-  if (tools?.length) env[ENV_DISABLED_TOOLS] = tools.join(",");
-  const tags = inputs.config?.disabledToolTags;
-  if (tags?.length) env[ENV_DISABLED_TOOL_TAGS] = tags.join(",");
-  return env;
-}
-
-// ── Spawn spec ──────────────────────────────────────────────────────────────
-
-// ── Parser (server side) ────────────────────────────────────────────────────
-
-/** Parse a comma-separated env var into a trimmed, de-blanked list. */
-export function parseEnvList(raw: string | undefined): string[] {
-  if (!raw) return [];
-  return raw
-    .split(",")
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0);
-}

package/src/core/tools/ops/agents.ts

@@ -184,10 +184,31 @@ export const agentTools: ToolDefinition[] = [
     tag: "agents",
   },
 
+  {
+    name: "list_peers",
+    description:
+      "Sub-agents only. List the other agents your parent spawned alongside you — id, label and what each is working on. These are the only agents you may message directly with message_peer. Call it before assuming you are working alone.",
+    schema: {},
+    execute: (params, bridge) => bridge("list_peers", params),
+    tag: "agents",
+  },
+
+  {
+    name: "message_peer",
+    description:
+      "Sub-agents only. Send a note straight to a peer — an agent spawned by the same parent as you — without routing it through your parent. Use it when you find something that changes another agent's work: a shared fact, a dead end worth not repeating, a correction to something you sent earlier. The peer sees it at its next check_inbox, so it is not an interrupt. You can only address peers (see list_peers); any other id is refused. This does not end your run and does not replace report_result.",
+    schema: {
+      agent_id: z.string().describe("Peer agent id, from list_peers"),
+      text: z.string().min(1).describe("What the peer needs to know"),
+    },
+    execute: (params, bridge) => bridge("message_peer", params),
+    tag: "agents",
+  },
+
   {
     name: "check_inbox",
     description:
-      "Sub-agents only. Drain any instructions your parent has sent you. Messages are delivered no other way, so check at milestones: after a phase of work, before a long operation, and before you report.",
+      "Sub-agents only. Drain anything sent to you — instructions from your parent, and notes from peer agents working alongside you. Each message names its sender. Messages are delivered no other way, so check at milestones: after a phase of work, before a long operation, and before you report.",
     schema: {},
     execute: (_params, bridge) => bridge("check_inbox", {}),
     tag: "agents",

package/src/core/tools/schemas.ts

@@ -41,8 +41,8 @@ export const idSchema = z.union([
  * sentinel the gateway already treats as falsy/unrouted.
  *
  * Accepts:
- *   - actual non-zero integer numbers (`352042062`, `-1001426819337`)
- *   - integer strings with optional leading minus (`"-1001426819337"`)
+ *   - actual non-zero integer numbers (`424242420`, `-1009876543210`)
+ *   - integer strings with optional leading minus (`"-1009876543210"`)
  *
  * Rejects:
  *   - zero (`0`, `"0"`, `"-0"`)
@@ -51,13 +51,8 @@ export const idSchema = z.union([
  *
  * Use this for `chat_id` fields on tool input schemas. The bare
  * `idSchema` is for message/user/reply IDs (always positive) and
- * would reject the negative IDs Telegram uses for groups/channels —
- * which was the bug PR #150 shipped with: heartbeat outbound `send`
- * to a supergroup got `expected number, received string` (the model
- * sees a `number` JSON schema, but zod rejects negatives before the
- * gateway sees the request). Gateway-side handling for negative
- * chat_ids was already tested and correct — only the tool-input
- * schema layer needed the fix.
+ * would reject the negative IDs Telegram uses for groups/channels
+ * before the gateway ever sees the request.
  */
 const nonZeroInt = z
   .number()

package/src/core/vfs/fusefs.ts

@@ -90,11 +90,6 @@ export function namespaceFsStatus(): FuseStatus {
   return status;
 }
 
-/** Test seam — force a status without a real mount. */
-function _setNamespaceFsStatusForTesting(next: FuseStatus): void {
-  status = next;
-}
-
 /** Test seam — drive one watchdog tick synchronously (no interval wait). */
 export async function _checkNamespaceFsHealthForTesting(): Promise<void> {
   await checkNamespaceFsHealth();

package/src/core/vfs/index.ts

@@ -12,7 +12,8 @@
  *     skills/     SKILL.md bundles (writable)
  *     scripts/    agent script bodies (writable)
  *     logs/       daily logs (read-only — the daemon writes these)
- *     proc/       task table + event bus ring (synthetic, read-only)
+ *     proc/       task table, event bus ring, and the daemon's own
+ *                 log/errors/alerts views (synthetic, read-only)
  *     plugins/    plugin registry view (synthetic, read-only)
  *
  * The namespace IS the filesystem: it lives at ~/.talon/ns (symlink
@@ -25,10 +26,12 @@
  * grammar in vfs.ts / fusefs.ts; consumers never see it.)
  */
 
-import { dirs } from "../../util/paths.js";
+import { dirs, files } from "../../util/paths.js";
 import { bus } from "../bus/index.js";
+import { activeAlerts } from "../frontend-runtime/alerts.js";
 import { registry } from "../plugin/registry.js";
 import { taskTable } from "../tasks/index.js";
+import { createDiagnosticViews } from "./mounts/diagnostics.js";
 import { createFileMount } from "./mounts/files.js";
 import { createPluginsMount, type PluginView } from "./mounts/plugins.js";
 import { createProcMount } from "./mounts/proc.js";
@@ -95,6 +98,10 @@ function buildDefaultNamespace(): Vfs {
     createProcMount({
       tasks: () => taskTable.list(),
       events: () => bus.recent(0),
+      views: createDiagnosticViews({
+        logPath: files.log,
+        alerts: activeAlerts,
+      }),
     }),
   );
   vfs.mount("plugins", createPluginsMount(pluginViews));

package/src/core/vfs/mounts/diagnostics.ts

@@ -0,0 +1,109 @@
+/**
+ * Diagnostic proc views — "what went wrong" without knowing a path:
+ *
+ *   proc/log      the last lines of talon.log, one human line each
+ *   proc/errors   recent warn/error/fatal entries, with stack frames
+ *   proc/alerts   the operator alerts currently raised
+ *
+ * Rendered text, not pino JSON, so `cat` answers the question directly.
+ * The log views read a bounded tail of talon.log (plus its newest
+ * rotated generation when the live file is young) — a regular file
+ * outside ~/.talon/ns, so the FUSE deadlock rule is not in play — and
+ * memoize for a second: FUSE stats a node before reading it, and both
+ * should see the same text without reading the log twice.
+ */
+
+import {
+  formatLogRecord,
+  readLogRecords,
+  type LogRecord,
+} from "../../daemon/log-reader.js";
+
+export type AlertView = {
+  key: string;
+  severity: string;
+  message: string;
+  since: number;
+};
+
+export interface DiagnosticViewDeps {
+  /** talon.log. */
+  logPath: string;
+  /** The live alert table (`activeAlerts`). */
+  alerts: () => ReadonlyArray<AlertView>;
+  now?: () => number;
+}
+
+const LOG_LINES = 200;
+const ERROR_ENTRIES = 100;
+const MEMO_MS = 1_000;
+/** Two generations: the live file and the one it rotated from. */
+const READ_OPTS = { maxFiles: 2, maxBytesPerFile: 1024 * 1024 } as const;
+
+function memo(render: () => string, now: () => number): () => string {
+  let cached: { at: number; text: string } | null = null;
+  return () => {
+    const t = now();
+    if (cached && t - cached.at < MEMO_MS) return cached.text;
+    cached = { at: t, text: render() };
+    return cached.text;
+  };
+}
+
+function body(records: LogRecord[], stackLines: number, max: number): string {
+  return records
+    .map((r) => formatLogRecord(r, { stackLines, maxMsgChars: max }))
+    .join("\n");
+}
+
+function renderLogView(logPath: string): string {
+  const records = readLogRecords(logPath, { limit: LOG_LINES, ...READ_OPTS });
+  if (records.length === 0) return `# ${logPath} is empty or missing\n`;
+  return (
+    `# last ${records.length} lines of ${logPath}, newest last ` +
+    `(older: ${logPath}.1…, or \`talon logs --since 1h\`)\n` +
+    `${body(records, 0, 400)}\n`
+  );
+}
+
+function renderErrorsView(logPath: string): string {
+  const records = readLogRecords(logPath, {
+    limit: ERROR_ENTRIES,
+    filter: { minLevel: "warn" },
+    ...READ_OPTS,
+  });
+  if (records.length === 0) {
+    return `# no warnings or errors in the recent ${logPath}\n`;
+  }
+  return (
+    `# last ${records.length} warn/error entries from ${logPath}, newest last\n` +
+    `${body(records, 5, 500)}\n`
+  );
+}
+
+export function renderAlertsView(
+  alerts: ReadonlyArray<AlertView>,
+  now: number,
+): string {
+  if (alerts.length === 0) return "# no active alerts\n";
+  const lines = alerts.map((a) => {
+    const mins = Math.max(0, Math.round((now - a.since) / 60_000));
+    return (
+      `[${a.severity}] ${a.key} since ${new Date(a.since).toISOString()} ` +
+      `(${mins} min)\n    ${a.message}`
+    );
+  });
+  return `# ${alerts.length} active alert(s)\n${lines.join("\n")}\n`;
+}
+
+/** The proc views, keyed by file name — wired by the vfs index. */
+export function createDiagnosticViews(
+  deps: DiagnosticViewDeps,
+): Record<string, () => string> {
+  const now = deps.now ?? Date.now;
+  return {
+    log: memo(() => renderLogView(deps.logPath), now),
+    errors: memo(() => renderErrorsView(deps.logPath), now),
+    alerts: () => renderAlertsView(deps.alerts(), now()),
+  };
+}

package/src/core/vfs/mounts/proc.ts

@@ -5,6 +5,8 @@
  *   proc/
  *     tasks/<id>   one task table record, pretty JSON
  *     events       the event bus ring, JSON Lines (newest last)
+ *     <view>       any extra text views the index wires (log, errors,
+ *                  alerts — see ./diagnostics.ts)
  *
  * Providers are injected so the mount is a pure projection — the index
  * wires the real task table and bus, tests wire fixtures. Sizes and
@@ -20,6 +22,8 @@ import { vfsError, vfsOk } from "../types.js";
 export interface ProcMountDeps {
   tasks: () => readonly TaskRecord[];
   events: () => readonly PublishedEvent[];
+  /** Extra read-only text files at the proc root, name → renderer. */
+  views?: Readonly<Record<string, () => string>>;
 }
 
 const DIR = (path: string, name: string): VfsStat => ({
@@ -54,6 +58,13 @@ function renderEvents(events: readonly PublishedEvent[]): string {
 }
 
 export function createProcMount(deps: ProcMountDeps): VfsMount {
+  const views: Readonly<Record<string, () => string>> = Object.assign(
+    Object.create(null) as Record<string, () => string>,
+    deps.views,
+  );
+  const viewStats = (): VfsStat[] =>
+    Object.keys(views).map((name) => fileStat(name, views[name]()));
+
   function taskById(id: string): TaskRecord | undefined {
     if (!/^\d+$/.test(id)) return undefined;
     return deps.tasks().find((task) => task.id === Number(id));
@@ -66,6 +77,7 @@ export function createProcMount(deps: ProcMountDeps): VfsMount {
       const events = deps.events();
       return vfsOk(fileStat("events", renderEvents(events), events.at(-1)?.at));
     }
+    if (views[rel]) return vfsOk(fileStat(rel, views[rel]()));
     const taskId = rel.startsWith("tasks/") ? rel.slice("tasks/".length) : null;
     if (taskId !== null && !taskId.includes("/")) {
       const task = taskById(taskId);
@@ -78,7 +90,9 @@ export function createProcMount(deps: ProcMountDeps): VfsMount {
   }
 
   return {
-    description: "Live daemon state: task table and event bus ring",
+    description: deps.views
+      ? "Live daemon state: task table, event bus ring, daemon log views"
+      : "Live daemon state: task table and event bus ring",
     writable: false,
 
     stat: resolveNode,
@@ -89,6 +103,7 @@ export function createProcMount(deps: ProcMountDeps): VfsMount {
         return vfsOk([
           DIR("tasks", "tasks"),
           fileStat("events", renderEvents(events), events.at(-1)?.at),
+          ...viewStats(),
         ]);
       }
       if (rel === "tasks") {
@@ -112,6 +127,7 @@ export function createProcMount(deps: ProcMountDeps): VfsMount {
 
     read(rel) {
       if (rel === "events") return vfsOk(renderEvents(deps.events()));
+      if (views[rel]) return vfsOk(views[rel]());
       if (rel.startsWith("tasks/")) {
         const task = taskById(rel.slice("tasks/".length));
         if (!task) return vfsError("not-found");

package/src/core/vfs/workspace.ts

@@ -20,6 +20,7 @@ import {
 } from "node:fs";
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
+import writeFileAtomic from "write-file-atomic";
 import { log } from "../../util/log.js";
 import { dirs, files as pathFiles } from "../../util/paths.js";
 import { listSeedPrompts, readPromptAsset } from "#prompt-assets";
@@ -259,8 +260,11 @@ function seedPrompts(): void {
     const pkgHash = sha256(pkg);
 
     if (!existsSync(dst)) {
+      // Atomic: a write cut short (ENOSPC, crash) must leave no file
+      // rather than a truncated one, which the next boot could not tell
+      // from a user edit and would keep forever.
       try {
-        writeFileSync(dst, pkg);
+        writeFileAtomic.sync(dst, pkg);
       } catch (err) {
         log(
           "workspace",
@@ -293,7 +297,7 @@ function seedPrompts(): void {
     } else if (seededHash !== undefined && curHash === seededHash) {
       // Pristine seeded copy + package changed → refresh on upgrade.
       try {
-        writeFileSync(dst, pkg);
+        writeFileAtomic.sync(dst, pkg);
       } catch {
         continue; // manifest keeps the old hash — retried next boot
       }
@@ -308,7 +312,7 @@ function seedPrompts(): void {
 
   if (manifestDirty) {
     try {
-      writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      writeFileAtomic.sync(manifestPath, JSON.stringify(manifest, null, 2));
     } catch {
       /* non-fatal — worst case we re-derive next boot */
     }