talon-agent 1.0.0

package/src/core/cron.ts

@@ -0,0 +1,148 @@
+/**
+ * Cron scheduler — runs persistent recurring jobs.
+ *
+ * Every 60 seconds, checks all enabled cron jobs. If one is due, executes it.
+ * "message" type sends text via injected sendMessage.
+ * "query" type goes through the dispatcher with full tool access.
+ *
+ * Knows nothing about the backend or frontend — dependencies are injected.
+ */
+
+import { Cron } from "croner";
+import { execute, getActiveCount } from "./dispatcher.js";
+import {
+  getAllCronJobs,
+  recordCronRun,
+  type CronJob,
+} from "../storage/cron-store.js";
+import { appendDailyLog } from "../storage/daily-log.js";
+import { log, logError } from "../util/log.js";
+
+// ── Dependencies (injected at startup) ──────────────────────────────────────
+
+type CronDeps = {
+  sendMessage: (chatId: number, text: string) => Promise<void>;
+};
+
+let deps: CronDeps | null = null;
+let timer: ReturnType<typeof setInterval> | null = null;
+
+const TICK_INTERVAL_MS = 60_000;
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+export function initCron(d: CronDeps): void {
+  deps = d;
+}
+
+export function startCronTimer(): void {
+  if (timer) return;
+  log("cron", "Started: checking every 60s");
+  timer = setInterval(() => {
+    runCronTick().catch((err) => logError("cron", "Tick failed", err));
+  }, TICK_INTERVAL_MS);
+}
+
+export function stopCronTimer(): void {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+
+// ── Core ─────────────────────────────────────────────────────────────────────
+
+async function runCronTick(): Promise<void> {
+  if (!deps) return;
+  if (getActiveCount() > 10) return; // safety valve — don't pile on if heavily loaded
+
+  const now = new Date();
+  const jobs = getAllCronJobs();
+
+  for (const job of jobs) {
+    if (!job.enabled) continue;
+    if (!isDue(job, now)) continue;
+    if (getActiveCount() > 10) break;
+
+    try {
+      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}`);
+      log("cron", `Executed "${job.name}" [${job.id}] in chat ${job.chatId}`);
+    } catch (err) {
+      logError("cron", `Job "${job.name}" [${job.id}] failed`, err);
+    }
+  }
+}
+
+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 next = cron.nextRun(oneMinuteAgo);
+    if (!next) return false;
+
+    const nowMinute = Math.floor(now.getTime() / 60_000);
+    const nextMinute = Math.floor(next.getTime() / 60_000);
+    if (nowMinute !== nextMinute) return false;
+
+    // Prevent duplicate runs — ensure at least 55 seconds since last execution
+    if (job.lastRunAt && now.getTime() - job.lastRunAt < 55_000) return false;
+
+    // Guard against backward clock jumps (NTP sync, etc.) — if last run is in the
+    // future, skip until the clock catches up
+    if (job.lastRunAt && job.lastRunAt > now.getTime()) return false;
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+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> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer!);
+  }
+}
+
+async function executeJob(job: CronJob): Promise<void> {
+  if (!deps) return;
+
+  const numericChatId = Number(job.chatId);
+  if (!Number.isFinite(numericChatId)) {
+    logError("cron", `Invalid chatId for job "${job.name}": ${job.chatId}`);
+    return;
+  }
+
+  if (job.type === "message") {
+    await deps.sendMessage(numericChatId, job.content);
+    return;
+  }
+
+  // type === "query" — run through dispatcher with full tool access, timeout-protected
+  const prompt =
+    `[System: CRON JOB "${job.name}" (schedule: ${job.schedule}). ` +
+    `Execute the task. Be concise and action-oriented.]\n\n${job.content}`;
+
+  await withTimeout(
+    execute({
+      chatId: job.chatId,
+      numericChatId,
+      prompt,
+      senderName: "Cron",
+      isGroup: false,
+      source: "cron",
+    }),
+    CRON_JOB_TIMEOUT_MS,
+    `Cron job "${job.name}"`,
+  );
+}

package/src/core/dispatcher.ts

@@ -0,0 +1,126 @@
+/**
+ * Dispatcher — execution path for all AI queries.
+ *
+ * Manages the lifecycle: acquire context → typing → query → release.
+ * True concurrency — every query runs immediately in parallel.
+ * No queue, no artificial limits. The Claude API handles its own rate limiting.
+ *
+ * Dependencies are injected at startup — this module imports nothing from
+ * frontend/ or backend/.
+ */
+
+import { randomBytes } from "node:crypto";
+import type {
+  QueryBackend,
+  ContextManager,
+  ExecuteParams,
+  ExecuteResult,
+} from "./types.js";
+import { log, logDebug } from "../util/log.js";
+import { maybeStartDream } from "./dream.js";
+
+// ── Dependencies (injected at startup) ──────────────────────────────────────
+
+type DispatcherDeps = {
+  backend: QueryBackend;
+  context: ContextManager;
+  sendTyping: (chatId: number) => Promise<void>;
+  onActivity: () => void;
+};
+
+let deps: DispatcherDeps | null = null;
+let activeCount = 0;
+
+// Per-chat promise chains — serializes within a chat, parallel across chats.
+// Prevents two queries from resuming the same Claude session simultaneously.
+const chatChains = new Map<string, Promise<unknown>>();
+
+export function initDispatcher(d: DispatcherDeps): void {
+  deps = d;
+  log("dispatcher", "Initialized (per-chat serial, cross-chat parallel)");
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/** Number of queries currently running. */
+export function getActiveCount(): number {
+  return activeCount;
+}
+
+/**
+ * Execute an AI query with full lifecycle management.
+ * Same-chat queries are serialized (FIFO) to avoid session conflicts.
+ * Different-chat queries run in true parallel.
+ */
+export async function execute(params: ExecuteParams): Promise<ExecuteResult> {
+  if (!deps) throw new Error("Dispatcher not initialized");
+
+  const { chatId } = params;
+
+  // Chain this query behind any pending query for the same chat.
+  // Atomic get-or-insert: read and replace in one step to prevent
+  // two concurrent calls both seeing the same `prev`.
+  const prev = chatChains.get(chatId) ?? Promise.resolve();
+  // Use .catch(() => {}) on prev to prevent unhandled rejections —
+  // previous query's error is already handled by its own caller.
+  const queued = prev.catch(() => {}).then(() => run(params));
+  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);
+  });
+
+  return queued;
+}
+
+async function run(params: ExecuteParams): Promise<ExecuteResult> {
+  activeCount++;
+  try {
+    return await executeInner(params);
+  } finally {
+    activeCount--;
+  }
+}
+
+async function executeInner(params: ExecuteParams): Promise<ExecuteResult> {
+  const { backend, context, sendTyping, onActivity } = deps!;
+  const reqId = randomBytes(4).toString("hex");
+
+  // Dream check — fire-and-forget background memory consolidation if due
+  maybeStartDream();
+
+  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(() => {});
+    typingTimer = setInterval(() => {
+      sendTyping(params.numericChatId).catch(() => {});
+    }, 4000);
+
+    const result = await backend.query({
+      chatId: params.chatId,
+      text: params.prompt,
+      senderName: params.senderName,
+      isGroup: params.isGroup,
+      messageId: params.messageId,
+      onStreamDelta: params.onStreamDelta,
+      onTextBlock: params.onTextBlock,
+      onToolUse: params.onToolUse,
+    });
+
+    onActivity();
+
+    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);
+    context.release(params.numericChatId);
+  }
+}

package/src/core/dream.ts

@@ -0,0 +1,295 @@
+/**
+ * Dream mode — background memory consolidation.
+ *
+ * On each invocation, checks whether it's time to consolidate memories.
+ * If 12 hours have elapsed since the last dream, it:
+ *   1. Immediately writes a "running" lock to dream_state.json
+ *   2. Spawns a background Agent that reads recent logs and merges new
+ *      facts/preferences/events into memory.md
+ *
+ * The dream agent runs entirely on filesystem tools — no Telegram/MCP access.
+ * It does NOT use the main dispatcher (no chat session, no typing indicator).
+ */
+
+import { existsSync, readFileSync, mkdirSync, appendFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import writeFileAtomic from "write-file-atomic";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import { files as pathFiles, dirs } from "../util/paths.js";
+import { log, logError, logWarn } from "../util/log.js";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type DreamState = {
+  /** Unix millisecond timestamp of the last completed dream run. */
+  last_run: number;
+  /** "idle" when no dream is running, "running" while one is active. */
+  status: "idle" | "running";
+};
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const DREAM_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
+const DREAM_STATE_FILE = pathFiles.dreamState;
+const DREAM_TIMEOUT_MS = 10 * 60 * 1000; // 10-minute max
+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;
+
+export function initDream(cfg: {
+  model?: string;
+  /** Override model used specifically for dream consolidation (e.g. haiku for cost savings). Falls back to main model. */
+  dreamModel?: string;
+  claudeBinary?: string;
+  workspace?: string;
+}): void {
+  configRef = cfg;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Called at the start of every invocation.
+ * Returns immediately — any dream work is fire-and-forget in the background.
+ */
+export function maybeStartDream(): void {
+  if (dreaming) return;
+
+  const state = readDreamState();
+  const now = Date.now();
+  const elapsed = now - (state?.last_run ?? 0);
+  if (elapsed < DREAM_INTERVAL_MS) return;
+
+  // Fire and forget
+  executeDream("auto").catch(() => {});
+}
+
+/**
+ * Force a dream run immediately, regardless of the 12-hour interval.
+ * Returns a promise that resolves when the dream completes (or rejects on failure).
+ * Throws if a dream is already running.
+ */
+export async function forceDream(): Promise<void> {
+  if (dreaming) throw new Error("Dream already running");
+  await executeDream("forced");
+}
+
+/** Shared dream execution — claims lock, runs agent, releases lock. */
+async function executeDream(trigger: "auto" | "forced"): Promise<void> {
+  const state = readDreamState();
+  const now = Date.now();
+
+  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"})`);
+
+  try {
+    const dreamLogPath = await runDreamAgent(state?.last_run ?? 0);
+    writeDreamState({ last_run: Date.now(), status: "idle" });
+    log("dream", `Memory consolidation complete (${trigger}), log: ${dreamLogPath}`);
+  } catch (err) {
+    logError("dream", `Memory consolidation failed (${trigger})`, err);
+    writeDreamState({ last_run: Date.now(), status: "idle" });
+    if (trigger === "forced") throw err;
+  } finally {
+    dreaming = false;
+  }
+}
+
+// ── Dream agent ──────────────────────────────────────────────────────────────
+
+async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
+  if (!configRef) {
+    logWarn("dream", "Dream agent not initialized — skipping");
+    return "";
+  }
+
+  const lastRunIso = lastRunTimestamp > 0
+    ? new Date(lastRunTimestamp).toISOString()
+    : "the beginning of time";
+
+  const logsDir = dirs.logs;
+  const memoryFile = pathFiles.memory;
+  const dreamStateFile = DREAM_STATE_FILE;
+
+  // Load prompt template from prompts/dream.md and interpolate variables
+  const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+  const promptPath = resolve(projectRoot, "prompts/dream.md");
+
+  let prompt: string;
+  try {
+    prompt = readFileSync(promptPath, "utf-8")
+      .replace(/\{\{dreamStateFile\}\}/g, dreamStateFile)
+      .replace(/\{\{logsDir\}\}/g, logsDir)
+      .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
+      .replace(/\{\{memoryFile\}\}/g, memoryFile);
+  } catch {
+    throw new Error(`Failed to read dream prompt from ${promptPath}`);
+  }
+
+  const model = configRef.dreamModel ?? configRef.model ?? "claude-sonnet-4-6";
+  const workspace = configRef.workspace ?? dirs.workspace;
+
+  // 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`);
+
+  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.",
+    cwd: workspace,
+    permissionMode: "bypassPermissions" as const,
+    allowDangerouslySkipPermissions: true,
+    ...(configRef.claudeBinary
+      ? { pathToClaudeCodeExecutable: configRef.claudeBinary }
+      : {}),
+    // No MCP servers — filesystem tools only
+    mcpServers: {},
+    disallowedTools: [
+      "EnterPlanMode",
+      "ExitPlanMode",
+      "EnterWorktree",
+      "ExitWorktree",
+      "TodoWrite",
+      "TodoRead",
+      "TaskCreate",
+      "TaskUpdate",
+      "TaskGet",
+      "TaskList",
+      "TaskOutput",
+      "TaskStop",
+      "AskUserQuestion",
+      "Agent",
+    ],
+  };
+
+  const timeoutPromise = new Promise<never>((_, reject) =>
+    setTimeout(() => reject(new Error("Dream agent timed out")), DREAM_TIMEOUT_MS),
+  );
+
+  const agentPromise = (async () => {
+    const qi = query({
+      prompt,
+      options: options as Parameters<typeof query>[0]["options"],
+    });
+    for await (const msg of qi) {
+      logDreamMessage(dreamLogFile, msg);
+    }
+    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`);
+    throw err;
+  }
+
+  return dreamLogFile;
+}
+
+// ── Dream logging helpers ─────────────────────────────────────────────────
+
+function createDreamLogFile(): string {
+  if (!existsSync(DREAM_LOGS_DIR)) {
+    mkdirSync(DREAM_LOGS_DIR, { recursive: true });
+  }
+  const now = new Date();
+  const ts = now.toISOString().replace(/[:.]/g, "-").slice(0, 19); // 2026-04-01T21-30-00
+  return resolve(DREAM_LOGS_DIR, `dream-${ts}.md`);
+}
+
+function appendDreamLog(logFile: string, text: string): void {
+  try {
+    appendFileSync(logFile, text);
+  } catch (err) {
+    logError("dream", "Failed to write dream log", err);
+  }
+}
+
+function logDreamMessage(logFile: string, msg: SDKMessage): void {
+  try {
+    const ts = new Date().toISOString().slice(11, 19); // HH:MM:SS
+
+    switch (msg.type) {
+      case "assistant": {
+        // 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 : "");
+        const toolUseBlocks = msg.message.content
+          .filter((b) => b.type === "tool_use")
+          .map((b) => {
+            const tu = b as { name: string; input: unknown };
+            return `**Tool call:** \`${tu.name}\`\n\`\`\`json\n${JSON.stringify(tu.input, null, 2)}\n\`\`\``;
+          });
+
+        if (textBlocks.length > 0) {
+          appendDreamLog(logFile, `\n## [${ts}] Assistant\n${textBlocks.join("\n")}\n`);
+        }
+        if (toolUseBlocks.length > 0) {
+          appendDreamLog(logFile, `\n${toolUseBlocks.join("\n\n")}\n`);
+        }
+        break;
+      }
+      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`);
+        break;
+      }
+      case "system": {
+        appendDreamLog(logFile, `\n### [${ts}] System (${msg.subtype})\n`);
+        break;
+      }
+      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`);
+        }
+        break;
+      }
+      default:
+        // Skip stream_event and other noisy message types
+        break;
+    }
+  } catch {
+    // Don't let logging errors break the dream
+  }
+}
+
+// ── State helpers ────────────────────────────────────────────────────────────
+
+function readDreamState(): DreamState | null {
+  try {
+    if (!existsSync(DREAM_STATE_FILE)) return null;
+    const raw = readFileSync(DREAM_STATE_FILE, "utf-8");
+    const parsed = JSON.parse(raw) as DreamState;
+    if (typeof parsed.last_run !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+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");
+  } catch (err) {
+    logError("dream", "Failed to write dream state", err);
+  }
+}