talon-agent 3.0.5 → 3.1.1

package/src/storage/history.ts

@@ -26,19 +26,8 @@ import { formatSmartTimestamp, formatRelativeAge } from "../util/time.js";
 import { importLegacyJson } from "./legacy-import.js";
 import * as repo from "./repositories/history-repo.js";
 
-export type HistoryMessage = {
-  msgId: number;
-  senderId: number;
-  senderName: string;
-  text: string;
-  replyToMsgId?: number;
-  timestamp: number;
-  mediaType?:
-    "photo" | "document" | "voice" | "sticker" | "video" | "animation";
-  stickerFileId?: string;
-  /** Saved file path for downloaded media. */
-  filePath?: string;
-};
+export type { HistoryMessage } from "./repositories/history-repo.js";
+import type { HistoryMessage } from "./repositories/history-repo.js";
 
 // ── Persistence lifecycle ───────────────────────────────────────────────────
 
@@ -166,7 +155,7 @@ export function getRecentFormatted(chatId: string, limit = 20): string {
  * Build an FTS5 MATCH expression from free-form user input. Every
  * token is double-quoted so FTS operators (AND, NEAR, *, ^) in user
  * text are treated as literals, not syntax. Delegates to the C core
- * (native/sqlguard-c) for byte-identical output.
+ * (native/sqlguard-wasm) for byte-identical output.
  */
 function ftsQuery(query: string): string {
   return ftsQuote(query);

package/src/storage/journal.ts

@@ -15,10 +15,21 @@
  * PRUNE_EVERY appends) rather than on a timer.
  */
 
-import type { PublishedEvent, TalonEvent } from "../core/bus/index.js";
 import { logError } from "../util/log.js";
 import * as repo from "./repositories/journal-repo.js";
 
+/**
+ * The shape the journal needs from a record: a type column to index on
+ * and a publish time. The bus's `PublishedEvent` satisfies it; the
+ * journal itself stays ignorant of the event vocabulary (storage never
+ * imports upward from core) — readers narrow with the type parameter
+ * on `readJournal`.
+ */
+export interface JournalRecord {
+  readonly type: string;
+  readonly at: number;
+}
+
 /** Rows kept after a prune — bounded, but generous for a busy daemon. */
 export const JOURNAL_RETENTION = 20_000;
 
@@ -26,12 +37,12 @@ export const JOURNAL_RETENTION = 20_000;
 const PRUNE_EVERY = 500;
 
 /** One journal record: the event plus its durable cursor and time. */
-export interface JournalEntry {
+export interface JournalEntry<E extends JournalRecord = JournalRecord> {
   /** Durable, monotonic cursor — survives restarts (unlike bus ids). */
   readonly seq: number;
   /** Publish time, epoch ms. */
   readonly at: number;
-  readonly event: TalonEvent;
+  readonly event: E;
 }
 
 let appendsSincePrune = 0;
@@ -42,7 +53,7 @@ let appendFailureLogged = false;
  * observer, and a full disk or locked database must not break the bus
  * or the publisher behind it.
  */
-export function appendToJournal(event: PublishedEvent): void {
+export function appendToJournal(event: JournalRecord): void {
   try {
     repo.append(event.at, event.type, JSON.stringify(event));
     if (++appendsSincePrune >= PRUNE_EVERY) {
@@ -63,20 +74,20 @@ export function appendToJournal(event: PublishedEvent): void {
  * (indexed). Rows whose payload no longer parses are skipped — a
  * corrupt row must not take down the readable ones around it.
  */
-export function readJournal(
-  options: { limit?: number; type?: TalonEvent["type"] } = {},
-): JournalEntry[] {
+export function readJournal<E extends JournalRecord = JournalRecord>(
+  options: { limit?: number; type?: E["type"] } = {},
+): JournalEntry<E>[] {
   const limit = options.limit ?? 100;
   const rows = options.type
     ? repo.recentByType(options.type, limit)
     : repo.recent(limit);
-  const entries: JournalEntry[] = [];
+  const entries: JournalEntry<E>[] = [];
   for (const row of rows) {
     try {
       entries.push({
         seq: row.seq,
         at: row.at,
-        event: JSON.parse(row.payload) as TalonEvent,
+        event: JSON.parse(row.payload) as E,
       });
     } catch {
       // skip the corrupt row

package/src/storage/media-index.ts

@@ -24,28 +24,8 @@ import { importLegacyJson } from "./legacy-import.js";
 import { setMessageFilePath } from "./history.js";
 import * as repo from "./repositories/media-index-repo.js";
 
-export type MediaEntry = {
-  id: string; // unique key: chatId:msgId
-  chatId: string;
-  msgId: number;
-  senderName: string;
-  type:
-    | "photo"
-    | "document"
-    | "voice"
-    | "video"
-    | "animation"
-    | "audio"
-    | "sticker";
-  filePath: string;
-  caption?: string;
-  timestamp: number;
-  /**
-   * BLAKE3 hex digest of the file contents (native/blake3-wasm).
-   * Filled in asynchronously after addMedia; undefined until hashed.
-   */
-  contentHash?: string;
-};
+export type { MediaEntry } from "./repositories/media-index-repo.js";
+import type { MediaEntry } from "./repositories/media-index-repo.js";
 
 const RETENTION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 

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

@@ -13,7 +13,61 @@
 
 import { getDatabase, inTransaction } from "../db.js";
 import { chatSettingsSql } from "../sql/statements.generated.js";
-import type { ChatSettings } from "../chat-settings.js";
+import type { ReasoningEffortLevel } from "../../types/effort.js";
+
+export type ChatSettings = {
+  /**
+   * Per-backend model overrides for this chat. Keyed by backend id
+   * (`"claude"`, `"codex"`, `"openai-agents"`, etc). Each entry is the
+   * model id the user picked on that backend.
+   *
+   * Switching backends preserves each side's last pick — your Codex
+   * chat remembers `gpt-5.5`, your OpenRouter chat remembers
+   * `meta-llama/...`. Replaces the single legacy `model` field which
+   * couldn't differentiate per-backend choices and produced the
+   * orphan-bug class (model from backend X persisting when switching
+   * to backend Y).
+   *
+   * Resolution order (see `core/models/active-model.ts`):
+   *   1. `modelByBackend[activeBackend]` if it validates on the catalog
+   *   2. `backend.getDefaultModel()` (canonical for backends that have one)
+   *   3. `config.backendDefaults[activeBackend]` (operator override)
+   *   4. `config.model` (only when activeBackend === config.backend)
+   *   5. null → "No model selected" UI + send guard refuses.
+   */
+  modelByBackend?: Record<string, string>;
+  /**
+   * @deprecated Single-slot model field. Retained for back-compat with
+   * old stores; migrated into `modelByBackend` on load. New writes go
+   * through `setChatModelForBackend` instead.
+   */
+  model?: string;
+  /**
+   * Backend override for this chat. When set, queries from this chat
+   * route to the override backend instead of the global `config.backend`.
+   * The backend controller refcounts pool instances, so two chats on
+   * two different backends keep both alive concurrently.
+   *
+   * Stored as the registry id (e.g. `"claude"`, `"openai-agents"`).
+   * Cleared via `setChatBackend(cid, undefined)` — chat reverts to
+   * the global default.
+   */
+  backend?: string;
+  /** Effort level override (maps to SDK thinking + effort options). */
+  effort?: ReasoningEffortLevel;
+  /** Whether pulse is enabled for this chat. */
+  pulse?: boolean;
+  /** Per-chat pulse check interval in milliseconds. */
+  pulseIntervalMs?: number;
+  /** Last message ID checked by pulse (persisted to avoid reprocessing on restart). */
+  pulseLastCheckMsgId?: number;
+  /**
+   * When true, the model picker filters to free-tier models by default.
+   * Only meaningful for backends that report free-tier metadata (currently
+   * `openai-agents` against OpenRouter); other backends ignore the flag.
+   */
+  freeOnly?: boolean;
+};
 
 export function upsert(chatId: string, settings: ChatSettings): void {
   getDatabase()

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

@@ -7,12 +7,88 @@
 
 import { getDatabase } from "../db.js";
 import { cronSql } from "../sql/statements.generated.js";
-import type {
-  CatchupPolicy,
-  CronJob,
-  CronJobType,
-  CronRunStatus,
-} from "../cron-store.js";
+import type { CatchupPolicy } from "../../native/scheduler-core.js";
+
+export type CronJobType = "message" | "query";
+
+/** Outcome of the most recent execution — surfaced in list_cron_jobs. */
+export type CronRunStatus = "ok" | "error";
+
+export type CronJob = {
+  id: string;
+  chatId: string;
+  /**
+   * Cron expression (5-field: minute hour day month weekday). Optional — a job
+   * carries EITHER `schedule` (cron mode) OR `everyMs` (interval mode), never
+   * both. The store validator (`isCronJob`) enforces exactly one.
+   */
+  schedule?: string;
+  /**
+   * Fixed interval in milliseconds (interval mode). Mutually exclusive with
+   * `schedule`. The job fires roughly every `everyMs` after its anchor
+   * (`lastRunAt`, else `startAt`, else `createdAt`). Wires the native
+   * scheduler-core interval math (next-due + missed-run catch-up) directly.
+   */
+  everyMs?: number;
+  /** "message" sends content as text; "query" runs content as a Claude prompt with tools */
+  type: CronJobType;
+  /** The message text or query prompt */
+  content: string;
+  /** Human-readable name for the job */
+  name: string;
+  enabled: boolean;
+  createdAt: number;
+  lastRunAt?: number;
+  runCount: number;
+  /** IANA timezone (e.g. "America/New_York"). Defaults to system timezone. */
+  timezone?: string;
+  /**
+   * Optional model override for `query` jobs. Unset = the chat's model. `query`
+   * cron jobs run as an isolated one-shot (no chat session), so unlike triggers
+   * the model may be on a different provider — see `provider`.
+   */
+  model?: string;
+  /**
+   * Optional provider/backend id for the override (e.g. a cheaper provider than
+   * the chat). Requires `model`. Unset = the chat's backend. Since cron runs
+   * isolated, a different provider is fine here.
+   */
+  provider?: string;
+  /**
+   * Optional short brief that becomes the isolated agent's system prompt — what
+   * the job is and how to do it. Useful to orient a cheaper override model.
+   */
+  instructions?: string;
+  /**
+   * Don't fire before this epoch-ms instant (a delayed start / "not before").
+   * Unset = eligible immediately.
+   */
+  startAt?: number;
+  /**
+   * Don't fire after this epoch-ms instant; the job auto-disables once now
+   * passes it (a natural expiry / "until"). Unset = no end.
+   */
+  endAt?: number;
+  /**
+   * Auto-disable after this many total runs (`runCount >= maxRuns`). A value of
+   * 1 makes the job one-shot. Unset = unbounded.
+   */
+  maxRuns?: number;
+  /**
+   * Missed-run policy for runs that were due while Talon was down:
+   *   "skip" (default) — drop them, resume on the next due tick
+   *   "once"           — collapse any number of missed runs into a single catch-up
+   *   "all"            — replay every missed run, capped by CATCHUP_MAX
+   * Decided by the native scheduler-core `catchupRunCount`.
+   */
+  catchup?: CatchupPolicy;
+  /** Status of the most recent execution. */
+  lastStatus?: CronRunStatus;
+  /** Error message from the most recent failed execution (cleared on success). */
+  lastError?: string;
+  /** Wall-clock duration of the most recent execution, in ms. */
+  lastDurationMs?: number;
+};
 
 type Row = {
   id: string;

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

@@ -7,7 +7,26 @@
 
 import { getDatabase } from "../db.js";
 import { goalsSql } from "../sql/statements.generated.js";
-import type { Goal, GoalPriority, GoalStatus } from "../goal-store.js";
+export type GoalStatus = "active" | "paused" | "completed" | "abandoned";
+export type GoalPriority = "low" | "normal" | "high";
+
+/** One persistent goal as the domain sees it. */
+export type Goal = {
+  id: string;
+  /** Chat the goal belongs to — progress reports route back here. */
+  chatId: string;
+  title: string;
+  description?: string;
+  status: GoalStatus;
+  priority: GoalPriority;
+  createdAt: number;
+  updatedAt: number;
+  /** Optional soft deadline (unix ms). */
+  dueAt?: number;
+  /** Rolling note from the last progress update. */
+  lastProgressNote?: string;
+  lastProgressAt?: number;
+};
 
 type Row = {
   id: string;

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

@@ -8,7 +8,20 @@
 import { escapeLike } from "../../native/sqlguard.js";
 import { getDatabase, inTransaction } from "../db.js";
 import { historySql } from "../sql/statements.generated.js";
-import type { HistoryMessage } from "../history.js";
+/** One chat message as the domain sees it — the shape the rows map to. */
+export type HistoryMessage = {
+  msgId: number;
+  senderId: number;
+  senderName: string;
+  text: string;
+  replyToMsgId?: number;
+  timestamp: number;
+  mediaType?:
+    "photo" | "document" | "voice" | "sticker" | "video" | "animation";
+  stickerFileId?: string;
+  /** Saved file path for downloaded media. */
+  filePath?: string;
+};
 
 type Row = {
   msg_id: number;

package/src/storage/repositories/media-index-repo.ts

@@ -14,7 +14,29 @@
 
 import { getDatabase, inTransaction } from "../db.js";
 import { mediaIndexSql } from "../sql/statements.generated.js";
-import type { MediaEntry } from "../media-index.js";
+/** One indexed media file as the domain sees it. */
+export type MediaEntry = {
+  id: string; // unique key: chatId:msgId
+  chatId: string;
+  msgId: number;
+  senderName: string;
+  type:
+    | "photo"
+    | "document"
+    | "voice"
+    | "video"
+    | "animation"
+    | "audio"
+    | "sticker";
+  filePath: string;
+  caption?: string;
+  timestamp: number;
+  /**
+   * BLAKE3 hex digest of the file contents (native/blake3-wasm).
+   * Filled in asynchronously after addMedia; undefined until hashed.
+   */
+  contentHash?: string;
+};
 
 type Row = {
   chat_id: string;

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

@@ -8,7 +8,22 @@
 
 import { getDatabase } from "../db.js";
 import { scriptsSql } from "../sql/statements.generated.js";
-import type { Script, ScriptLanguage } from "../script-store.js";
+export type ScriptLanguage = "bash" | "python" | "node";
+
+/** One saved script as the domain sees it. */
+export type Script = {
+  id: string;
+  /** Unique lookup key — also the script's filename stem. */
+  name: string;
+  /** One-liner shown in listings; tells the agent when to reach for it. */
+  description: string;
+  language: ScriptLanguage;
+  scriptPath: string;
+  createdAt: number;
+  updatedAt: number;
+  useCount: number;
+  lastUsedAt?: number;
+};
 
 type Row = {
   id: string;

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

@@ -19,7 +19,7 @@ import {
   normaliseMetrics,
   type SessionMetrics,
   type SessionState,
-} from "../sessions.js";
+} from "../session-record.js";
 
 type Row = {
   chat_id: string;

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

@@ -8,11 +8,66 @@
 
 import { getDatabase } from "../db.js";
 import { triggersSql } from "../sql/statements.generated.js";
-import type {
-  Trigger,
-  TriggerLanguage,
-  TriggerStatus,
-} from "../trigger-store.js";
+export type TriggerLanguage = "bash" | "python" | "node" | "lua";
+
+export type TriggerStatus =
+  | "pending" // created, not yet spawned (transient)
+  | "running" // child process alive
+  | "fired" // exited 0 — fired final wake message
+  | "errored" // exited non-zero — fired error wake message
+  | "cancelled" // killed by user (trigger_cancel)
+  | "timed_out" // killed by hard timeout
+  | "terminated"; // killed by Talon shutdown / restart
+
+export type Trigger = {
+  id: string;
+  chatId: string;
+  numericChatId: number;
+  name: string;
+  language: TriggerLanguage;
+  /** Absolute path to the script body on disk. */
+  scriptPath: string;
+  /** Absolute path to the run log (interleaved stdout+stderr). */
+  logPath: string;
+  description?: string;
+  status: TriggerStatus;
+  createdAt: number;
+  startedAt?: number;
+  endedAt?: number;
+  /** PID of the child process while running (cleared on exit). */
+  pid?: number;
+  /** Linux /proc/<pid>/stat field 22 (start time in jiffies) captured at
+   *  spawn. Used by killOrphan to defend against PID reuse — start time is
+   *  monotonic per boot and unchanged by exec(), so a match guarantees the
+   *  current owner of the PID is the same process we spawned. Undefined on
+   *  non-Linux platforms. */
+  pidStarttime?: number;
+  /** Hard timeout in seconds. Default 24h, max 7d. */
+  timeoutSeconds: number;
+  /** Exit code on terminal status. */
+  exitCode?: number;
+  /** Total wake-ups fired for this trigger — sum of mid-run TALON_FIRE: lines
+   *  plus the terminal exit fire. Incremented every time fireWake() runs. */
+  fireCount: number;
+  lastFireAt?: number;
+  /** Truncated tail of the most recent fire payload (for diagnostics). */
+  lastFirePayload?: string;
+  lastError?: string;
+  /** If true, the trigger is respawned on Talon startup if it was still
+   *  active when Talon went down. Triggers in any terminal state
+   *  (fired/errored/cancelled) are NOT respawned — only ones interrupted
+   *  by Talon shutdown or crash. (Persistent triggers have no hard timeout,
+   *  so timed_out is unreachable for them — see spawnTrigger.) */
+  persistent?: boolean;
+  /**
+   * Optional model override for the wake-up turn — a model id valid on the
+   * chat's own backend. Unset = inherit the chat's model (preferred). When set,
+   * the fired wake-up runs on this (typically cheaper) model instead, while
+   * still resuming the chat session (restricted to the same backend so
+   * continuity is preserved).
+   */
+  model?: string;
+};
 
 type Row = {
   id: string;

package/src/storage/script-store.ts

@@ -22,21 +22,8 @@ import { dirname, resolve } from "node:path";
 import { dirs } from "../util/paths.js";
 import * as repo from "./repositories/scripts-repo.js";
 
-export type ScriptLanguage = "bash" | "python" | "node";
-
-export type Script = {
-  id: string;
-  /** Unique lookup key — also the script's filename stem. */
-  name: string;
-  /** One-liner shown in listings; tells the agent when to reach for it. */
-  description: string;
-  language: ScriptLanguage;
-  scriptPath: string;
-  createdAt: number;
-  updatedAt: number;
-  useCount: number;
-  lastUsedAt?: number;
-};
+export type { Script, ScriptLanguage } from "./repositories/scripts-repo.js";
+import type { Script, ScriptLanguage } from "./repositories/scripts-repo.js";
 
 export const SCRIPT_LANGUAGES: readonly ScriptLanguage[] = [
   "bash",