talon-agent 1.0.0 → 1.2.0

package/src/core/cron.ts

@@ -65,10 +65,16 @@ async function runCronTick(): Promise<void> {
     if (getActiveCount() > 10) break;
 
     try {
-      log("cron", `Executing "${job.name}" [${job.id}] (${job.type}) in chat ${job.chatId}`);
+      log(
+        "cron",
+        `Executing "${job.name}" [${job.id}] (${job.type}) in chat ${job.chatId}`,
+      );
       await executeJob(job);
       recordCronRun(job.id);
-      appendDailyLog("Cron", `Ran "${job.name}" (${job.type}) in chat ${job.chatId}`);
+      appendDailyLog(
+        "Cron",
+        `Ran "${job.name}" (${job.type}) in chat ${job.chatId}`,
+      );
       log("cron", `Executed "${job.name}" [${job.id}] in chat ${job.chatId}`);
     } catch (err) {
       logError("cron", `Job "${job.name}" [${job.id}] failed`, err);
@@ -79,7 +85,9 @@ async function runCronTick(): Promise<void> {
 function isDue(job: CronJob, now: Date): boolean {
   try {
     const oneMinuteAgo = new Date(now.getTime() - 60_000);
-    const cron = new Cron(job.schedule, { timezone: job.timezone ?? undefined });
+    const cron = new Cron(job.schedule, {
+      timezone: job.timezone ?? undefined,
+    });
     const next = cron.nextRun(oneMinuteAgo);
     if (!next) return false;
 
@@ -102,10 +110,17 @@ function isDue(job: CronJob, now: Date): boolean {
 
 const CRON_JOB_TIMEOUT_MS = 10 * 60_000; // 10-minute max per job
 
-async function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  label: string,
+): Promise<T> {
   let timer: ReturnType<typeof setTimeout>;
   const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    timer = setTimeout(
+      () => reject(new Error(`${label} timed out after ${ms}ms`)),
+      ms,
+    );
   });
   try {
     return await Promise.race([promise, timeout]);

package/src/core/dispatcher.ts

@@ -16,7 +16,7 @@ import type {
   ExecuteParams,
   ExecuteResult,
 } from "./types.js";
-import { log, logDebug } from "../util/log.js";
+import { log, logDebug, logWarn } from "../util/log.js";
 import { maybeStartDream } from "./dream.js";
 
 // ── Dependencies (injected at startup) ──────────────────────────────────────
@@ -67,9 +67,11 @@ export async function execute(params: ExecuteParams): Promise<ExecuteResult> {
   chatChains.set(chatId, queued); // must happen before any await
 
   // Clean up chain entry when this is the last in the chain
-  queued.catch(() => {}).finally(() => {
-    if (chatChains.get(chatId) === queued) chatChains.delete(chatId);
-  });
+  queued
+    .catch(() => {})
+    .finally(() => {
+      if (chatChains.get(chatId) === queued) chatChains.delete(chatId);
+    });
 
   return queued;
 }
@@ -90,14 +92,27 @@ async function executeInner(params: ExecuteParams): Promise<ExecuteResult> {
   // Dream check — fire-and-forget background memory consolidation if due
   maybeStartDream();
 
-  logDebug("dispatcher", `[${reqId}] ${params.source} chat=${params.chatId} started (active=${activeCount})`);
+  logDebug(
+    "dispatcher",
+    `[${reqId}] ${params.source} chat=${params.chatId} started (active=${activeCount})`,
+  );
   context.acquire(params.numericChatId, params.chatId);
 
   let typingTimer: ReturnType<typeof setInterval> | undefined;
   try {
-    await sendTyping(params.numericChatId).catch(() => {});
+    await sendTyping(params.numericChatId).catch((err: unknown) => {
+      logWarn(
+        "dispatcher",
+        `sendTyping failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    });
     typingTimer = setInterval(() => {
-      sendTyping(params.numericChatId).catch(() => {});
+      sendTyping(params.numericChatId).catch((err: unknown) => {
+        logWarn(
+          "dispatcher",
+          `sendTyping interval failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      });
     }, 4000);
 
     const result = await backend.query({
@@ -113,14 +128,17 @@ async function executeInner(params: ExecuteParams): Promise<ExecuteResult> {
 
     onActivity();
 
-    logDebug("dispatcher", `[${reqId}] completed in ${result.durationMs}ms (in=${result.inputTokens} out=${result.outputTokens})`);
+    logDebug(
+      "dispatcher",
+      `[${reqId}] completed in ${result.durationMs}ms (in=${result.inputTokens} out=${result.outputTokens})`,
+    );
 
     return {
       ...result,
       bridgeMessageCount: context.getMessageCount(params.numericChatId),
     };
   } finally {
-    if (typingTimer) clearInterval(typingTimer);
+    clearInterval(typingTimer);
     context.release(params.numericChatId);
   }
 }

package/src/core/dream.ts

@@ -25,6 +25,8 @@ import { log, logError, logWarn } from "../util/log.js";
 export type DreamState = {
   /** Unix millisecond timestamp of the last completed dream run. */
   last_run: number;
+  /** Human-readable ISO timestamp of the last completed dream run. */
+  last_run_at?: string;
   /** "idle" when no dream is running, "running" while one is active. */
   status: "idle" | "running";
 };
@@ -39,7 +41,12 @@ const DREAM_LOGS_DIR = resolve(dirs.logs, "dreams");
 // ── State ────────────────────────────────────────────────────────────────────
 
 let dreaming = false; // in-process guard (one dream at a time)
-let configRef: { model?: string; dreamModel?: string; claudeBinary?: string; workspace?: string } | null = null;
+let configRef: {
+  model?: string;
+  dreamModel?: string;
+  claudeBinary?: string;
+  workspace?: string;
+} | null = null;
 
 export function initDream(cfg: {
   model?: string;
@@ -86,12 +93,18 @@ async function executeDream(trigger: "auto" | "forced"): Promise<void> {
 
   dreaming = true;
   writeDreamState({ last_run: now, status: "running" });
-  log("dream", `${trigger === "forced" ? "Force-triggering" : "Triggering"} memory consolidation (last run: ${state?.last_run ? new Date(state.last_run).toISOString() : "never"})`);
+  log(
+    "dream",
+    `${trigger === "forced" ? "Force-triggering" : "Triggering"} memory consolidation (last run: ${state?.last_run ? new Date(state.last_run).toISOString() : "never"})`,
+  );
 
   try {
     const dreamLogPath = await runDreamAgent(state?.last_run ?? 0);
     writeDreamState({ last_run: Date.now(), status: "idle" });
-    log("dream", `Memory consolidation complete (${trigger}), log: ${dreamLogPath}`);
+    log(
+      "dream",
+      `Memory consolidation complete (${trigger}), log: ${dreamLogPath}`,
+    );
   } catch (err) {
     logError("dream", `Memory consolidation failed (${trigger})`, err);
     writeDreamState({ last_run: Date.now(), status: "idle" });
@@ -109,9 +122,10 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
     return "";
   }
 
-  const lastRunIso = lastRunTimestamp > 0
-    ? new Date(lastRunTimestamp).toISOString()
-    : "the beginning of time";
+  const lastRunIso =
+    lastRunTimestamp > 0
+      ? new Date(lastRunTimestamp).toISOString()
+      : "the beginning of time";
 
   const logsDir = dirs.logs;
   const memoryFile = pathFiles.memory;
@@ -127,7 +141,8 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
       .replace(/\{\{dreamStateFile\}\}/g, dreamStateFile)
       .replace(/\{\{logsDir\}\}/g, logsDir)
       .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
-      .replace(/\{\{memoryFile\}\}/g, memoryFile);
+      .replace(/\{\{memoryFile\}\}/g, memoryFile)
+      .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory);
   } catch {
     throw new Error(`Failed to read dream prompt from ${promptPath}`);
   }
@@ -138,12 +153,19 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
   // Set up dream log file
   const dreamLogFile = createDreamLogFile();
   appendDreamLog(dreamLogFile, `# Dream Run — ${new Date().toISOString()}\n`);
-  appendDreamLog(dreamLogFile, `**Trigger:** last_run=${lastRunIso}, model=${model}\n`);
-  appendDreamLog(dreamLogFile, `**Prompt:**\n\`\`\`\n${prompt}\n\`\`\`\n\n---\n`);
+  appendDreamLog(
+    dreamLogFile,
+    `**Trigger:** last_run=${lastRunIso}, model=${model}\n`,
+  );
+  appendDreamLog(
+    dreamLogFile,
+    `**Prompt:**\n\`\`\`\n${prompt}\n\`\`\`\n\n---\n`,
+  );
 
   const options = {
     model,
-    systemPrompt: "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
+    systemPrompt:
+      "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
     cwd: workspace,
     permissionMode: "bypassPermissions" as const,
     allowDangerouslySkipPermissions: true,
@@ -171,7 +193,10 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
   };
 
   const timeoutPromise = new Promise<never>((_, reject) =>
-    setTimeout(() => reject(new Error("Dream agent timed out")), DREAM_TIMEOUT_MS),
+    setTimeout(
+      () => reject(new Error("Dream agent timed out")),
+      DREAM_TIMEOUT_MS,
+    ),
   );
 
   const agentPromise = (async () => {
@@ -182,13 +207,19 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
     for await (const msg of qi) {
       logDreamMessage(dreamLogFile, msg);
     }
-    appendDreamLog(dreamLogFile, `\n---\n**Dream completed at ${new Date().toISOString()}**\n`);
+    appendDreamLog(
+      dreamLogFile,
+      `\n---\n**Dream completed at ${new Date().toISOString()}**\n`,
+    );
   })();
 
   try {
     await Promise.race([agentPromise, timeoutPromise]);
   } catch (err) {
-    appendDreamLog(dreamLogFile, `\n---\n**Dream FAILED at ${new Date().toISOString()}:** ${err}\n`);
+    appendDreamLog(
+      dreamLogFile,
+      `\n---\n**Dream FAILED at ${new Date().toISOString()}:** ${err}\n`,
+    );
     throw err;
   }
 
@@ -223,7 +254,7 @@ function logDreamMessage(logFile: string, msg: SDKMessage): void {
         // Extract text content from the assistant message
         const textBlocks = msg.message.content
           .filter((b) => b.type === "text")
-          .map((b) => "text" in b ? (b as { text: string }).text : "");
+          .map((b) => ("text" in b ? (b as { text: string }).text : ""));
         const toolUseBlocks = msg.message.content
           .filter((b) => b.type === "tool_use")
           .map((b) => {
@@ -232,7 +263,10 @@ function logDreamMessage(logFile: string, msg: SDKMessage): void {
           });
 
         if (textBlocks.length > 0) {
-          appendDreamLog(logFile, `\n## [${ts}] Assistant\n${textBlocks.join("\n")}\n`);
+          appendDreamLog(
+            logFile,
+            `\n## [${ts}] Assistant\n${textBlocks.join("\n")}\n`,
+          );
         }
         if (toolUseBlocks.length > 0) {
           appendDreamLog(logFile, `\n${toolUseBlocks.join("\n\n")}\n`);
@@ -241,9 +275,18 @@ function logDreamMessage(logFile: string, msg: SDKMessage): void {
       }
       case "result": {
         // Final result of the dream agent run
-        const result = "result" in msg ? (msg as { result: string }).result : JSON.stringify(msg);
-        const truncated = result.length > 2000 ? result.slice(0, 2000) + "\n... (truncated)" : result;
-        appendDreamLog(logFile, `\n### [${ts}] Result (${msg.subtype})\n\`\`\`\n${truncated}\n\`\`\`\n`);
+        const result =
+          "result" in msg
+            ? (msg as { result: string }).result
+            : JSON.stringify(msg);
+        const truncated =
+          result.length > 2000
+            ? result.slice(0, 2000) + "\n... (truncated)"
+            : result;
+        appendDreamLog(
+          logFile,
+          `\n### [${ts}] Result (${msg.subtype})\n\`\`\`\n${truncated}\n\`\`\`\n`,
+        );
         break;
       }
       case "system": {
@@ -253,11 +296,16 @@ function logDreamMessage(logFile: string, msg: SDKMessage): void {
       case "user": {
         // Tool results come back as user messages
         if (msg.tool_use_result != null) {
-          const raw = typeof msg.tool_use_result === "string"
-            ? msg.tool_use_result
-            : JSON.stringify(msg.tool_use_result, null, 2);
-          const truncated = raw.length > 2000 ? raw.slice(0, 2000) + "\n... (truncated)" : raw;
-          appendDreamLog(logFile, `\n### [${ts}] Tool Result\n\`\`\`\n${truncated}\n\`\`\`\n`);
+          const raw =
+            typeof msg.tool_use_result === "string"
+              ? msg.tool_use_result
+              : JSON.stringify(msg.tool_use_result, null, 2);
+          const truncated =
+            raw.length > 2000 ? raw.slice(0, 2000) + "\n... (truncated)" : raw;
+          appendDreamLog(
+            logFile,
+            `\n### [${ts}] Tool Result\n\`\`\`\n${truncated}\n\`\`\`\n`,
+          );
         }
         break;
       }
@@ -288,7 +336,14 @@ function writeDreamState(state: DreamState): void {
   try {
     const dir = resolve(DREAM_STATE_FILE, "..");
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileAtomic.sync(DREAM_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+    const enriched: DreamState = {
+      ...state,
+      last_run_at: new Date(state.last_run).toISOString(),
+    };
+    writeFileAtomic.sync(
+      DREAM_STATE_FILE,
+      JSON.stringify(enriched, null, 2) + "\n",
+    );
   } catch (err) {
     logError("dream", "Failed to write dream state", err);
   }

package/src/core/errors.ts

@@ -59,7 +59,13 @@ export function classify(err: unknown): TalonError {
   let msg: string;
   if (err instanceof Error) msg = err.message;
   else if (typeof err === "string") msg = err;
-  else { try { msg = String(err); } catch { msg = "[non-stringifiable error]"; } }
+  else {
+    try {
+      msg = String(err);
+    } catch {
+      msg = "[non-stringifiable error]";
+    }
+  }
   const cause = err instanceof Error ? err : undefined;
 
   // Extract HTTP status if present
@@ -93,7 +99,11 @@ export function classify(err: unknown): TalonError {
   }
 
   // Network errors
-  if (/network|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(msg)) {
+  if (
+    /network|ECONNREFUSED|ECONNRESET|ECONNABORTED|ETIMEDOUT|ENOTFOUND|fetch failed|connection reset/i.test(
+      msg,
+    )
+  ) {
     return new TalonError(msg, {
       reason: "network",
       retryable: true,