talon-agent 5.18.1 → 5.19.0

package/src/cli/logs.ts

@@ -1,13 +1,72 @@
 /**
  * `talon logs` — pretty-print the last lines of the JSON log file and then
  * tail it live.
+ *
+ * Filters (`--errors`, `--component`, `--since`, `--grep`, `--turn`)
+ * switch to the shared log reader (core/daemon/log-reader.ts — the same
+ * parser behind proc/log, proc/errors and doctor): the backlog is read
+ * across rotated generations, and the live tail applies the same filter.
+ * `--no-follow` prints the backlog and exits, for scripts and agents.
  */
 
 import pc from "picocolors";
 import { existsSync, readFileSync, watchFile } from "node:fs";
+import type { LogFilter, LogRecord } from "../core/daemon/log-reader.js";
 import { printBanner } from "./config.js";
 import { LOG_FILE } from "./context.js";
 
+export type LogsOptions = {
+  filter: LogFilter;
+  /** Keep tailing after the backlog (default true). */
+  follow: boolean;
+  /** Backlog size; undefined = 30, or 1000 under `--since`. */
+  lines?: number;
+};
+
+const LOGS_USAGE =
+  "talon logs [--errors] [--component <c>] [--since <30m|2h|1d>] " +
+  "[--grep <text>] [--turn <id>] [-n <lines>] [--no-follow]";
+
+/** Parse `talon logs` argv; a string is a usage error to print. */
+export async function parseLogsArgs(
+  args: string[],
+  now: number = Date.now(),
+): Promise<LogsOptions | string> {
+  const { parseLogDuration } = await import("../core/daemon/log-reader.js");
+  const opts: LogsOptions = { filter: {}, follow: true };
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i];
+    const value = (): string | undefined => args[++i];
+    if (flag === "--errors") opts.filter.minLevel = "warn";
+    else if (flag === "--no-follow") opts.follow = false;
+    else if (flag === "--component") opts.filter.component = value();
+    else if (flag === "--grep") opts.filter.grep = value();
+    else if (flag === "--turn") opts.filter.turn = value();
+    else if (flag === "--since") {
+      const ms = parseLogDuration(value() ?? "");
+      if (ms === null) return `--since needs a duration like 30m, 2h, 1d`;
+      opts.filter.since = now - ms;
+    } else if (flag === "-n" || flag === "--lines") {
+      const n = Number(value());
+      if (!Number.isInteger(n) || n <= 0) return `${flag} needs a count`;
+      opts.lines = n;
+    } else return `unknown option: ${flag}\n  usage: ${LOGS_USAGE}`;
+    if (i >= args.length) return `${flag} needs a value`;
+  }
+  return opts;
+}
+
+/** `parseLogsArgs` then run; usage errors exit non-zero. */
+export async function runLogsCommand(args: string[]): Promise<void> {
+  const opts = await parseLogsArgs(args);
+  if (typeof opts === "string") {
+    console.error(`  ${pc.red("✖")} ${opts}`);
+    process.exitCode = 1;
+    return;
+  }
+  await tailLogs(opts);
+}
+
 const LEVEL_LABELS: Record<number, string> = {
   10: pc.dim("TRC"),
   20: pc.dim("DBG"),
@@ -17,6 +76,25 @@ const LEVEL_LABELS: Record<number, string> = {
   60: pc.bgRed(pc.white("FTL")),
 };
 
+const LEVEL_NAME_LABELS: Record<LogRecord["level"], string> = {
+  trace: LEVEL_LABELS[10],
+  debug: LEVEL_LABELS[20],
+  info: LEVEL_LABELS[30],
+  warn: LEVEL_LABELS[40],
+  error: LEVEL_LABELS[50],
+  fatal: LEVEL_LABELS[60],
+};
+
+/** A parsed record in the same shape as {@link formatLogLine}. */
+function formatRecord(rec: LogRecord): string {
+  const time = pc.dim(new Date(rec.ts).toTimeString().slice(0, 8));
+  const comp = pc.cyan((rec.component ?? "?").padEnd(10));
+  const turn =
+    rec.turn && !rec.msg.includes("turn=") ? ` turn=${rec.turn}` : "";
+  const err = rec.err ? pc.red(` (${rec.err})`) : "";
+  return `  ${time} ${LEVEL_NAME_LABELS[rec.level]} ${comp} ${rec.msg}${turn}${err}`;
+}
+
 function formatLogLine(line: string): string {
   try {
     const obj = JSON.parse(line);
@@ -31,7 +109,13 @@ function formatLogLine(line: string): string {
   }
 }
 
-export async function tailLogs(): Promise<void> {
+function hasFilter(filter: LogFilter): boolean {
+  return Object.values(filter).some((v) => v !== undefined);
+}
+
+export async function tailLogs(
+  opts: LogsOptions = { filter: {}, follow: true },
+): Promise<void> {
   printBanner();
   if (!existsSync(LOG_FILE)) {
     console.log(
@@ -39,18 +123,73 @@ export async function tailLogs(): Promise<void> {
     );
     return;
   }
-  console.log(
-    `  ${pc.dim("Tailing")} ${pc.dim(LOG_FILE)}\n  ${pc.dim("Press Ctrl+C to stop")}\n`,
-  );
+  if (hasFilter(opts.filter)) return tailFiltered(opts);
+  if (opts.follow) {
+    console.log(
+      `  ${pc.dim("Tailing")} ${pc.dim(LOG_FILE)}\n  ${pc.dim("Press Ctrl+C to stop")}\n`,
+    );
+  }
   const content = readFileSync(LOG_FILE, "utf-8");
   const lines = content.trim().split("\n");
-  for (const line of lines.slice(-30)) console.log(formatLogLine(line));
-  let lastSize = lines.length;
-  watchFile(LOG_FILE, { interval: 500 }, () => {
+  for (const line of lines.slice(-(opts.lines ?? 30)))
+    console.log(formatLogLine(line));
+  if (!opts.follow) return;
+  await followLog(lines.length, (line) => console.log(formatLogLine(line)));
+}
+
+/** The filtered path: backlog across generations, then a filtered tail. */
+async function tailFiltered(opts: LogsOptions): Promise<void> {
+  const { readLogRecords, parseLogLine, matchesLogFilter } =
+    await import("../core/daemon/log-reader.js");
+  const limit = opts.lines ?? (opts.filter.since !== undefined ? 1000 : 30);
+  const backlog = readLogRecords(LOG_FILE, {
+    limit,
+    filter: opts.filter,
+    // The CLI owns its process: read whole generations, not a window.
+    maxBytesPerFile: 64 * 1024 * 1024,
+  });
+  const desc = describeFilter(opts.filter);
+  console.log(
+    `  ${pc.dim(`${backlog.length} matching entr${backlog.length === 1 ? "y" : "ies"} (${desc})`)}` +
+      (opts.follow ? `\n  ${pc.dim("Following — Ctrl+C to stop")}` : "") +
+      "\n",
+  );
+  for (const rec of backlog) console.log(formatRecord(rec));
+  if (!opts.follow) return;
+  const start = readFileSync(LOG_FILE, "utf-8").trim().split("\n").length;
+  await followLog(start, (line) => {
+    const rec = parseLogLine(line);
+    if (rec && matchesLogFilter(rec, opts.filter))
+      console.log(formatRecord(rec));
+  });
+}
+
+function describeFilter(filter: LogFilter): string {
+  const parts: string[] = [];
+  if (filter.minLevel) parts.push(`>=${filter.minLevel}`);
+  if (filter.component) parts.push(`component=${filter.component}`);
+  if (filter.since !== undefined)
+    parts.push(`since ${new Date(filter.since).toTimeString().slice(0, 8)}`);
+  if (filter.grep) parts.push(`grep "${filter.grep}"`);
+  if (filter.turn) parts.push(`turn=${filter.turn}`);
+  return parts.join(", ");
+}
+
+/** Print each line appended to the log from line `from` on, forever. */
+async function followLog(
+  from: number,
+  onLine: (line: string) => void,
+): Promise<void> {
+  let lastSize = from;
+  watchFile(LOG_FILE, { interval: 500 }, (curr, prev) => {
+    // A rotation (daemon start → talon.log.old, or the sink's runtime
+    // shift to talon.log.1) leaves a new file under the name, and counting
+    // its lines against the old one's would stay silent until it outgrew
+    // the file it replaced.
+    if (curr.ino !== prev.ino || curr.size < prev.size) lastSize = 0;
     try {
       const nl = readFileSync(LOG_FILE, "utf-8").trim().split("\n");
-      for (let i = lastSize; i < nl.length; i++)
-        console.log(formatLogLine(nl[i]));
+      for (let i = lastSize; i < nl.length; i++) onLine(nl[i]);
       lastSize = nl.length;
     } catch {
       /* ignore */

package/src/cli/setup.ts

@@ -26,11 +26,9 @@ const trimmedOrUndefined = (raw: string) => raw.trim() || undefined;
 /**
  * Await a clack prompt; on Esc/Ctrl-C say so and leave the wizard.
  *
- * Every prompt used to be followed by the same four-line `isCancel` guard,
- * and because `@clack/core` narrows `isCancel` to its own unique symbol
- * the unguarded remainder still needed an `as string` cast. clack only
- * ever resolves a symbol to mean "cancelled", so narrowing on `typeof`
- * here removes both.
+ * clack only ever resolves a symbol to mean "cancelled", so narrowing on
+ * `typeof` replaces a per-prompt `isCancel` guard and the `as` cast that
+ * `@clack/core`'s own unique-symbol narrowing would still need.
  *
  * The answer type is subtracted with `Exclude` rather than inferred from a
  * `Promise<T | symbol>` parameter: clack 1.8.1 retyped `CANCEL_SYMBOL` as a
@@ -667,12 +665,12 @@ function telegramAccess(
  *
  * Extracted from `runSetup` so the merge is testable without driving the
  * prompts — the behaviour that matters here is what it *doesn't* touch.
- * The wizard models roughly half of ~/.talon/config.json; it used to
- * rebuild the file from its own named fields alone, which silently
- * deleted every other key (whatsapp, native, soul, memory, github,
- * heartbeat/dream, allowlists, plugin blocks…). Spreading `existing`
- * first keeps them. Fields below still override, and an explicit
- * `undefined` still deletes, because `saveConfig` strips undefined.
+ * The wizard models roughly half of ~/.talon/config.json. Spreading
+ * `existing` first keeps every key it does not model (whatsapp, native,
+ * memory, github, heartbeat/dream, allowlists, plugin blocks…) — building
+ * from the named fields alone silently deletes them. Fields below still
+ * override, and an explicit `undefined` still deletes, because
+ * `saveConfig` strips undefined.
  */
 export function buildSetupConfig(
   existing: Config,

package/src/cli/status.ts

@@ -15,6 +15,29 @@ function formatUptime(seconds: number): string {
   return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
 }
 
+type HealthAlert = { key: string; severity: string; message: string };
+
+/** The daemon's active alerts from its /health body (older daemons: none). */
+function healthAlerts(health: Record<string, unknown>): HealthAlert[] {
+  const raw = health.alerts;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (a): a is HealthAlert =>
+      typeof a === "object" &&
+      a !== null &&
+      typeof a.key === "string" &&
+      typeof a.message === "string",
+  );
+}
+
+/** One line per active alert, coloured by severity. Shared with doctor. */
+export function formatAlertLines(health: Record<string, unknown>): string[] {
+  return healthAlerts(health).map((a) => {
+    const dot = a.severity === "warn" ? pc.yellow("●") : pc.red("●");
+    return `  ${dot} ${pc.bold(a.key)}  ${a.message}`;
+  });
+}
+
 export async function showStatus(): Promise<void> {
   printBanner();
   const instance = await findRunningInstance();
@@ -38,6 +61,12 @@ export async function showStatus(): Promise<void> {
     console.log(`  ${pc.dim("Queue")}        ${h.queue} pending`);
     console.log(`  ${pc.dim("Errors")}       ${h.errors}`);
     console.log(`  ${pc.dim("Last active")}  ${h.lastActivity}\n`);
+    const alerts = formatAlertLines(h);
+    if (alerts.length > 0) {
+      console.log(`  ${pc.bold("Active alerts")}\n`);
+      for (const line of alerts) console.log(line);
+      console.log();
+    }
     return;
   }
 

package/src/core/agent-runtime/README.md

@@ -41,15 +41,16 @@ error | completed
 ```
 
 Plus `UsageSnapshot`, `AgentError` (with `AgentErrorKind`),
-`AgentResult`. Helpers: `emptyUsage`, `addUsage`, `isAgentEventOf`,
-`isAgentRunTerminator`.
+`AgentResult`, and `AgentRunError` — what the dispatcher rethrows an
+`error` terminator as. Helpers: `emptyUsage`, `toolInputToRecord`,
+`classifiedToAgentError`.
 
 ### `model-ref.ts`
 
 Typed model identity. `ModelRef = { backend: BackendId, id,
 displayName, ... }`. Owns the `BACKEND_IDS` literal — single source of
 truth for which backends the typed union can route to. Helpers:
-`isBackendId`, `sameModelRef`, `makeBareModelRef`.
+`isBackendId`, `makeBareModelRef`.
 
 ### `capabilities.ts`
 
@@ -101,16 +102,6 @@ Backend contract assertions any conforming `Backend` must pass:
 
 Each throws `ContractViolation` with a descriptive message.
 
-### `event-bridge.ts`
-
-The bridge between the canonical `AgentEvent` stream and the
-callback-shaped consumer contract the dispatcher uses upstream of the
-backend. `pipeEventsToCallbacks(stream, callbacks)` consumes an
-`AgentEvent` stream and invokes the supplied callbacks (`onStreamDelta`
-/ `onTextBlock` / `onToolUse`), returns the final `AgentResult`, and
-throws `BridgedAgentError` carrying the original `AgentError` if the
-stream terminates with an error event.
-
 ## Migration cookbook
 
 ### Adding a new backend
@@ -164,11 +155,6 @@ returns `{ model: string | null, ref: ModelRef | null, source }`:
 - `source` carries the chain step that produced the model, useful
   for toast wording and stale-slot cleanup.
 
-Convenience wrappers:
-
-- `getActiveModelForChat(...)` → `model`
-- `getActiveModelRefForChat(...)` → `ref`
-
 ### Adding a new store
 
 New structured state goes in the SQLite layer — see the layering doc
@@ -178,7 +164,7 @@ in `src/storage/db.ts` (sql/<store>.sql → repositories/<store>-repo.ts
 ## Invariants
 
 - `BACKEND_IDS` in `model-ref.ts` is the source of truth for the typed
-  union. `src/util/config.ts` zod enums are wired to the same literal.
+  union. `core/config/index.ts` zod enums are wired to the same literal.
 - `AgentEvent.type` is the ONLY discrimination mechanism. No class
   hierarchy, no `instanceof` checks.
 - Every `ChatBackend.runChatTurn` stream terminates with `completed`

package/src/core/agent-runtime/events.ts

@@ -5,12 +5,12 @@
  * Every backend (Claude SDK, Codex, Kilo, OpenCode, OpenAI Agents)
  * translates its SDK's native event stream into `AgentEvent`s. Core
  * renderers (Telegram dispatch, terminal output, heartbeat log,
- * dream log, `/status`, tests) consume `AgentEvent`s. Backends no
- * longer render markdown logs themselves and core no longer parses
+ * dream log, `/status`, tests) consume `AgentEvent`s. Backends don't
+ * render markdown logs themselves and core never parses
  * backend-specific output.
  *
  * The shared wrapper `backend/runtime/turn/handler-to-events.ts` converts
- * each backend's existing callback-driven `handleMessage` into the
+ * each backend's callback-driven `handleMessage` into the
  * canonical sequence: `run_started → text_delta* →
  * assistant_message* → tool_call* → usage → completed`. Backends
  * with richer SDKs can emit events directly without the wrapper.
@@ -146,27 +146,6 @@ export type AgentEvent =
   | { type: "error"; error: AgentError }
   | { type: "completed"; result?: AgentResult };
 
-/**
- * Type-narrowing helper. Saves callers from writing
- * `event.type === "completed"` in two places when they need both the
- * narrowing and a boolean expression.
- */
-export function isAgentEventOf<K extends AgentEvent["type"]>(
-  event: AgentEvent,
-  kind: K,
-): event is Extract<AgentEvent, { type: K }> {
-  return event.type === kind;
-}
-
-/**
- * Whether this event is a stream terminator — `completed` (success)
- * or `error` (failure). Useful for stream consumers that want to
- * release a typing indicator or close a log section on either.
- */
-export function isAgentRunTerminator(event: AgentEvent): boolean {
-  return event.type === "completed" || event.type === "error";
-}
-
 /**
  * Error thrown when an `AgentEvent` stream terminates with an `error`
  * event. The dispatcher consumes the canonical event stream directly
@@ -234,21 +213,6 @@ export function emptyUsage(): UsageSnapshot {
   };
 }
 
-/**
- * Accumulate two usage snapshots. Pure — caller passes both, gets a
- * new object back. Used by stream consumers that aggregate per-event
- * usage into a final figure for `/status`.
- */
-export function addUsage(a: UsageSnapshot, b: UsageSnapshot): UsageSnapshot {
-  return {
-    inputTokens: a.inputTokens + b.inputTokens,
-    outputTokens: a.outputTokens + b.outputTokens,
-    cacheRead: a.cacheRead + b.cacheRead,
-    cacheWrite: a.cacheWrite + b.cacheWrite,
-    modelId: b.modelId ?? a.modelId,
-  };
-}
-
 /**
  * The `core/errors.ts` reasons that map to a specific `AgentErrorKind`.
  * Anything not listed collapses to `unknown`. `ErrorReason` is

package/src/core/agent-runtime/model-ref.ts

@@ -102,14 +102,6 @@ export interface ModelRef {
   unavailableReason?: string;
 }
 
-/**
- * Equality on identity only — two refs are the same run if they
- * point at the same backend + id.
- */
-export function sameModelRef(a: ModelRef, b: ModelRef): boolean {
-  return a.backend === b.backend && a.id === b.id;
-}
-
 /**
  * Bare-minimum constructor for tests and adapters that don't yet
  * carry rich metadata. Real catalog code should populate the

package/src/core/agents/registry.ts

@@ -25,6 +25,7 @@ import type { TaskUsage } from "../tasks/types.js";
 import type { AgentSettledEvent, AgentSpawnedEvent } from "../bus/events.js";
 import type { ReasoningEffortLevel } from "../types.js";
 import { bus } from "../bus/index.js";
+import { logWarn } from "../../util/log.js";
 
 /** Settled agents kept for status queries after they leave the live map. */
 const DEFAULT_HISTORY_LIMIT = 100;
@@ -87,6 +88,23 @@ interface LiveAgent {
   killRequested: boolean;
 }
 
+/**
+ * Whether two agents were spawned by the same parent.
+ *
+ * Compared structurally rather than by reference: records come from separate
+ * snapshots, so the parent objects are equal in value and never identical.
+ * The `kind` check is what stops a chat-parented agent matching an
+ * agent-parented one whose id happens to equal a chat key.
+ */
+function sameParent(a: AgentParent, b: AgentParent): boolean {
+  if (a.kind !== b.kind) return false;
+  return a.kind === "chat" && b.kind === "chat"
+    ? a.chatId === b.chatId
+    : a.kind === "agent" && b.kind === "agent"
+      ? a.agentId === b.agentId
+      : false;
+}
+
 function snapshot(entry: LiveAgent): AgentRecord {
   return {
     ...entry.record,
@@ -279,8 +297,13 @@ export class AgentRegistry {
       entry.killRequested = true;
       try {
         entry.abort?.abort();
-      } catch {
-        // An abort hook must not be able to break the kill path.
+      } catch (err) {
+        // An abort hook must not be able to break the kill path — but a
+        // throwing one may leave the agent running, so say so.
+        logWarn(
+          "agents",
+          `Abort hook threw agent=${id}: ${err instanceof Error ? err.message : String(err)}`,
+        );
       }
     }
     return true;
@@ -351,6 +374,30 @@ export class AgentRegistry {
     return children.filter((child) => this.live.has(child));
   }
 
+  /**
+   * An agent's live **peers** — the other agents sharing its parent.
+   *
+   * This is the addressing scope for agent-to-agent messaging, and it is
+   * deliberately narrower than "everything under the same chat". A swarm is
+   * a set of siblings spawned for one job, so siblings are the useful unit;
+   * widening to the whole chat tree would let an agent reach a cousin from an
+   * unrelated piece of work it knows nothing about.
+   *
+   * Live only: a settled agent has no mailbox to deliver into, and offering
+   * it as a peer would only produce a delivery failure one call later.
+   */
+  peersOf(id: string): AgentRecord[] {
+    const self = this.get(id);
+    if (!self) return [];
+    const peers: AgentRecord[] = [];
+    for (const entry of this.live.values()) {
+      const record = snapshot(entry);
+      if (record.id === id) continue;
+      if (sameParent(record.parent, self.parent)) peers.push(record);
+    }
+    return peers.sort((a, b) => a.createdAt - b.createdAt);
+  }
+
   /** Live agents plus the bounded settled ring, oldest first. */
   list(): AgentRecord[] {
     const records = [...this.history];

package/src/core/auth/expiry-monitor.ts

@@ -10,6 +10,7 @@
  */
 
 import { notifyAdmin } from "../frontend-runtime/admin-notify.js";
+import { logWarn } from "../../util/log.js";
 import {
   daysUntil,
   PROVIDER_LABELS,
@@ -75,7 +76,14 @@ export function resetAuthExpiryAnnouncements(): void {
 
 export function startAuthExpiryMonitor(): () => void {
   const tick = (): void => {
-    void runAuthExpiryCheck().catch(() => {});
+    void runAuthExpiryCheck().catch((err: unknown) => {
+      // The alert is already marked announced, so a failed send is not
+      // retried until the status changes — the log is its only trace.
+      logWarn(
+        "notify",
+        `auth expiry check failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    });
   };
   // First check shortly after boot so a lapsed login is surfaced right away.
   const first = setTimeout(tick, 30_000);

package/src/core/auth/login-flow.ts

@@ -160,7 +160,15 @@ export function startLogin(
         new Error(outcome.ok ? "no prompt" : outcome.detail || outcome.reason),
       );
     if (tmpHome)
-      await rm(tmpHome, { recursive: true, force: true }).catch(() => {});
+      await rm(tmpHome, { recursive: true, force: true }).catch(
+        (err: unknown) =>
+          // The scratch HOME can hold a fresh credential copy — a leftover
+          // is worth knowing about.
+          logWarn(
+            "notify",
+            `${provider} login cleanup failed dir=${tmpHome}: ${err instanceof Error ? err.message : String(err)}`,
+          ),
+      );
     resolveDone(outcome);
   };
 

package/src/core/auth/status.ts

@@ -15,6 +15,7 @@
 import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { logWarn } from "../../util/log.js";
 
 export type AuthProvider = "claude" | "codex";
 
@@ -64,6 +65,19 @@ export function clearProviderExpired(provider: AuthProvider): void {
   reportedExpired.delete(provider);
 }
 
+/**
+ * A credentials file that exists but isn't JSON reads as "not signed
+ * in" — indistinguishable from a missing login unless logged. Nothing
+ * from the file goes into the line: JSON.parse's message quotes the
+ * input, and the input is a token.
+ */
+function warnUnparseable(provider: AuthProvider): void {
+  logWarn(
+    "notify",
+    `${provider} credentials file is not valid JSON — reporting not signed in`,
+  );
+}
+
 export function parseClaudeCredentials(raw: string): ProviderAuthStatus {
   const base: ProviderAuthStatus = {
     provider: "claude",
@@ -81,6 +95,7 @@ export function parseClaudeCredentials(raw: string): ProviderAuthStatus {
   try {
     parsed = JSON.parse(raw);
   } catch {
+    warnUnparseable("claude");
     return base;
   }
   const oauth = parsed.claudeAiOauth;
@@ -115,6 +130,7 @@ export function parseCodexAuth(raw: string): ProviderAuthStatus {
   try {
     parsed = JSON.parse(raw);
   } catch {
+    warnUnparseable("codex");
     return base;
   }
   const apiKey =
@@ -136,11 +152,23 @@ export function parseCodexAuth(raw: string): ProviderAuthStatus {
   };
 }
 
-async function readOrEmpty(path: string): Promise<string | undefined> {
+async function readOrEmpty(
+  provider: AuthProvider,
+  path: string,
+): Promise<string | undefined> {
   try {
     await stat(path);
     return await readFile(path, "utf8");
-  } catch {
+  } catch (err) {
+    // Missing is the normal signed-out case; anything else (EACCES,
+    // EISDIR) is a fault that would otherwise read as signed out too.
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") {
+      logWarn(
+        "notify",
+        `${provider} credentials unreadable code=${code ?? "?"} — reporting not signed in`,
+      );
+    }
     return undefined;
   }
 }
@@ -151,7 +179,7 @@ export async function readProviderStatus(
 ): Promise<ProviderAuthStatus> {
   const path =
     provider === "claude" ? claudeCredentialsPath(env) : codexAuthPath(env);
-  const raw = await readOrEmpty(path);
+  const raw = await readOrEmpty(provider, path);
   const status =
     raw === undefined
       ? { provider, loggedIn: false, expired: true }

package/src/core/background/cron/scheduler.ts

@@ -34,6 +34,8 @@ import {
 } from "../../../storage/cron.js";
 import { appendDailyLog } from "../../../storage/daily-log.js";
 import { log, logError, logWarn } from "../../../util/log.js";
+import { raiseAlert, resolveAlert } from "../../frontend-runtime/alerts.js";
+import { faultText } from "../../engine/fault-text.js";
 import { numericChatIdFor } from "../../frontend-runtime/chat-id.js";
 import {
   chooseBackend,
@@ -156,8 +158,12 @@ async function runCronTick(): Promise<void> {
   pruneJobHealth(new Set(jobs.map((j) => j.id)));
 
   let loadShed = false;
-  for (const job of jobs) {
-    if (!job.enabled) continue;
+  for (const listed of jobs) {
+    // Re-read: each run is awaited, so a slow job lets the next tick start
+    // and run later jobs before this loop reaches them. The listing's copy
+    // would carry the pre-run lastRunAt and fire such a job a second time.
+    const job = getCronJob(listed.id);
+    if (!job?.enabled) continue;
     // Expiry takes priority over dueness: a job past its end time is disabled
     // and skipped even if this minute would otherwise match.
     if (expireIfPast(job, nowMs)) continue;
@@ -201,6 +207,10 @@ async function runScheduled(job: CronJob): Promise<void> {
       durationMs: Date.now() - startedAt,
     };
     recordJobSuccess(job.id, Date.now(), JOB_HEALTH);
+    resolveAlert(
+      `cron.job.${job.id}`,
+      `Cron job "${job.name}" is running again.`,
+    );
     recordCronRun(job.id, outcome);
     appendDailyLog(
       "Cron",
@@ -223,12 +233,23 @@ async function runScheduled(job: CronJob): Promise<void> {
       lastError: err instanceof Error ? err.message : String(err),
       lastDurationMs: Date.now() - startedAt,
     });
-    logError("cron", `Job "${job.name}" [${job.id}] failed`, err);
+    logError(
+      "cron",
+      `Job "${job.name}" [${job.id}] failed chat=${job.chatId} type=${job.type} ms=${Date.now() - startedAt}`,
+      err,
+    );
     const cooldown = recordJobFailure(job.id, Date.now(), JOB_HEALTH);
     if (cooldown !== null) {
+      const mins = Math.round(cooldown / 60_000);
       logWarn(
         "cron",
-        `Breaker opened for "${job.name}" [${job.id}] — cooling down ~${Math.round(cooldown / 60_000)}min`,
+        `Breaker opened for "${job.name}" [${job.id}] — cooling down ~${mins}min`,
+      );
+      // The breaker opens at JOB_HEALTH.threshold consecutive failures —
+      // the job is now paused, which the operator should hear about.
+      raiseAlert(
+        `cron.job.${job.id}`,
+        `Cron job "${job.name}" failed ${JOB_HEALTH.threshold} runs in a row: ${faultText(err)}. Paused for ~${mins} min.`,
       );
     }
   } finally {
@@ -461,7 +482,6 @@ function isCronDue(job: CronJob, now: Date, windowStartMs: number): boolean {
 export const _cronInternals = {
   isDue,
   isCronDue,
-  MAX_TICK_LOOKBACK_MS,
 };
 
 /**