talon-agent 5.18.2 → 5.19.1

package/src/core/plugin/loader.ts

@@ -16,6 +16,8 @@ import type {
 import { isMcpPlugin } from "./types.js";
 import { registry, _deps } from "./registry.js";
 import { GATEWAY_TOKEN_ENV } from "../engine/gateway-auth.js";
+import { faultText } from "../engine/fault-text.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
 
 /**
  * Candidate entry point paths, checked in order. Exported for
@@ -48,7 +50,6 @@ export async function loadPlugins(
       );
       continue;
     }
-    // Standalone MCP servers are registered for getPluginMcpServers, not loaded as modules
     if (isMcpPlugin(entry)) {
       if (registry.registerMcpEntry(entry)) {
         log("plugin", `Registered standalone MCP server: ${entry.name}`);
@@ -108,6 +109,7 @@ export async function initPluginWithTimeout(
 
   let timer: ReturnType<typeof setTimeout> | undefined;
 
+  const alertKey = `plugin.${plugin.name}`;
   try {
     await Promise.race([
       Promise.resolve(plugin.init(config)),
@@ -120,11 +122,18 @@ export async function initPluginWithTimeout(
         timer.unref?.();
       }),
     ]);
+    resolveAlert(alertKey, `Plugin "${plugin.name}" initialised normally.`);
   } catch (err) {
     logError(
       "plugin",
       `${errorPrefix}: ${err instanceof Error ? err.message : err}`,
     );
+    // Init runs once per boot or reload: a plugin that failed it stays
+    // half-loaded until someone fixes it, so this needs no threshold.
+    raiseAlert(
+      alertKey,
+      `Plugin "${plugin.name}" failed to initialise: ${faultText(err)}. Its tools may not work until the next reload or restart.`,
+    );
   } finally {
     if (timer) clearTimeout(timer);
   }
@@ -136,7 +145,6 @@ async function loadSinglePlugin(
 ): Promise<void> {
   const pluginDir = resolve(entry.path);
 
-  // Resolve entry point
   const entryPoint = resolveEntryPoint(pluginDir);
   if (!entryPoint) {
     logError(
@@ -146,7 +154,6 @@ async function loadSinglePlugin(
     return;
   }
 
-  // Import and extract plugin module
   const mod = await _deps.importModule(entryPoint);
   const plugin = extractPlugin(mod);
   if (!plugin) {
@@ -157,7 +164,6 @@ async function loadSinglePlugin(
     return;
   }
 
-  // Check frontend whitelist — skip if plugin specifies frontends and none match
   if (plugin.frontends && plugin.frontends.length > 0 && activeFrontends) {
     const match = activeFrontends.some((fe) => plugin.frontends!.includes(fe));
     if (!match) {
@@ -173,7 +179,6 @@ async function loadSinglePlugin(
   const loaded = registerPluginInstance(plugin, config, pluginDir);
   if (!loaded) return;
 
-  // Run init hook
   await initPluginWithTimeout(
     loaded.plugin,
     loaded.config,
@@ -182,11 +187,14 @@ async function loadSinglePlugin(
     `Plugin "${loaded.plugin.name}" init failed`,
   );
 
-  const version = loaded.plugin.version ? ` v${loaded.plugin.version}` : "";
-  const desc = loaded.plugin.description
-    ? ` — ${loaded.plugin.description}`
-    : "";
-  log("plugin", `Loaded: ${loaded.plugin.name}${version}${desc}`);
+  log("plugin", `Loaded: ${describePlugin(loaded.plugin)}`);
+}
+
+/** `name v1.0 — description`, for load/register log lines. */
+function describePlugin(plugin: TalonPlugin): string {
+  const version = plugin.version ? ` v${plugin.version}` : "";
+  const desc = plugin.description ? ` — ${plugin.description}` : "";
+  return `${plugin.name}${version}${desc}`;
 }
 
 function resolveEntryPoint(pluginDir: string): string | null {
@@ -198,13 +206,11 @@ function resolveEntryPoint(pluginDir: string): string | null {
 }
 
 function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
-  // Support: export default { ... } or module.exports = { ... }
+  // `export default { … }` or `module.exports = { … }`
   const candidate = mod.default ?? mod;
   if (!candidate || typeof candidate !== "object") return null;
   const plugin = candidate as Record<string, unknown>;
-  // Validate required field types
   if (typeof plugin.name !== "string" || !plugin.name) return null;
-  // Validate optional fields are the right types if present
   if (
     plugin.handleAction !== undefined &&
     typeof plugin.handleAction !== "function"
@@ -241,33 +247,27 @@ function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
 
 // ── Public API ─────────────────────────────────────────────────────────────
 
-/** Get all loaded plugins. */
 export function getLoadedPlugins(): readonly LoadedPlugin[] {
   return registry.all;
 }
 
-/** Get a plugin by name. */
 export function getPlugin(name: string): LoadedPlugin | undefined {
   return registry.getByName(name);
 }
 
-/** Number of loaded plugins. */
 export function getPluginCount(): number {
   return registry.count;
 }
 
-/** Destroy all plugins (called during shutdown). */
+/** Shutdown path. */
 export async function destroyPlugins(): Promise<void> {
   await registry.destroyAll();
 }
 
 /**
- * Register a built-in plugin directly (bypasses filesystem loader).
- * Used for tightly-integrated plugins like mempalace that are configured via
- * dedicated config fields rather than the plugins[] array.
- *
- * NOTE: This only registers the plugin — it does NOT call `init()`. The caller
- * is responsible for calling `plugin.init()` separately after registration.
+ * Register a built-in plugin (configured by its own config section, not a
+ * `plugins[]` entry) without the filesystem loader. Does NOT call `init()`;
+ * the caller does.
  */
 export function registerPlugin(
   plugin: TalonPlugin,
@@ -275,19 +275,11 @@ export function registerPlugin(
 ): LoadedPlugin | null {
   const loaded = registerPluginInstance(plugin, config, "(built-in)");
   if (!loaded) return null;
-
-  const version = loaded.plugin.version ? ` v${loaded.plugin.version}` : "";
-  const desc = loaded.plugin.description
-    ? ` — ${loaded.plugin.description}`
-    : "";
-  log("plugin", `Registered built-in: ${loaded.plugin.name}${version}${desc}`);
+  log("plugin", `Registered built-in: ${describePlugin(loaded.plugin)}`);
   return loaded;
 }
 
-/**
- * Collect system prompt additions from all plugins.
- * Called during config/prompt assembly.
- */
+/** Every plugin's trimmed system-prompt addition, load order. */
 export function getPluginPromptAdditions(): string[] {
   const additions: string[] = [];
   for (const { plugin, config } of registry.all) {

package/src/core/plugin/mcp.ts

@@ -1,7 +1,7 @@
 /**
- * MCP server config — build the Claude Agent SDK MCP server map for plugins
- * that expose an MCP server (via `mcpServer` command/args or `mcpServerPath`),
- * plus the standalone MCP entries from config.
+ * MCP server specs — the stdio command for every plugin that exposes an MCP
+ * server (via `mcpServer` command/args or `mcpServerPath`), plus the
+ * standalone MCP entries from config. The hub spawns its children from these.
  */
 
 import { resolve } from "node:path";
@@ -54,7 +54,6 @@ export function getPluginMcpServers(
   );
 
   for (const { plugin, envVars } of registry.all) {
-    // Skip plugins not in the allow-list when filtering
     if (only !== undefined && !only.includes(plugin.name)) continue;
 
     // Let the plugin re-materialize on-disk state the child will read. Runs
@@ -95,7 +94,6 @@ export function getPluginMcpServers(
     }
   }
 
-  // Include standalone MCP server entries from config
   for (const entry of registry.mcpEntries) {
     if (only !== undefined && !only.includes(entry.name)) continue;
     servers[`${entry.name}-tools`] = wrapMcpServer({

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));