talon-agent 5.18.2 → 5.19.0

package/src/storage/media-index.ts

@@ -17,11 +17,12 @@
 
 import { existsSync, unlinkSync } from "node:fs";
 import { blake3HexFile } from "../native/blake3.js";
-import { log, logError } from "../util/log.js";
+import { log, logError, logWarn } from "../util/log.js";
 import { recordError } from "../util/watchdog.js";
 import { files } from "../util/paths.js";
 import { importLegacyJson } from "./legacy-import.js";
 import { setMessageFilePath } from "./history.js";
+import { dbErrorFields } from "./db.js";
 import * as repo from "./repositories/media-index-repo.js";
 
 export type { MediaEntry } from "./repositories/media-index-repo.js";
@@ -75,7 +76,11 @@ export function addMedia(entry: Omit<MediaEntry, "id">): void {
   try {
     repo.upsert(entry);
   } catch (err) {
-    logError("media", "Media index save failed", err);
+    logError(
+      "media",
+      `Media index save failed chat=${entry.chatId} msg=${entry.msgId} path=${entry.filePath}${dbErrorFields(err)}`,
+      err,
+    );
     recordError(
       `Media index write failed: ${err instanceof Error ? err.message : err}`,
     );
@@ -116,8 +121,13 @@ async function hashAndDedupe(entry: Omit<MediaEntry, "id">): Promise<void> {
         "media",
         `Deduped ${entry.filePath} -> ${canonical.filePath} (blake3 ${hash.slice(0, 12)}…)`,
       );
-    } catch {
-      /* dedupe is best-effort; the entry already points at the canonical copy */
+    } catch (err) {
+      // Dedupe is best-effort — the entry already points at the canonical
+      // copy — but the duplicate now sits on disk unreferenced.
+      logWarn(
+        "media",
+        `Dedupe unlink failed path=${entry.filePath}: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
   }
 }
@@ -161,17 +171,29 @@ function purgeExpired(): void {
     const removed = repo.deleteOlderThan(cutoff);
     // Rows first, files second: content dedupe means several entries can
     // share one file, so only unlink paths no surviving row references.
+    let unlinkFailures = 0;
+    let firstFailure = "";
     for (const path of new Set(expired.map((e) => e.filePath))) {
       if (repo.countByFilePath(path) > 0) continue;
       try {
         if (existsSync(path)) unlinkSync(path);
-      } catch {
-        /* skip */
+      } catch (err) {
+        // Skip it, but count: files left behind are disk that the purge
+        // thinks it reclaimed.
+        if (unlinkFailures++ === 0) {
+          firstFailure = `${path}: ${err instanceof Error ? err.message : String(err)}`;
+        }
       }
     }
     if (removed > 0) {
       log("media", `Purged ${removed} expired media entries`);
     }
+    if (unlinkFailures > 0) {
+      logWarn(
+        "media",
+        `Media purge left ${unlinkFailures} expired file(s) on disk; first=${firstFailure}`,
+      );
+    }
   } catch (err) {
     logError("media", "Media index purge failed", err);
   }

package/src/storage/repositories/chat-settings-repo.ts

@@ -11,6 +11,7 @@
  * queried independently in SQL.
  */
 
+import { logWarn } from "../../util/log.js";
 import { getDatabase, inTransaction } from "../db.js";
 import { chatSettingsSql } from "../sql/statements.generated.js";
 import type { ReasoningEffortLevel } from "../../types/effort.js";
@@ -102,8 +103,13 @@ export function all(): Array<{ chatId: string; settings: ChatSettings }> {
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         result.push({ chatId: row.chat_id, settings: parsed });
       }
-    } catch {
-      /* skip unparseable row */
+    } catch (err) {
+      // Skip the unparseable row; the chat silently falls back to
+      // defaults otherwise.
+      logWarn(
+        "settings",
+        `Skipped corrupt chat settings chat=${row.chat_id}: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
   }
   return result;

package/src/storage/repositories/sessions-repo.ts

@@ -12,6 +12,7 @@
  * column default can hold.
  */
 
+import { logWarn } from "../../util/log.js";
 import { getDatabase, inTransaction } from "../db.js";
 import { sessionsSql } from "../sql/statements.generated.js";
 import {
@@ -46,13 +47,19 @@ type Row = {
   metrics: string | null;
 };
 
-function parseMetrics(raw: string | null): SessionMetrics {
+function parseMetrics(raw: string | null, chatId: string): SessionMetrics {
   if (!raw) return emptyMetrics();
   try {
     // Normalise at the load boundary: backfills partial blobs and restores
     // the Infinity minMs sentinel that JSON round-trips as null.
     return normaliseMetrics(JSON.parse(raw));
-  } catch {
+  } catch (err) {
+    // Degrade to empty — and say so, since the next upsert overwrites
+    // the corrupt blob and the chat's lifetime counters restart at zero.
+    logWarn(
+      "sessions",
+      `Corrupt session metrics chat=${chatId} bytes=${raw.length} — resetting: ${err instanceof Error ? err.message : String(err)}`,
+    );
     return emptyMetrics();
   }
 }
@@ -78,7 +85,7 @@ function rowToSession(row: Row): SessionState {
       // NULL = no timed turn yet — the domain sentinel is Infinity.
       fastestResponseMs: row.fastest_response_ms ?? Infinity,
     },
-    metrics: parseMetrics(row.metrics),
+    metrics: parseMetrics(row.metrics, row.chat_id),
     lastBotMessageId: row.last_bot_message_id ?? undefined,
     sessionName: row.session_name ?? undefined,
     lastModel: row.last_model ?? undefined,

package/src/storage/scripts.ts

@@ -17,8 +17,10 @@
  */
 
 import { randomUUID } from "node:crypto";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync } from "node:fs";
 import { dirname, resolve } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { logWarn } from "../util/log.js";
 import { dirs } from "../util/paths.js";
 import * as repo from "./repositories/scripts-repo.js";
 
@@ -93,8 +95,9 @@ function writeScriptFile(
 ): string {
   const path = scriptFilePath(name, lang);
   mkdirSync(dirname(path), { recursive: true });
-  // 0o700: only the user running Talon should be able to read/exec scripts
-  writeFileSync(path, body, { encoding: "utf-8", mode: 0o700 });
+  // 0o700: only the user running Talon should be able to read/exec scripts.
+  // Atomic: a failed replace (ENOSPC) must keep the previous body.
+  writeFileAtomic.sync(path, body, { encoding: "utf-8", mode: 0o700 });
   return path;
 }
 
@@ -117,11 +120,7 @@ export function saveScript(input: {
 }): Script {
   const existing = repo.getByName(input.name);
   if (existing && existing.language !== input.language) {
-    try {
-      rmSync(existing.scriptPath, { force: true });
-    } catch {
-      /* best effort */
-    }
+    removeScriptFile(existing.scriptPath, input.name);
   }
   const scriptPath = writeScriptFile(input.name, input.language, input.script);
   const now = Date.now();
@@ -153,15 +152,27 @@ export function recordScriptUse(name: string): void {
 }
 
 /** Delete a script and best-effort clean up its on-disk file. */
+/**
+ * Best-effort unlink. `force` already absorbs a missing file, so any
+ * throw here is a real fault (permissions, a directory in the way) that
+ * leaves an orphan script on disk.
+ */
+function removeScriptFile(path: string, name: string): void {
+  try {
+    rmSync(path, { force: true });
+  } catch (err) {
+    logWarn(
+      "scripts",
+      `Could not remove script file name=${name} path=${path}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 export function deleteScript(name: string): boolean {
   const script = repo.getByName(name);
   if (!script) return false;
   repo.removeByName(name);
-  try {
-    rmSync(script.scriptPath, { force: true });
-  } catch {
-    /* best effort */
-  }
+  removeScriptFile(script.scriptPath, name);
   return true;
 }
 

package/src/storage/sessions.ts

@@ -22,6 +22,7 @@ import { log, logError } from "../util/log.js";
 import { recordError } from "../util/watchdog.js";
 import { files } from "../util/paths.js";
 import { importLegacyJson } from "./legacy-import.js";
+import { dbErrorFields } from "./db.js";
 import * as repo from "./repositories/sessions-repo.js";
 
 export type {
@@ -204,7 +205,11 @@ function persist(chatId: string, session: SessionState): void {
   try {
     repo.upsert(chatId, session);
   } catch (err) {
-    logError("sessions", "Failed to persist sessions", err);
+    logError(
+      "sessions",
+      `Failed to persist sessions chat=${chatId}${dbErrorFields(err)}`,
+      err,
+    );
     recordError(
       `Session save failed: ${err instanceof Error ? err.message : err}`,
     );
@@ -518,7 +523,11 @@ function removeSessionRow(chatId: string): void {
   try {
     repo.remove(chatId);
   } catch (err) {
-    logError("sessions", "Failed to delete session row", err);
+    logError(
+      "sessions",
+      `Failed to delete session row chat=${chatId}${dbErrorFields(err)}`,
+      err,
+    );
     recordError(
       `Session delete failed: ${err instanceof Error ? err.message : err}`,
     );

package/src/storage/skills.ts

@@ -26,7 +26,9 @@ import {
   writeFileSync,
 } from "node:fs";
 import { basename, resolve } from "node:path";
+import writeFileAtomic from "write-file-atomic";
 import { parseDocument, stringify } from "yaml";
+import { logWarn } from "../util/log.js";
 import { dirs } from "../util/paths.js";
 
 export type Skill = {
@@ -123,6 +125,13 @@ function serializeSkill(input: {
   return ["---", yaml, "---", "", input.body.trimEnd(), ""].join("\n");
 }
 
+/**
+ * Frontmatter errors already reported, keyed by path + message: skills
+ * are re-read for every prompt, so a broken SKILL.md warns once, not
+ * once per turn.
+ */
+const reportedFrontmatterErrors = new Set<string>();
+
 function parseSkill(
   path: string,
   raw: string,
@@ -161,7 +170,15 @@ function parseSkill(
     if (value && typeof value === "object") {
       parsed = value as Record<string, unknown>;
     }
-  } catch {
+  } catch (err) {
+    // The skill still loads (name falls back to its directory, no
+    // description) — which is exactly why the reason must be visible.
+    const msg = err instanceof Error ? err.message : String(err);
+    const key = `${path}\0${msg}`;
+    if (!reportedFrontmatterErrors.has(key)) {
+      reportedFrontmatterErrors.add(key);
+      logWarn("skills", `Unparseable frontmatter in ${path}: ${msg}`);
+    }
     parsed = {};
   }
 
@@ -216,7 +233,9 @@ export function saveSkill(input: {
   mkdirSync(dir, { recursive: true });
   const path = skillFilePath(input.name);
   const content = serializeSkill(input);
-  writeFileSync(path, content, { encoding: "utf-8", mode: 0o600 });
+  // Atomic: a failed replace (ENOSPC) must keep the previous SKILL.md,
+  // not leave a truncated one.
+  writeFileAtomic.sync(path, content, { encoding: "utf-8", mode: 0o600 });
   return readSkill(input.name)!;
 }
 

package/src/storage/stickers.ts

@@ -14,6 +14,7 @@
 
 import { readFileSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
+import { logWarn } from "../util/log.js";
 import { dirs } from "../util/paths.js";
 
 // ── Types ───────────────────────────────────────────────────────────────────
@@ -50,7 +51,15 @@ export function listSavedPacks(): SavedPack[] {
   let entries: string[];
   try {
     entries = readdirSync(dir).filter((f) => f.endsWith(".json"));
-  } catch {
+  } catch (err) {
+    // No stickers dir yet is the normal empty library; anything else
+    // (EACCES, ENOTDIR) hides every saved pack.
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      logWarn(
+        "stickers",
+        `Could not list sticker packs dir=${dir}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
     return [];
   }
   const packs: SavedPack[] = [];
@@ -82,8 +91,13 @@ export function listSavedPacks(): SavedPack[] {
         stickers,
         savedAt: typeof raw.savedAt === "string" ? raw.savedAt : "",
       });
-    } catch {
-      /* skip malformed pack file */
+    } catch (err) {
+      // Skip the malformed pack file, but name it — it silently drops
+      // out of the library otherwise.
+      logWarn(
+        "stickers",
+        `Skipped unreadable sticker pack file=${file}: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
   }
   return packs.sort((a, b) => b.savedAt.localeCompare(a.savedAt));

package/src/storage/triggers.ts

@@ -19,7 +19,7 @@ import {
 } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { dirname, resolve } from "node:path";
-import { log, logError } from "../util/log.js";
+import { log, logError, logWarn } from "../util/log.js";
 import { dirs, files } from "../util/paths.js";
 import { importLegacyJson } from "./legacy-import.js";
 import { inTransaction } from "./db.js";
@@ -286,8 +286,13 @@ export function deleteTrigger(id: string): boolean {
   for (const path of [t.scriptPath, t.logPath]) {
     try {
       rmSync(path, { force: true });
-    } catch {
-      /* best effort */
+    } catch (err) {
+      // Best effort; `force` already absorbs a missing file, so this is
+      // a real fault that leaves an orphan on disk.
+      logWarn(
+        "triggers",
+        `Could not remove trigger file id=${id} path=${path}: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
   }
   return true;

package/src/storage/turn-meta.ts

@@ -14,11 +14,11 @@
  * actually fetch.
  */
 
-import { inTransaction } from "./db.js";
+import { dbErrorFields, inTransaction } from "./db.js";
 import * as repo from "./repositories/turn-meta-repo.js";
 import { importLegacyJson } from "./legacy-import.js";
 import { files } from "../util/paths.js";
-import { logError } from "../util/log.js";
+import { logError, logWarn } from "../util/log.js";
 
 /** Per-chat cap — matches the /history page ceiling. */
 const MAX_PER_CHAT = 500;
@@ -83,7 +83,11 @@ export function recordTurnMeta(
       repo.prune(chatId, MAX_PER_CHAT);
     });
   } catch (err) {
-    logError("db", "Failed to persist turn meta", err);
+    logError(
+      "db",
+      `Failed to persist turn meta chat=${chatId} msg=${msgId}${dbErrorFields(err)}`,
+      err,
+    );
   }
 }
 
@@ -96,14 +100,24 @@ export function getTurnMeta<T>(chatId: string, msgId: string): T | null {
   } catch (err) {
     // Reads are hydration-only — a storage fault must degrade to
     // "no meta", not break the caller (matching recordTurnMeta).
-    logError("db", "Failed to read turn meta", err);
+    logError(
+      "db",
+      `Failed to read turn meta chat=${chatId} msg=${msgId}${dbErrorFields(err)}`,
+      err,
+    );
     return null;
   }
   if (raw === undefined) return null;
   try {
     return JSON.parse(raw) as T;
-  } catch {
-    return null; // corrupt row — treat as absent rather than throw
+  } catch (err) {
+    // Corrupt row — treat as absent rather than throw, but say so: the
+    // caller sees "no meta" and can't tell it from a message never tagged.
+    logWarn(
+      "db",
+      `Corrupt turn meta chat=${chatId} msg=${msgId} bytes=${raw.length}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return null;
   }
 }
 
@@ -113,6 +127,10 @@ export function clearTurnMeta(chatId: string): void {
   try {
     repo.removeChat(chatId);
   } catch (err) {
-    logError("db", "Failed to clear turn meta", err);
+    logError(
+      "db",
+      `Failed to clear turn meta chat=${chatId}${dbErrorFields(err)}`,
+      err,
+    );
   }
 }