talon-agent 3.33.4 → 3.34.1

package/src/core/background/triggers/resume.ts

@@ -9,6 +9,7 @@ import {
   getAllTriggers,
   updateTrigger,
   RESTART_KILL_ERROR,
+  SHUTDOWN_KILL_ERROR,
   type Trigger,
 } from "../../../storage/trigger-store.js";
 import { log, logError } from "../../../util/log.js";
@@ -50,19 +51,25 @@ export async function resumeAfterRestart(): Promise<void> {
     // Late death notice. Two cases earn one:
     //   - never fired at all (the old rule) — the chat heard nothing
     //     from this trigger, so its termination is news; and
-    //   - killed by THIS restart (recoverInterrupted stamped the
-    //     marker error) — even a multi-fire watcher that signalled
-    //     mid-run was still an active promise when the process died,
-    //     and without this wake the chat never learns its watcher is
-    //     gone. (Previously gated on lastFireAt === undefined alone,
-    //     which silently dropped exactly those watchers.)
+    //   - killed by THIS restart — either the crash path
+    //     (recoverInterrupted stamped RESTART_KILL_ERROR) or the clean
+    //     path (shutdownTriggers stamped SHUTDOWN_KILL_ERROR and
+    //     finalizeExit deliberately skipped the wake because the
+    //     backend pool was already going away). Even a multi-fire
+    //     watcher that signalled mid-run was still an active promise
+    //     when the process died, and without this wake the chat never
+    //     learns its watcher is gone. (Previously gated on
+    //     lastFireAt === undefined alone, which silently dropped
+    //     exactly those watchers.)
     // Triggers that exited on their own already fired their terminal
     // wake (lastFireAt set, no marker) — they stay silent here.
     if (
       t.status === "terminated" &&
       t.endedAt &&
       Date.now() - t.endedAt < 5 * 60_000 &&
-      (t.lastFireAt === undefined || t.lastError === RESTART_KILL_ERROR)
+      (t.lastFireAt === undefined ||
+        t.lastError === RESTART_KILL_ERROR ||
+        t.lastError === SHUTDOWN_KILL_ERROR)
     ) {
       await fireWake(t.id, "terminated", t.lastError, /* terminal */ true);
     }

package/src/core/background/triggers/state.ts

@@ -20,6 +20,14 @@ export type TriggerDeps = {
 /** Reassignable on a holder object so submodules see the injected deps. */
 export const depsHolder: { deps: TriggerDeps | null } = { deps: null };
 
+/**
+ * Set by shutdownTriggers for the rest of the process lifetime. finalizeExit
+ * consults it so the children it kills don't dispatch wakes into a backend
+ * pool that is being torn down at the same time. initTriggers clears it so a
+ * fresh lifecycle (next boot, or the next test) starts clean.
+ */
+export const lifecycle = { shuttingDown: false };
+
 /** Live child handles, keyed by trigger id. */
 export const children = new Map<string, ChildProcess>();
 export const timeouts = new Map<string, ReturnType<typeof setTimeout>>();
@@ -43,6 +51,7 @@ export const WARDEN_GRACE_SLACK_MS = 2_000;
 
 export function initTriggers(d: TriggerDeps): void {
   depsHolder.deps = d;
+  lifecycle.shuttingDown = false;
   log("triggers", "Initialized");
 }
 

package/src/core/engine/backend-controller/pool.ts

@@ -14,6 +14,7 @@ import { log, logWarn } from "../../../util/log.js";
 import { roleHolder } from "./holders.js";
 import {
   pool,
+  initInFlight,
   bindings,
   listeners,
   ctx,
@@ -285,6 +286,7 @@ export async function cleanupBackendPool(): Promise<void> {
 /** Test-only state reset. */
 export function resetBackendPoolForTest(): void {
   pool.clear();
+  initInFlight.clear();
   bindings.clear();
   ctx.initCtx = null;
   ctx.poolConfig = null;

package/src/core/engine/backend-controller/state.ts

@@ -29,6 +29,8 @@ export interface PoolEntry {
 
 /** id → entry. */
 export const pool = new Map<string, PoolEntry>();
+/** id → init in progress; concurrent callers await the same promise. */
+export const initInFlight = new Map<string, Promise<PoolEntry>>();
 /** holder → backend id (only present for holders currently bound). */
 export const bindings = new Map<BackendHolder, string>();
 
@@ -56,6 +58,8 @@ export async function ensurePoolEntry(
 ): Promise<PoolEntry> {
   const existing = pool.get(id);
   if (existing) return existing;
+  const inFlight = initInFlight.get(id);
+  if (inFlight) return inFlight;
 
   const factory = getBackend(id);
   if (!factory) {
@@ -64,22 +68,31 @@ export async function ensurePoolEntry(
       .join(", ");
     throw new Error(`Unknown backend "${id}" — known: ${known}`);
   }
-  if (!ctx.initCtx) {
+  const initCtx = ctx.initCtx;
+  if (!initCtx) {
     throw new Error(
       "Backend pool not initialised — call initBackendPool first",
     );
   }
-  const instance = await factory.init(config, ctx.initCtx);
-  const entry: PoolEntry = {
-    id: factory.id,
-    label: factory.label,
-    backend: instance.backend,
-    cleanup: instance.cleanup,
-    holders: new Set(),
-  };
-  pool.set(factory.id, entry);
-  log("backend-controller", `Pool init: ${factory.label} (${factory.id})`);
-  return entry;
+  const init = (async (): Promise<PoolEntry> => {
+    const instance = await factory.init(config, initCtx);
+    const entry: PoolEntry = {
+      id: factory.id,
+      label: factory.label,
+      backend: instance.backend,
+      cleanup: instance.cleanup,
+      holders: new Set(),
+    };
+    pool.set(factory.id, entry);
+    log("backend-controller", `Pool init: ${factory.label} (${factory.id})`);
+    return entry;
+  })();
+  initInFlight.set(id, init);
+  try {
+    return await init;
+  } finally {
+    initInFlight.delete(id);
+  }
 }
 
 /** Drop a holder from an entry; clean up the entry if its refcount hits zero. */

package/src/core/engine/gateway-actions/cron.ts

@@ -8,14 +8,12 @@ import {
   getCronJobsForChat,
   updateCronJob,
   deleteCronJob,
-  validateCronExpression,
   generateCronId,
   describeSchedule,
   nextRunAt,
-  type CronJobType,
-  type CatchupPolicy,
 } from "../../../storage/cron-store.js";
 import { runJobNow } from "../../background/cron.js";
+import { parseCronSpec } from "../../background/cron-spec.js";
 import { log } from "../../../util/log.js";
 import type { Backend } from "../../agent-runtime/capabilities.js";
 import {
@@ -27,31 +25,6 @@ import {
 import { validateJobModelOverride } from "./shared.js";
 import type { SharedActionHandlers } from "./types.js";
 
-// ── Scheduler field parsing (shared by create/edit cron) ────────────────────
-
-/** The scheduler ticks once a minute, so sub-minute intervals are meaningless. */
-const MIN_INTERVAL_SECONDS = 60;
-const CATCHUP_POLICIES = new Set<CatchupPolicy>(["skip", "once", "all"]);
-
-/** True for a body field that was actually supplied (not absent/blank). */
-function provided(v: unknown): boolean {
-  return v !== undefined && v !== null && v !== "";
-}
-
-/**
- * Parse an instant given as an ISO-8601 string or epoch-ms number into epoch
- * ms. Returns undefined when the field is absent or unparseable — callers
- * distinguish the two via `provided()`.
- */
-function parseInstant(v: unknown): number | undefined {
-  if (!provided(v)) return undefined;
-  if (typeof v === "number") return Number.isFinite(v) ? v : undefined;
-  const s = String(v).trim();
-  if (/^\d+$/.test(s)) return Number(s);
-  const d = Date.parse(s);
-  return Number.isFinite(d) ? d : undefined;
-}
-
 /**
  * Validate a cron `query` job's model + optional provider override. Cron runs
  * isolated, so unlike triggers it may target a different provider — the backend
@@ -113,147 +86,38 @@ function validateCronBackgroundCapability(
 
 export const cronHandlers: SharedActionHandlers = {
   create_cron_job: async (body, chatId) => {
-    const name = String(body.name ?? "Unnamed job");
-    const jobType = (body.type as CronJobType) ?? "message";
-    const content = String(body.content ?? "");
-    const timezone = body.timezone ? String(body.timezone) : undefined;
-    const model = body.model ? String(body.model) : undefined;
-    const provider = body.provider ? String(body.provider) : undefined;
-    const instructions = body.instructions
-      ? String(body.instructions)
-      : undefined;
-
-    if (!content) return { ok: false, error: "Missing content" };
-    if (content.length > 10_000)
-      return { ok: false, error: "Content too long (max 10,000 chars)" };
-
-    // Cadence: exactly one of `schedule` (cron expression) or
-    // `every_seconds` (fixed interval).
-    const schedule = provided(body.schedule)
-      ? String(body.schedule)
-      : undefined;
-    const hasEvery = provided(body.every_seconds);
-    if (!schedule && !hasEvery)
-      return {
-        ok: false,
-        error:
-          "Provide either 'schedule' (a cron expression) or 'every_seconds' (a fixed interval).",
-      };
-    if (schedule && hasEvery)
-      return {
-        ok: false,
-        error: "Provide only one of 'schedule' or 'every_seconds', not both.",
-      };
-
-    let everyMs: number | undefined;
-    if (hasEvery) {
-      const everySeconds = Number(body.every_seconds);
-      if (!Number.isFinite(everySeconds) || everySeconds < MIN_INTERVAL_SECONDS)
-        return {
-          ok: false,
-          error: `'every_seconds' must be a number >= ${MIN_INTERVAL_SECONDS} (the scheduler ticks once a minute).`,
-        };
-      everyMs = Math.round(everySeconds * 1000);
-    }
-
-    if (schedule) {
-      const validation = validateCronExpression(schedule, timezone);
-      if (!validation.valid)
-        return {
-          ok: false,
-          error: `Invalid cron expression: ${validation.error}`,
-        };
-    }
-
-    // Lifecycle bounds.
-    const startAt = parseInstant(body.start_at);
-    if (provided(body.start_at) && startAt === undefined)
-      return {
-        ok: false,
-        error:
-          "Could not parse 'start_at' (use an ISO-8601 timestamp or epoch ms).",
-      };
-    const endAt = parseInstant(body.end_at);
-    if (provided(body.end_at) && endAt === undefined)
-      return {
-        ok: false,
-        error:
-          "Could not parse 'end_at' (use an ISO-8601 timestamp or epoch ms).",
-      };
-    if (startAt !== undefined && endAt !== undefined && endAt <= startAt)
-      return { ok: false, error: "'end_at' must be after 'start_at'." };
-    if (endAt !== undefined && endAt <= Date.now())
-      return {
-        ok: false,
-        error: "'end_at' is in the past — the job would never run.",
-      };
-
-    // Run cap. `once: true` is sugar for max_runs = 1 (one-shot).
-    let maxRuns: number | undefined;
-    if (body.once === true) maxRuns = 1;
-    else if (provided(body.max_runs)) {
-      const m = Number(body.max_runs);
-      if (!Number.isInteger(m) || m < 1)
-        return { ok: false, error: "'max_runs' must be a positive integer." };
-      maxRuns = m;
-    }
-
-    // Missed-run catch-up policy. New jobs default to "once": a run that
-    // came due while Talon was down (or while the scheduler was wedged)
-    // replays a single time at startup instead of being lost silently — a
-    // live audit found one-shot reminders that missed their date under the
-    // old "skip" default and quietly rolled over a full year. Explicit
-    // "skip" remains available for jobs where a late run is worthless.
-    let catchup: CatchupPolicy = "once";
-    if (provided(body.catchup)) {
-      catchup = String(body.catchup) as CatchupPolicy;
-      if (!CATCHUP_POLICIES.has(catchup))
-        return {
-          ok: false,
-          error: "'catchup' must be one of: skip, once, all.",
-        };
-    }
-
-    // The overrides only make sense for "query" jobs (a "message" job just
-    // sends text — no model runs).
-    if ((model || provider || instructions) && jobType !== "query")
-      return {
-        ok: false,
-        error: "Model/provider/instructions only apply to 'query' jobs.",
-      };
-    if (provider && !model)
-      return {
-        ok: false,
-        error: "A 'provider' override also requires a 'model'.",
-      };
+    const parsed = parseCronSpec(body);
+    if (!parsed.ok) return { ok: false, error: parsed.error };
+    const spec = parsed.effective;
+    const {
+      name,
+      type: jobType,
+      schedule,
+      everyMs,
+      startAt,
+      endAt,
+      maxRuns,
+    } = spec;
 
     // Validate the target backend/model up front so a bad id or unsupported
     // backend is rejected here instead of silently failing at fire time.
     if (jobType === "query") {
-      const modelErr = await validateCronModelOverride(chatId, model, provider);
+      const modelErr = await validateCronModelOverride(
+        chatId,
+        spec.model,
+        spec.provider,
+      );
       if (modelErr) return { ok: false, error: modelErr };
     }
 
     const id = generateCronId();
     addCronJob({
+      ...spec,
       id,
       chatId: String(chatId),
-      type: jobType,
-      content,
-      name,
       enabled: true,
       createdAt: Date.now(),
       runCount: 0,
-      timezone,
-      ...(schedule ? { schedule } : {}),
-      ...(everyMs !== undefined ? { everyMs } : {}),
-      ...(startAt !== undefined ? { startAt } : {}),
-      ...(endAt !== undefined ? { endAt } : {}),
-      ...(maxRuns !== undefined ? { maxRuns } : {}),
-      catchup,
-      ...(model ? { model } : {}),
-      ...(provider ? { provider } : {}),
-      ...(instructions ? { instructions } : {}),
     });
     log(
       "gateway",
@@ -268,7 +132,7 @@ export const cronHandlers: SharedActionHandlers = {
         ? `starts: ${new Date(startAt).toISOString()}`
         : null,
       endAt !== undefined ? `ends: ${new Date(endAt).toISOString()}` : null,
-      catchup ? `catch-up: ${catchup}` : null,
+      spec.catchup ? `catch-up: ${spec.catchup}` : null,
     ]
       .filter(Boolean)
       .join(", ");
@@ -335,157 +199,29 @@ export const cronHandlers: SharedActionHandlers = {
     if (job.chatId !== String(chatId))
       return { ok: false, error: "Job belongs to a different chat" };
 
-    const updates: Record<string, unknown> = {};
-    if (body.name !== undefined) updates.name = String(body.name);
-    if (body.content !== undefined) updates.content = String(body.content);
-    if (body.enabled !== undefined) updates.enabled = Boolean(body.enabled);
-    if (body.type !== undefined) updates.type = String(body.type);
-    if (body.timezone !== undefined)
-      updates.timezone = body.timezone ? String(body.timezone) : undefined;
-
-    // Cadence — schedule and every_seconds are mutually exclusive; setting
-    // one switches mode and clears the other.
-    const editSchedule = body.schedule !== undefined;
-    const editEvery = provided(body.every_seconds);
-    if (editSchedule && provided(body.schedule) && editEvery)
-      return {
-        ok: false,
-        error: "Provide only one of 'schedule' or 'every_seconds', not both.",
-      };
-    if (editSchedule && provided(body.schedule)) {
-      const tz = (updates.timezone as string | undefined) ?? job.timezone;
-      const v = validateCronExpression(String(body.schedule), tz);
-      if (!v.valid)
-        return { ok: false, error: `Invalid cron expression: ${v.error}` };
-      updates.schedule = String(body.schedule);
-      updates.everyMs = undefined;
-    }
-    if (editEvery) {
-      const everySeconds = Number(body.every_seconds);
-      if (!Number.isFinite(everySeconds) || everySeconds < MIN_INTERVAL_SECONDS)
-        return {
-          ok: false,
-          error: `'every_seconds' must be a number >= ${MIN_INTERVAL_SECONDS}.`,
-        };
-      updates.everyMs = Math.round(everySeconds * 1000);
-      updates.schedule = undefined;
-    }
+    const parsed = parseCronSpec(body, job);
+    if (!parsed.ok) return { ok: false, error: parsed.error };
+    const { updates, effective } = parsed;
 
-    // Lifecycle bounds (pass null/"" to clear).
-    if (body.start_at !== undefined) {
-      if (!provided(body.start_at)) updates.startAt = undefined;
-      else {
-        const s = parseInstant(body.start_at);
-        if (s === undefined)
-          return { ok: false, error: "Could not parse 'start_at'." };
-        updates.startAt = s;
-      }
-    }
-    if (body.end_at !== undefined) {
-      if (!provided(body.end_at)) updates.endAt = undefined;
-      else {
-        const e = parseInstant(body.end_at);
-        if (e === undefined)
-          return { ok: false, error: "Could not parse 'end_at'." };
-        if (e <= Date.now())
-          return {
-            ok: false,
-            error: "'end_at' is in the past — the job would never run.",
-          };
-        updates.endAt = e;
-      }
-    }
-    if (body.once === true) updates.maxRuns = 1;
-    else if (body.max_runs !== undefined) {
-      if (!provided(body.max_runs)) updates.maxRuns = undefined;
-      else {
-        const m = Number(body.max_runs);
-        if (!Number.isInteger(m) || m < 1)
-          return {
-            ok: false,
-            error: "'max_runs' must be a positive integer.",
-          };
-        updates.maxRuns = m;
-      }
-    }
-    if (body.catchup !== undefined) {
-      const c = String(body.catchup) as CatchupPolicy;
-      if (!CATCHUP_POLICIES.has(c))
-        return {
-          ok: false,
-          error: "'catchup' must be one of: skip, once, all.",
-        };
-      updates.catchup = c;
-    }
-    if (body.model !== undefined) {
-      updates.model = provided(body.model) ? String(body.model) : undefined;
-    }
-    if (body.provider !== undefined) {
-      updates.provider = provided(body.provider)
-        ? String(body.provider)
-        : undefined;
-    }
-    if (body.instructions !== undefined) {
-      updates.instructions = provided(body.instructions)
-        ? String(body.instructions)
-        : undefined;
-    }
-
-    // Query execution overrides only apply to 'query' jobs — mirror create.
     // Validate the effective post-edit target so provider+model edits are
     // checked together using cron's cross-provider rules.
-    const effType = (updates.type as CronJobType | undefined) ?? job.type;
-    const effModel =
-      "model" in updates ? (updates.model as string | undefined) : job.model;
-    const effProvider =
-      "provider" in updates
-        ? (updates.provider as string | undefined)
-        : job.provider;
-    const effInstructions =
-      "instructions" in updates
-        ? (updates.instructions as string | undefined)
-        : job.instructions;
-    if (effType !== "query" && (effModel || effProvider || effInstructions))
-      return {
-        ok: false,
-        error: "Model/provider/instructions only apply to 'query' jobs.",
-      };
-    if (effProvider && !effModel)
-      return {
-        ok: false,
-        error: "A 'provider' override also requires a 'model'.",
-      };
     if (
-      effType === "query" &&
+      effective.type === "query" &&
       ("model" in updates || "provider" in updates || "type" in updates)
     ) {
       const modelErr = await validateCronModelOverride(
         chatId,
-        effModel,
-        effProvider,
+        effective.model,
+        effective.provider,
       );
       if (modelErr) return { ok: false, error: modelErr };
     }
 
-    // Reject a start/end window that can never fire, accounting for the merge.
-    const effStart =
-      "startAt" in updates
-        ? (updates.startAt as number | undefined)
-        : job.startAt;
-    const effEnd =
-      "endAt" in updates ? (updates.endAt as number | undefined) : job.endAt;
-    if (effStart !== undefined && effEnd !== undefined && effEnd <= effStart)
-      return { ok: false, error: "'end_at' must be after 'start_at'." };
-
     // If a lowered run cap already met/exceeds runCount, retire the job now so
     // it can't sneak one more run before enforceRunCap catches it post-run.
-    const effMaxRuns =
-      "maxRuns" in updates
-        ? (updates.maxRuns as number | undefined)
-        : job.maxRuns;
     if (
-      effMaxRuns !== undefined &&
-      job.runCount >= effMaxRuns &&
+      effective.maxRuns !== undefined &&
+      job.runCount >= effective.maxRuns &&
       updates.enabled !== true
     )
       updates.enabled = false;