agent.libx.js 0.93.44 → 0.94.1

package/dist/cli.js

@@ -2659,6 +2659,11 @@ function reasoningToChatFragment(model, effort) {
 
 // src/Agent.ts
 var log3 = forComponent("Agent");
+function isAbortError(err2) {
+  const e = err2;
+  const blob = `${e?.message ?? ""} ${e?.name ?? ""} ${e?.code ?? ""} ${e?.cause?.name ?? ""}`;
+  return /operation was aborted|\bAbortError\b|ABORT_ERR|\[canceled\]/i.test(blob);
+}
 var AgentOptions = class {
   /** Any ai.libx.js AIClient (or a FakeAIClient). */
   ai;
@@ -2985,7 +2990,7 @@ var Agent = class _Agent {
         }
       } catch (err2) {
         if (err2?.code === "budget") return kill("budget");
-        if (o.signal?.aborted) return kill("aborted");
+        if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
         log3.error(`chat() failed: ${err2?.message ?? err2}`, err2);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err2 };
       }
@@ -3491,6 +3496,253 @@ init_OverlayFilesystem();
 // src/index.ts
 init_tools();
 
+// src/scheduler.ts
+function parseCronField(field, min, max) {
+  const vals = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [rangeStr, stepStr] = part.split("/");
+    const step = stepStr ? parseInt(stepStr, 10) : 1;
+    if (isNaN(step) || step < 1) throw new Error(`invalid cron step: ${part}`);
+    let lo, hi;
+    if (rangeStr === "*") {
+      lo = min;
+      hi = max;
+    } else if (rangeStr.includes("-")) {
+      const [a, b] = rangeStr.split("-").map(Number);
+      if (isNaN(a) || isNaN(b)) throw new Error(`invalid cron range: ${part}`);
+      lo = a;
+      hi = b;
+    } else {
+      const n = parseInt(rangeStr, 10);
+      if (isNaN(n)) throw new Error(`invalid cron value: ${part}`);
+      lo = n;
+      hi = stepStr ? max : n;
+    }
+    for (let i = lo; i <= hi; i += step) vals.add(i);
+  }
+  return [...vals].sort((a, b) => a - b);
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`cron expression must have 5 fields (minute hour dom month dow), got ${parts.length}: "${expr}"`);
+  return {
+    minute: parseCronField(parts[0], 0, 59),
+    hour: parseCronField(parts[1], 0, 23),
+    dom: parseCronField(parts[2], 1, 31),
+    month: parseCronField(parts[3], 1, 12),
+    dow: parseCronField(parts[4], 0, 6)
+  };
+}
+function cronMatches(fields, date) {
+  return fields.minute.includes(date.getMinutes()) && fields.hour.includes(date.getHours()) && fields.dom.includes(date.getDate()) && fields.month.includes(date.getMonth() + 1) && fields.dow.includes(date.getDay());
+}
+function nextCronAfter(cron, after) {
+  const fields = parseCron(cron);
+  const d = new Date(after);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = after + 366 * 864e5;
+  while (d.getTime() <= limit) {
+    if (cronMatches(fields, d)) return d.getTime();
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+var Scheduler = class {
+  jobs = /* @__PURE__ */ new Map();
+  seq = 0;
+  timer = null;
+  firing = false;
+  fire;
+  now;
+  tickMs;
+  constructor(opts) {
+    this.fire = opts.fire;
+    this.now = opts.now ?? Date.now;
+    this.tickMs = opts.tickMs ?? 15e3;
+    if (!opts.manual) this.start();
+  }
+  /** Start the tick timer. Idempotent. */
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), this.tickMs);
+    if (typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
+  }
+  /** Stop the tick timer. Does not clear jobs. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Add a scheduled job. Returns the job id. */
+  add(opts) {
+    if ("cron" in opts.trigger) parseCron(opts.trigger.cron);
+    if ("at" in opts.trigger && opts.trigger.at < this.now()) {
+    }
+    if ("everyMs" in opts.trigger && opts.trigger.everyMs < 1e3) {
+      throw new Error("interval must be >= 1000ms");
+    }
+    const id = `sched-${++this.seq}`;
+    this.jobs.set(id, {
+      id,
+      prompt: opts.prompt,
+      trigger: opts.trigger,
+      status: "active",
+      created: this.now(),
+      runs: 0,
+      label: opts.label
+    });
+    return id;
+  }
+  /** Cancel a job. Returns false if not found. */
+  cancel(id) {
+    const j = this.jobs.get(id);
+    if (!j) return false;
+    j.status = "done";
+    return true;
+  }
+  get(id) {
+    return this.jobs.get(id);
+  }
+  list() {
+    return [...this.jobs.values()];
+  }
+  active() {
+    return this.list().filter((j) => j.status === "active");
+  }
+  /** Compute when a job next fires (epoch ms), or null if done/unknown. */
+  nextFire(job) {
+    if (job.status !== "active") return null;
+    const t = job.trigger;
+    if ("at" in t) return t.at;
+    if ("everyMs" in t) return (job.lastRun ?? job.created) + t.everyMs;
+    if ("cron" in t) return nextCronAfter(t.cron, job.lastRun ?? job.created);
+    return null;
+  }
+  /** Check all active jobs and fire any that are due. Reentrant-safe. */
+  async tick() {
+    if (this.firing) return;
+    this.firing = true;
+    try {
+      const now5 = this.now();
+      for (const job of this.jobs.values()) {
+        if (job.status !== "active") continue;
+        const due = this.nextFire(job);
+        if (due == null || due > now5) continue;
+        job.lastRun = now5;
+        job.runs++;
+        if ("at" in job.trigger) job.status = "done";
+        try {
+          await this.fire(job);
+        } catch {
+        }
+      }
+    } finally {
+      this.firing = false;
+    }
+  }
+  /** Export all jobs for session persistence. */
+  snapshot() {
+    return this.list().filter((j) => j.status === "active").map((j) => ({ ...j }));
+  }
+  /** Restore jobs from a snapshot (e.g. on --resume). Clears existing jobs first. */
+  restore(snapshots) {
+    this.jobs.clear();
+    for (const s of snapshots) {
+      this.seq = Math.max(this.seq, parseInt(s.id.replace("sched-", ""), 10) || 0);
+      this.jobs.set(s.id, { ...s });
+    }
+  }
+  /** Number of active jobs. */
+  get size() {
+    return this.active().length;
+  }
+  destroy() {
+    this.stop();
+    this.jobs.clear();
+  }
+};
+function makeScheduleTools(scheduler) {
+  return [
+    {
+      name: "ScheduleTask",
+      description: 'Schedule a prompt to fire automatically while this session is alive.\nModes:\n  \u2022 One-off:   {at: <epoch_ms>}        \u2014 fires once at that time, then done.\n  \u2022 Interval:  {everyMs: <ms>}          \u2014 fires repeatedly (\u22651s).\n  \u2022 Cron:      {cron: "min hr dom mon dow"} \u2014 standard 5-field cron.\nReturns the job id. Jobs only fire while the CLI session is running \u2014 they do NOT survive quitting.',
+      parameters: {
+        type: "object",
+        required: ["prompt", "trigger"],
+        properties: {
+          prompt: { type: "string", description: "The prompt to inject when the job fires." },
+          trigger: {
+            type: "object",
+            description: 'One of: {at: epoch_ms}, {everyMs: ms}, {cron: "5-field expr"}.',
+            properties: {
+              at: { type: "number" },
+              everyMs: { type: "number" },
+              cron: { type: "string" }
+            }
+          },
+          label: { type: "string", description: "Short label for display (optional)." }
+        }
+      },
+      async run({ prompt, trigger, label }) {
+        try {
+          const id = scheduler.add({ prompt, trigger, label });
+          const job = scheduler.get(id);
+          const next = scheduler.nextFire(job);
+          return `Scheduled ${id}${label ? ` (${label})` : ""}. Next fire: ${next ? new Date(next).toLocaleString() : "now"}.`;
+        } catch (e) {
+          return `Error: ${e?.message ?? e}`;
+        }
+      }
+    },
+    {
+      name: "ScheduleList",
+      description: "List all scheduled jobs and their next fire time.",
+      parameters: { type: "object", properties: {} },
+      async run() {
+        const jobs = scheduler.list();
+        if (!jobs.length) return "(no scheduled jobs)";
+        return jobs.map((j) => {
+          const next = scheduler.nextFire(j);
+          const trig = "at" in j.trigger ? `once @ ${new Date(j.trigger.at).toLocaleString()}` : "everyMs" in j.trigger ? `every ${(j.trigger.everyMs / 1e3).toFixed(0)}s` : `cron: ${j.trigger.cron}`;
+          return `${j.id}  ${j.status}  ${trig}  runs:${j.runs}  next:${next ? new Date(next).toLocaleTimeString() : "\u2014"}${j.label ? "  " + j.label : ""}`;
+        }).join("\n");
+      }
+    },
+    {
+      name: "ScheduleCancel",
+      description: "Cancel a scheduled job by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return scheduler.cancel(String(id)) ? `Cancelled ${id}.` : `Error: no scheduled job '${id}'. Use ScheduleList to see jobs.`;
+      }
+    },
+    {
+      name: "Wakeup",
+      description: 'Self-pacing: schedule a one-off re-invocation of the agent after a delay.\nUse this to resume work later in the session (e.g. "check back in 5 minutes").\nThe prompt fires once, while the session is alive. Equivalent to ScheduleTask with {at: now + delayMs}.',
+      parameters: {
+        type: "object",
+        required: ["delayMs", "prompt"],
+        properties: {
+          delayMs: { type: "number", description: "Delay in milliseconds (minimum 5000)." },
+          prompt: { type: "string", description: "The prompt to inject when waking up." },
+          label: { type: "string" }
+        }
+      },
+      async run({ delayMs, prompt, label }) {
+        const delay = Math.max(5e3, Number(delayMs) || 5e3);
+        try {
+          const id = scheduler.add({ prompt, trigger: { at: Date.now() + delay }, label: label ?? "wakeup" });
+          return `Wakeup ${id} in ${(delay / 1e3).toFixed(0)}s.`;
+        } catch (e) {
+          return `Error: ${e?.message ?? e}`;
+        }
+      }
+    }
+  ];
+}
+
 // src/presets.ts
 init_tools();
 import { MemFilesystem } from "@livx.cc/wcli/core";
@@ -3771,7 +4023,7 @@ var DuplexAgentOptions = class {
   memoryUserDir;
 };
 var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
-var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, speak the USEFUL gist in one or two short sentences \u2014 the actual answer the user wanted (the headline finding, the key numbers), not the thinnest possible "it\'s done". A forecast \u2192 say it\'s calm AND that it\'s good for swimming but not surf; a count \u2192 say the number. Be brief, but do not drop the substance. If the result is a LIST (search results, multiple files/matches), the user CANNOT see it \u2014 there is no screen and no numbered menu to point at. Speak the gist: say what you found and name the top one or two by NAME (the source, not "the first one" or a number), then ask plainly if they want more. Never ask them to "pick which one" or reference items by position. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer arrives ONLY in the "[task \u2026 completed]" event; inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, just say "still on it" and end the turn \u2014 never poll it again and again in a loop. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nYou are NOT a knowledge base. For any question whose answer needs SPECIFIC verifiable facts you do not already have in hand \u2014 how to build/configure/implement something, exact API, library, entitlement, command or option names, current events, or particular numbers, dates, or names \u2014 do NOT answer from your own memory: you will confidently make things up (a fake API, a wrong entitlement, an event that did not happen). Route it to `Act`, which can search and verify, and speak only what its report says. Answer inline ONLY for general conversation, chit-chat, and trivia you are sure of, or facts you can see via QuickLook. When elaborating on a completed task ("tell me more", "the gist"), stay strictly within what that result actually said \u2014 if the user asks for something the result did not cover, that is NEW information: dispatch `Act`, do not improvise.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, speak the USEFUL gist in one or two short sentences \u2014 the actual answer the user wanted (the headline finding, the key numbers), not the thinnest possible "it\'s done". A forecast \u2192 say it\'s calm AND that it\'s good for swimming but not surf; a count \u2192 say the number. Be brief, but do not drop the substance. If the result is a LIST (search results, multiple files/matches), the user CANNOT see it \u2014 there is no screen and no numbered menu to point at. Speak the gist: say what you found and name the top one or two by NAME (the source, not "the first one" or a number), then ask plainly if they want more. Never ask them to "pick which one" or reference items by position. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer arrives ONLY in the "[task \u2026 completed]" event; inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo NOT end every turn with the same canned offer ("want a rundown?", "want the steps?"). Offer once at most; if the user pushes back, repeats themselves, or sounds unsatisfied ("you know what I mean?", "think deeper", "are you sure?"), do NOT re-offer the same thing \u2014 change approach: dispatch `Act`/`Think` to actually dig in, or ask one concrete clarifying question. Repeating a non-answer is worse than silence.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, just say "still on it" and end the turn \u2014 never poll it again and again in a loop. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
 var THINK_GUIDANCE = "\u2022 `Think` \u2014 your brain. A premium reasoning model, FAR more expensive than Act. Reserve it for open-ended architecture/design questions, or a problem Act already FAILED at. ALL implementation work \u2014 coding, refactoring, debugging, edge cases, tests \u2014 goes to Act; Act is highly capable. Never send the same work to both.";
 var THINK_DISABLED_GUIDANCE = "(Think tier is not available \u2014 use Act for all escalations.)";
 var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you escalate to Act or Think, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now act", no task ids out loud).`;
@@ -4412,7 +4664,7 @@ init_logging();
 init_logging();
 var log8 = forComponent("VoiceEngine");
 var now = () => performance.now();
-var forSpeech = (t) => t.replace(/[*_`#]+/g, "").replace(/^[ \t]*[-•]\s+/gm, "");
+var forSpeech = (t) => t.replace(/[*_`#]+/g, "").replace(/^[ \t]*[-•]\s+/gm, "").replace(/\s*[\u2013\u2014]\s*/g, ", ").replace(/[\u2010\u2011]/g, "-").replace(/\s*\|\s*/g, ", ").replace(/(\d)\s+%/g, "$1%").replace(/\.{3,}/g, ".");
 var VoiceEngineOptions = class {
   stt;
   tts;
@@ -5070,6 +5322,7 @@ var CartesiaTTS = class _CartesiaTTS {
   }
   speak(text, cont) {
     if (this.down) return;
+    if (cont && !text) return;
     if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(text, cont));
     else void this.ensureConnected().then(() => this.ws?.readyState === WebSocket.OPEN && this.ws.send(this.frame(text, cont)));
   }
@@ -7925,6 +8178,9 @@ var vis = (s) => needsBidi(s) ? bidiLine(s).visual : s;
 function displayText(s) {
   return s.replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/(?<![\w*])[*_]([^*_\s][^*_]*?)[*_](?![\w*])/g, "$1");
 }
+function plainLine(s) {
+  return displayText(s).replace(/^\s{0,3}#{1,6}\s+/, "").replace(/^(\s*)[-*+]\s+/, "$1");
+}
 function mdInline(line, p) {
   const re = /(`[^`]+`)|(\[[^\]]+\]\([^)]+\))|(\*\*[^*]+\*\*)|(~~[^~]+~~)|((?<![\w*])[*_][^*_\s][^*_]*?[*_](?![\w*]))/g;
   return line.replace(re, (_m, code, link2, bold2, strike2, italic2) => {
@@ -8976,9 +9232,37 @@ async function repl(args, ai, cfg, cwd) {
   if (args.voice && !args.duplex) agent.options.tools = [...agent.options.tools ?? [], exitSessionTool(() => {
     exitRequested = true;
   })];
+  const scheduleQueue = [];
+  let scheduleTurn;
+  const scheduler = new Scheduler({
+    fire: (job) => {
+      if (!activeTurn && scheduleTurn) {
+        err(dim(`  \u23F0 scheduled \u203A ${job.prompt.slice(0, 60)}${job.prompt.length > 60 ? "\u2026" : ""}
+`));
+        void scheduleTurn(job.prompt).then(() => editorRef?.redrawNow());
+      } else {
+        scheduleQueue.push(job.prompt);
+      }
+    },
+    tickMs: 15e3
+  });
+  agent.options.tools = [...agent.options.tools ?? [], ...makeScheduleTools(scheduler)];
   const duplex = args.duplex;
   let dx;
   let voiceIO;
+  let voiceLineOpen = false;
+  const voiceEcho = (text) => {
+    const s = forSpeech(text);
+    if (!s) return;
+    process.stdout.write(s);
+    voiceLineOpen = true;
+  };
+  const voiceEchoEnd = () => {
+    if (voiceLineOpen) {
+      process.stdout.write("\n");
+      voiceLineOpen = false;
+    }
+  };
   let toggleVoice;
   let editorRef;
   let repaintStash = () => {
@@ -9039,6 +9323,8 @@ async function repl(args, ai, cfg, cwd) {
         if (e.kind === "text_delta" && voiceIO) {
           voiceIO.speakDelta(e.message);
           editorRef?.suspend();
+          voiceEcho(e.message);
+          return;
         } else if (e.kind === "text_delta" && stashBuf) {
           process.stdout.write("\r\x1B[K");
           base.notify(e);
@@ -9050,8 +9336,11 @@ async function repl(args, ai, cfg, cwd) {
           return;
         }
         if (e.kind === "revoice_done") {
-          base.flushText();
-          process.stdout.write("\n");
+          if (voiceIO) voiceEchoEnd();
+          else {
+            base.flushText();
+            process.stdout.write("\n");
+          }
           voiceIO?.endSpeech();
           duplexPersist();
           editorRef?.resume();
@@ -9062,7 +9351,7 @@ async function repl(args, ai, cfg, cwd) {
           const lines = String(e.data.text).split("\n");
           const shown = lines.slice(0, previewLines());
           err("\r\x1B[0J\n" + dim(`  \u29BF ${e.message}
-`) + shown.map((l) => dim(`    ${l}
+`) + shown.map((l) => dim(`    ${plainLine(l)}
 `)).join(""));
           if (lines.length > shown.length) err(dim(`    \u2026 (+${lines.length - shown.length} more lines)
 `));
@@ -9276,6 +9565,11 @@ async function repl(args, ai, cfg, cwd) {
   installCancelGuards(mounted);
   const store = new SessionStore(cwd);
   let session = startSession(args, store, face, cwd);
+  if (session.meta.scheduledJobs?.length) {
+    scheduler.restore(session.meta.scheduledJobs);
+    err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
+`));
+  }
   const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join9(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) work.hooks = composeHooks(work.hooks, cpHooks);
@@ -9329,6 +9623,11 @@ async function repl(args, ai, cfg, cwd) {
     goalTurns = m.goalTurns ?? 0;
     goalTokens = m.goalTokens ?? 0;
     goalLastReason = m.goalLastReason;
+    if (m.scheduledJobs?.length) {
+      scheduler.restore(m.scheduledJobs);
+      err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
+`));
+    }
     err(dim(`  resumed ${data.meta.id} (${data.meta.turns} turns)${data.meta.title ? " \u2014 " + data.meta.title : ""}
 `));
     if (goalCondition) err(dim(`  \u25CE goal active: ${goalCondition} (${goalTurns} turns)
@@ -9403,7 +9702,7 @@ async function repl(args, ai, cfg, cwd) {
   const turn = async (task) => {
     const r = await runTurn(face, store, session, task, duplex ? void 0 : checkpoints, cwd, sendVia);
     if (voiceIO) {
-      process.stdout.write("\n");
+      voiceEchoEnd();
       editorRef?.resume();
     }
     voiceIO?.endSpeech();
@@ -9414,6 +9713,7 @@ async function repl(args, ai, cfg, cwd) {
     }
     return r;
   };
+  scheduleTurn = turn;
   const runSkill = async (sk, extra = "") => {
     try {
       const body = await fs.readFile(sk.path);
@@ -10298,9 +10598,13 @@ ${extra}` : body);
           editorRef?.redrawNow();
         }, 250);
       },
+      // voiceEchoEnd closes the open echo line; '\r\x1b[0J' wipes the stale prompt/footer before the
+      // notice — every other async-chrome writer does this, and without it "✋ interrupted" overprints
+      // the footer's leading chars (the "interrupted% ctx" glue).
       onBargeIn: (phase) => {
         activeTurn?.abort();
-        if (phase === "speaking") err(yellow("\n  \u270B interrupted\n"));
+        voiceEchoEnd();
+        if (phase === "speaking") err("\r\x1B[0J" + yellow("  \u270B interrupted\n"));
       },
       onUtterance: (text) => {
         voicePartial = "";
@@ -10386,6 +10690,7 @@ ${extra}` : body);
       if (r && r !== "off") parts.push(`reasoning:${r}`);
       if (verboseOutput) parts.push("verbose");
       if (goalCondition) parts.push(`\u25CE goal (${goalTurns} turns)`);
+      if (scheduler.size) parts.push(`\u23F0 ${scheduler.size} scheduled`);
       if (inputStash.length) parts.push(`${inputStash.length} stashed (\u2303S to pop)`);
       const taskLines = [];
       if (dx) {
@@ -10454,8 +10759,20 @@ ${extra}` : body);
 `));
       quit = await dispatchLine(next) === "quit";
     }
+    while (!quit && scheduleQueue.length) {
+      const prompt = scheduleQueue.shift();
+      err(dim(`  \u23F0 scheduled \u203A ${prompt.slice(0, 60)}${prompt.length > 60 ? "\u2026" : ""}
+`));
+      await turn(prompt);
+    }
+    session.meta.scheduledJobs = scheduler.snapshot();
+    try {
+      store.save(session);
+    } catch {
+    }
     if (quit) break;
   }
+  scheduler.destroy();
   voiceIO?.stop();
   if (dx) {
     const running = [...dx.tasks.values()].filter((t) => t.status === "running");