talon-agent 1.0.0 → 1.2.0

package/src/storage/media-index.ts

@@ -8,16 +8,24 @@
 
 import { existsSync, readFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
+import { registerCleanup } from "../util/cleanup-registry.js";
 import writeFileAtomic from "write-file-atomic";
 import { log } from "../util/log.js";
 import { files } from "../util/paths.js";
 
 export type MediaEntry = {
-  id: string;           // unique key: chatId:msgId
+  id: string; // unique key: chatId:msgId
   chatId: string;
   msgId: number;
   senderName: string;
-  type: "photo" | "document" | "voice" | "video" | "animation" | "audio" | "sticker";
+  type:
+    | "photo"
+    | "document"
+    | "voice"
+    | "video"
+    | "animation"
+    | "audio"
+    | "sticker";
   filePath: string;
   caption?: string;
   timestamp: number;
@@ -36,7 +44,9 @@ export function loadMediaIndex(): void {
     if (existsSync(STORE_FILE)) {
       entries = JSON.parse(readFileSync(STORE_FILE, "utf-8"));
     }
-  } catch { entries = []; }
+  } catch {
+    entries = [];
+  }
   // Purge expired on load
   purgeExpired();
 }
@@ -48,11 +58,13 @@ function save(): void {
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     writeFileAtomic.sync(STORE_FILE, JSON.stringify(entries) + "\n");
     dirty = false;
-  } catch { /* non-fatal */ }
+  } catch {
+    /* non-fatal */
+  }
 }
 
 const autoSaveTimer = setInterval(save, 30_000);
-process.on("exit", save);
+registerCleanup(save);
 
 export function flushMediaIndex(): void {
   clearInterval(autoSaveTimer);
@@ -80,7 +92,11 @@ export function getRecentMedia(chatId: string, limit = 10): MediaEntry[] {
 }
 
 /** Get all media matching a type in a chat. */
-export function getMediaByType(chatId: string, type: MediaEntry["type"], limit = 10): MediaEntry[] {
+export function getMediaByType(
+  chatId: string,
+  type: MediaEntry["type"],
+  limit = 10,
+): MediaEntry[] {
   return entries
     .filter((e) => e.chatId === chatId && e.type === type)
     .sort((a, b) => b.timestamp - a.timestamp)
@@ -91,11 +107,16 @@ export function getMediaByType(chatId: string, type: MediaEntry["type"], limit =
 export function formatMediaIndex(chatId: string, limit = 10): string {
   const media = getRecentMedia(chatId, limit);
   if (media.length === 0) return "No recent media in this chat.";
-  return media.map((m) => {
-    const time = new Date(m.timestamp).toISOString().slice(0, 16).replace("T", " ");
-    const cap = m.caption ? ` "${m.caption.slice(0, 50)}"` : "";
-    return `[${m.type}] msg:${m.msgId} by ${m.senderName} at ${time}${cap}\n  file: ${m.filePath}`;
-  }).join("\n");
+  return media
+    .map((m) => {
+      const time = new Date(m.timestamp)
+        .toISOString()
+        .slice(0, 16)
+        .replace("T", " ");
+      const cap = m.caption ? ` "${m.caption.slice(0, 50)}"` : "";
+      return `[${m.type}] msg:${m.msgId} by ${m.senderName} at ${time}${cap}\n  file: ${m.filePath}`;
+    })
+    .join("\n");
 }
 
 // ── Expiry ──────────────────────────────────────────────────────────────────
@@ -106,7 +127,11 @@ function purgeExpired(): void {
   entries = entries.filter((e) => {
     if (e.timestamp >= cutoff) return true;
     // Delete the file too
-    try { if (existsSync(e.filePath)) unlinkSync(e.filePath); } catch { /* skip */ }
+    try {
+      if (existsSync(e.filePath)) unlinkSync(e.filePath);
+    } catch {
+      /* skip */
+    }
     return false;
   });
   if (entries.length < before) {

package/src/storage/sessions.ts

@@ -3,6 +3,7 @@ import writeFileAtomic from "write-file-atomic";
 import { log, logError } from "../util/log.js";
 import { recordError } from "../util/watchdog.js";
 import { dirs, files } from "../util/paths.js";
+import { registerCleanup } from "../util/cleanup-registry.js";
 
 /**
  * Session manager — maps Telegram chat IDs to Claude SDK session IDs.
@@ -227,7 +228,7 @@ export function recordUsage(
     session.usage.totalResponseMs =
       (session.usage.totalResponseMs || 0) + turn.durationMs;
     session.usage.lastResponseMs = turn.durationMs;
-    const current = session.usage.fastestResponseMs || Infinity;
+    const current = session.usage.fastestResponseMs;
     if (turn.durationMs < current) {
       session.usage.fastestResponseMs = turn.durationMs;
     }
@@ -318,7 +319,7 @@ export function getAllSessions(): Array<{ chatId: string; info: SessionInfo }> {
 }
 
 // Flush on exit (signal handlers are in index.ts for graceful shutdown)
-process.on("exit", saveSessions);
+registerCleanup(saveSessions);
 
 /** Force-save sessions to disk and stop the auto-save timer. */
 export function flushSessions(): void {

package/src/util/cleanup-registry.ts

@@ -0,0 +1,34 @@
+/**
+ * Centralized process exit handler registry.
+ *
+ * Each storage module calls registerCleanup() instead of
+ * process.on("exit", fn) directly. This keeps exactly ONE
+ * "exit" listener on the process regardless of how many modules
+ * are loaded — avoiding MaxListenersExceededWarning.
+ */
+
+const handlers: Array<() => void> = [];
+let registered = false;
+
+/**
+ * Register a synchronous cleanup function to run on process exit.
+ * Safe to call multiple times across multiple modules — only one
+ * process "exit" listener is ever registered.
+ */
+export function registerCleanup(fn: () => void): void {
+  handlers.push(fn);
+  if (!registered) {
+    registered = true;
+    process.on("exit", runAll);
+  }
+}
+
+function runAll(): void {
+  for (const fn of handlers) {
+    try {
+      fn();
+    } catch {
+      // Suppress — we're in exit, can't do much about it
+    }
+  }
+}

package/src/util/config.ts

@@ -1,12 +1,17 @@
-import { existsSync, readFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+} from "node:fs";
 import { resolve } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { dirs, files as pathFiles } from "./paths.js";
-import { setTimezone, formatFullDatetime } from "./time.js";
+import { setTimezone, formatFullDatetime, todayAndYesterday } from "./time.js";
 import { log } from "./log.js";
 
-
 // ── Config schema ───────────────────────────────────────────────────────────
 
 const pluginEntrySchema = z.object({
@@ -28,8 +33,12 @@ const configSchema = z.object({
   apiId: z.number().int().optional(),
   apiHash: z.string().optional(),
   adminUserId: z.number().int().optional(),
+  allowedUsers: z.array(z.number().int()).optional(), // Whitelist of user IDs allowed to DM the bot
   pulse: z.boolean().default(true),
   pulseIntervalMs: z.number().int().min(60000).default(300000),
+  heartbeat: z.boolean().default(false),
+  heartbeatIntervalMinutes: z.number().int().min(5).default(60),
+  heartbeatModel: z.string().optional(), // Model for heartbeat agent (defaults to main model)
   braveApiKey: z.string().optional(),
   searxngUrl: z.string().default("http://localhost:8080"),
   timezone: z.string().optional(),
@@ -77,7 +86,9 @@ function loadConfigFile(): Record<string, unknown> {
     if (existsSync(CONFIG_FILE)) {
       return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
     }
-  } catch { /* corrupt — will be recreated */ }
+  } catch {
+    /* corrupt — will be recreated */
+  }
   return {};
 }
 
@@ -89,7 +100,10 @@ function ensureConfigFile(): boolean {
   if (!existsSync(dirs.root)) mkdirSync(dirs.root, { recursive: true });
   if (!existsSync(dirs.data)) mkdirSync(dirs.data, { recursive: true });
   if (!existsSync(CONFIG_FILE)) {
-    writeFileAtomic.sync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+    writeFileAtomic.sync(
+      CONFIG_FILE,
+      JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n",
+    );
     return true;
   }
   return false;
@@ -100,13 +114,18 @@ function ensureConfigFile(): boolean {
 function readOptionalFile(path: string): string {
   try {
     if (existsSync(path)) return readFileSync(path, "utf-8").trim();
-  } catch { /* ignore */ }
+  } catch {
+    /* ignore */
+  }
   return "";
 }
 
 let lastLoggedPromptKey = "";
 
-function loadSystemPrompt(frontend?: string, pluginPromptAdditions?: string[]): string {
+function loadSystemPrompt(
+  frontend?: string,
+  pluginPromptAdditions?: string[],
+): string {
   const promptDir = dirs.prompts;
   const parts: string[] = [];
 
@@ -124,14 +143,21 @@ function loadSystemPrompt(frontend?: string, pluginPromptAdditions?: string[]):
   // Load base prompt (shared across all frontends)
   const custom = readOptionalFile(resolve(promptDir, "custom.md"));
   const basePrompt = readOptionalFile(resolve(promptDir, "base.md"));
-  if (custom) { parts.push(custom); loaded.push("custom"); }
-  else if (basePrompt) { parts.push(basePrompt); loaded.push("base"); }
-  else parts.push("You are a sharp and helpful AI assistant.");
+  if (custom) {
+    parts.push(custom);
+    loaded.push("custom");
+  } else if (basePrompt) {
+    parts.push(basePrompt);
+    loaded.push("base");
+  } else parts.push("You are a sharp and helpful AI assistant.");
 
   // Load frontend-specific prompt
   const frontendFile = `${frontend ?? "telegram"}.md`;
   const frontendPrompt = readOptionalFile(resolve(promptDir, frontendFile));
-  if (frontendPrompt) { parts.push(frontendPrompt); loaded.push(frontendFile.replace(".md", "")); }
+  if (frontendPrompt) {
+    parts.push(frontendPrompt);
+    loaded.push(frontendFile.replace(".md", ""));
+  }
 
   const memory = readOptionalFile(pathFiles.memory);
   if (memory) {
@@ -141,6 +167,12 @@ function loadSystemPrompt(frontend?: string, pluginPromptAdditions?: string[]):
     loaded.push("memory");
   }
 
+  // Point the bot at daily memory files (read on demand, not injected)
+  const { today } = todayAndYesterday();
+  parts.push(
+    `## Daily Memory\n\nYour daily notes are stored in \`${dirs.dailyMemory}/\`. Today's file is \`${today}.md\`. Use the Read tool to check recent daily notes when you need context from previous days.`,
+  );
+
   const loadedKey = loaded.join(" + ");
   if (loadedKey && loadedKey !== lastLoggedPromptKey) {
     log("config", `System prompt: ${loadedKey}`);
@@ -155,28 +187,44 @@ function loadSystemPrompt(frontend?: string, pluginPromptAdditions?: string[]):
       const entries: string[] = [];
       try {
         for (const e of readdirSync(dir, { withFileTypes: true })) {
-          if (e.name.startsWith(".") || e.name === "node_modules" || e.name === "talon.log") continue;
+          if (
+            e.name.startsWith(".") ||
+            e.name === "node_modules" ||
+            e.name === "talon.log"
+          )
+            continue;
           const full = resolve(dir, e.name);
           if (e.isDirectory()) {
             const sub = listDir(full, `${prefix}${e.name}/`);
             if (sub.length > 0 && sub.length <= 8) entries.push(...sub);
-            else if (sub.length > 8) entries.push(`${prefix}${e.name}/ (${sub.length} files)`);
+            else if (sub.length > 8)
+              entries.push(`${prefix}${e.name}/ (${sub.length} files)`);
           } else {
             const sz = statSync(full).size;
-            entries.push(`${prefix}${e.name} (${sz < 1024 ? sz + "B" : (sz / 1024).toFixed(0) + "KB"})`);
+            entries.push(
+              `${prefix}${e.name} (${sz < 1024 ? sz + "B" : (sz / 1024).toFixed(0) + "KB"})`,
+            );
           }
         }
-      } catch { /* skip */ }
+      } catch {
+        /* skip */
+      }
       return entries;
     };
     const files = listDir(workspaceDir);
-    if (files.length > 0) workspaceFiles = "\n\nCurrent workspace contents:\n" + files.map((f) => `  ${f}`).join("\n");
-  } catch { /* no workspace yet */ }
+    if (files.length > 0)
+      workspaceFiles =
+        "\n\nCurrent workspace contents:\n" +
+        files.map((f) => `  ${f}`).join("\n");
+  } catch {
+    /* no workspace yet */
+  }
 
   parts.push(`## Workspace
 
 You have a workspace directory at \`~/.talon/workspace/\`. This is your home — organize it however you want.
 - \`~/.talon/workspace/memory/memory.md\` is your persistent memory file. Update it when you learn important things.
+- \`~/.talon/workspace/memory/daily/YYYY-MM-DD.md\` is your daily notes file. Write observations, learnings, corrections, and follow-ups here throughout the day. Keep entries concise.
 - Daily interaction logs are saved to \`~/.talon/workspace/logs/\` automatically.
 - Files users send you (photos, docs, voice) are saved to \`~/.talon/workspace/uploads/\`.
 - Persistent cron jobs are managed via the cron tools.
@@ -215,13 +263,19 @@ export function loadConfig(): TalonConfig {
   setTimezone(parsed.timezone);
 
   // Validate per-frontend requirements
-  const frontends = Array.isArray(parsed.frontend) ? parsed.frontend : [parsed.frontend];
+  const frontends = Array.isArray(parsed.frontend)
+    ? parsed.frontend
+    : [parsed.frontend];
   for (const fe of frontends) {
     if (fe === "telegram" && !parsed.botToken) {
-      throw new Error(`Telegram frontend requires "botToken" in ${CONFIG_FILE}. Run "talon setup" to configure.`);
+      throw new Error(
+        `Telegram frontend requires "botToken" in ${CONFIG_FILE}. Run "talon setup" to configure.`,
+      );
     }
     if (fe === "teams" && !parsed.teamsWebhookUrl) {
-      throw new Error(`Teams frontend requires "teamsWebhookUrl" in ${CONFIG_FILE}. Run "talon setup" to configure.`);
+      throw new Error(
+        `Teams frontend requires "teamsWebhookUrl" in ${CONFIG_FILE}. Run "talon setup" to configure.`,
+      );
     }
   }
 
@@ -238,7 +292,15 @@ export function loadConfig(): TalonConfig {
  * Rebuild the system prompt with plugin additions.
  * Called after plugins are loaded to inject their prompt contributions.
  */
-export function rebuildSystemPrompt(config: TalonConfig, pluginAdditions: string[]): void {
-  const frontends = Array.isArray(config.frontend) ? config.frontend : [config.frontend];
-  config.systemPrompt = loadSystemPrompt(frontends[0], pluginAdditions.length > 0 ? pluginAdditions : undefined);
+export function rebuildSystemPrompt(
+  config: TalonConfig,
+  pluginAdditions: string[],
+): void {
+  const frontends = Array.isArray(config.frontend)
+    ? config.frontend
+    : [config.frontend];
+  config.systemPrompt = loadSystemPrompt(
+    frontends[0],
+    pluginAdditions.length > 0 ? pluginAdditions : undefined,
+  );
 }

package/src/util/log.ts

@@ -8,7 +8,14 @@
  */
 
 import pino from "pino";
-import { existsSync, readFileSync, mkdirSync, statSync, renameSync, unlinkSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  statSync,
+  renameSync,
+  unlinkSync,
+} from "node:fs";
 import { dirs, files } from "./paths.js";
 
 export type LogComponent =
@@ -22,22 +29,29 @@ export type LogComponent =
   | "workspace"
   | "shutdown"
   | "file"
+  | "history"
   | "sessions"
   | "settings"
   | "commands"
   | "cron"
   | "dream"
+  | "heartbeat"
   | "dispatcher"
   | "gateway"
   | "plugin"
   | "teams"
-  | "config";
+  | "config"
+  | "access";
 
 const LOG_FILE = files.log;
 
 // Ensure .talon dir exists for log file
 if (!existsSync(dirs.root)) {
-  try { mkdirSync(dirs.root, { recursive: true }); } catch { /* ignore */ }
+  try {
+    mkdirSync(dirs.root, { recursive: true });
+  } catch {
+    /* ignore */
+  }
 }
 
 // Rotate log file on startup if it exceeds 10MB
@@ -45,10 +59,21 @@ const MAX_LOG_SIZE = 10 * 1024 * 1024;
 try {
   if (existsSync(LOG_FILE) && statSync(LOG_FILE).size > MAX_LOG_SIZE) {
     const rotated = `${LOG_FILE}.old`;
-    try { unlinkSync(rotated); } catch { /* ignore */ }
+    try {
+      unlinkSync(rotated);
+    } catch {
+      /* ignore */
+    }
     renameSync(LOG_FILE, rotated);
   }
-} catch { /* ignore */ }
+} catch {
+  /* ignore */
+}
+
+// Detect if running as a bun compiled binary (pino-pretty can't be bundled).
+// import.meta.path is Bun-specific — undefined in Node.js/Vitest, so guard with ?.
+const isBunBinary =
+  (import.meta as { path?: string }).path?.startsWith("/$bunfs/") ?? false;
 
 // Suppress console output for terminal frontend (stdout belongs to the REPL)
 let quiet = process.env.TALON_QUIET === "1";
@@ -59,23 +84,29 @@ if (!quiet) {
       const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       if (cfg.frontend === "terminal") quiet = true;
     }
-  } catch { /* ignore */ }
+  } catch {
+    /* ignore */
+  }
 }
 
 const logger = pino({
   level: "trace",
   transport: {
     targets: [
-      // Console output (disabled in quiet mode)
-      ...(!quiet ? [{
-        target: "pino-pretty",
-        level: "trace" as const,
-        options: {
-          colorize: true,
-          ignore: "pid,hostname",
-          translateTime: "HH:MM:ss",
-        },
-      }] : []),
+      // Console output (disabled in quiet mode or compiled binary)
+      ...(!quiet && !isBunBinary
+        ? [
+            {
+              target: "pino-pretty",
+              level: "trace" as const,
+              options: {
+                colorize: true,
+                ignore: "pid,hostname",
+                translateTime: "HH:MM:ss",
+              },
+            },
+          ]
+        : []),
       // JSON file output (always active)
       {
         target: "pino/file",
@@ -119,4 +150,3 @@ export function logDebug(component: LogComponent, message: string): void {
 (globalThis as Record<string, unknown>).__talonLog = log;
 (globalThis as Record<string, unknown>).__talonLogError = logError;
 (globalThis as Record<string, unknown>).__talonLogWarn = logWarn;
-

package/src/util/paths.ts

@@ -14,6 +14,7 @@
  *       media-index.json
  *     workspace/               User-facing workspace (memory, uploads, logs)
  *       memory/
+ *         daily/               Per-day memory notes (YYYY-MM-DD.md)
  *       uploads/
  *       stickers/
  *       logs/
@@ -42,6 +43,8 @@ export const dirs = {
   logs: resolve(TALON_ROOT, "workspace", "logs"),
   /** Memory: ~/.talon/workspace/memory/ */
   memory: resolve(TALON_ROOT, "workspace", "memory"),
+  /** Daily memory notes: ~/.talon/workspace/memory/daily/ */
+  dailyMemory: resolve(TALON_ROOT, "workspace", "memory", "daily"),
   /** Sticker packs: ~/.talon/workspace/stickers/ */
   stickers: resolve(TALON_ROOT, "workspace", "stickers"),
   /** Prompt files: ~/.talon/prompts/ */
@@ -77,4 +80,11 @@ export const files = {
   pid: resolve(TALON_ROOT, "talon.pid"),
   /** Dream mode state: ~/.talon/workspace/memory/dream_state.json */
   dreamState: resolve(TALON_ROOT, "workspace", "memory", "dream_state.json"),
+  /** Heartbeat state: ~/.talon/workspace/memory/heartbeat_state.json */
+  heartbeatState: resolve(
+    TALON_ROOT,
+    "workspace",
+    "memory",
+    "heartbeat_state.json",
+  ),
 } as const;

package/src/util/time.ts

@@ -29,12 +29,12 @@ function toHHMM(date: Date): string {
 }
 
 /** Format a Date in the configured timezone as YYYY-MM-DD. */
-function toYMD(date: Date): string {
+export function toYMD(date: Date): string {
   return date.toLocaleDateString("en-CA", { timeZone: getTimezone() }); // en-CA gives YYYY-MM-DD
 }
 
 /** Get "today" and "yesterday" date strings in the configured timezone. */
-function todayAndYesterday(): { today: string; yesterday: string } {
+export function todayAndYesterday(): { today: string; yesterday: string } {
   const now = new Date();
   const today = toYMD(now);
   const yd = new Date(now.getTime() - 86_400_000);
@@ -60,18 +60,38 @@ export function formatSmartTimestamp(ts: number): string {
   if (dateStr === yesterday) return `Yesterday ${time}`;
 
   const now = new Date();
-  const thisYear = now.toLocaleDateString("en-CA", { timeZone: getTimezone() }).slice(0, 4);
+  const thisYear = now
+    .toLocaleDateString("en-CA", { timeZone: getTimezone() })
+    .slice(0, 4);
   const msgYear = dateStr.slice(0, 4);
 
   if (msgYear === thisYear) {
-    const month = date.toLocaleString("en-US", { month: "short", timeZone: getTimezone() });
-    const day = date.toLocaleString("en-US", { day: "numeric", timeZone: getTimezone() });
+    const month = date.toLocaleString("en-US", {
+      month: "short",
+      timeZone: getTimezone(),
+    });
+    const day = date.toLocaleString("en-US", {
+      day: "numeric",
+      timeZone: getTimezone(),
+    });
     return `${month} ${day} ${time}`;
   }
 
   return `${dateStr} ${time}`;
 }
 
+/**
+ * Human-readable relative age: "just now", "5m ago", "3h ago", "2d ago".
+ * Used for user-facing displays where a precise timestamp isn't needed.
+ */
+export function formatRelativeAge(ts: number): string {
+  const diff = Date.now() - ts;
+  if (diff < 60_000) return "just now";
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
+  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
+  return `${Math.floor(diff / 86_400_000)}d ago`;
+}
+
 /**
  * Full datetime for system prompt injection.
  * Example: "2026-03-21 14:32 (Europe/Warsaw, Fri)"
@@ -81,6 +101,9 @@ export function formatFullDatetime(): string {
   const tz = getTimezone();
   const dateStr = toYMD(now);
   const time = toHHMM(now);
-  const weekday = now.toLocaleString("en-US", { weekday: "short", timeZone: tz });
+  const weekday = now.toLocaleString("en-US", {
+    weekday: "short",
+    timeZone: tz,
+  });
   return `${dateStr} ${time} ${weekday} (${tz})`;
 }

package/src/util/watchdog.ts

@@ -69,7 +69,11 @@ export function startWatchdog(workspaceDir?: string): void {
     // Ensure workspace still exists (might have been deleted externally)
     if (workspaceDir && !existsSync(workspaceDir)) {
       logWarn("watchdog", "Workspace directory missing — recreating");
-      try { mkdirSync(workspaceDir, { recursive: true }); } catch { /* ignore */ }
+      try {
+        mkdirSync(workspaceDir, { recursive: true });
+      } catch {
+        /* ignore */
+      }
     }
   }, 60_000); // Check every minute
 }