catui-agent 1.0.0-beta.0

package/dist/extensions/builtin/loop/cron/cron-scheduler.d.ts

@@ -0,0 +1,85 @@
+/**
+ * [WHO]: createCronScheduler, CronScheduler, isRecurringTaskAged, buildMissedTaskNotification
+ * [FROM]: Depends on chokidar, ./cron-parser, ./cron-tasks, ./cron-tasks-lock
+ * [TO]: Consumed by loop/index
+ * [HERE]: extensions/builtin/loop/cron/cron-scheduler.ts - non-React scheduler core for scheduled_tasks.json
+ *
+ * Non-React scheduler core for .claude/scheduled_tasks.json.
+ *
+ * 1:1 port of Claude Code src/utils/cronScheduler.ts
+ *
+ * Lifecycle: poll scheduledTasksEnabled until true (flag flips when
+ * CronCreate runs) → load tasks + watch the file + start a 1s check
+ * timer → on fire, call onFire(prompt). stop() tears everything down.
+ */
+import { type CronJitterConfig, type CronTask } from "./cron-tasks.js";
+/**
+ * True when a recurring task was created more than `maxAgeMs` ago and should
+ * be deleted on its next fire. Permanent tasks never age. `maxAgeMs === 0`
+ * means unlimited (never ages out).
+ */
+export declare function isRecurringTaskAged(t: CronTask, nowMs: number, maxAgeMs: number): boolean;
+type CronSchedulerOptions = {
+    /** Called when a task fires (regular or missed-on-startup). */
+    onFire: (prompt: string) => void;
+    /** While true, firing is deferred to the next tick. */
+    isLoading: () => boolean;
+    /**
+     * When true, bypasses the isLoading gate in check() and auto-enables the
+     * scheduler without waiting for setScheduledTasksEnabled().
+     */
+    assistantMode?: boolean;
+    /**
+     * When provided, receives the full CronTask on normal fires (and onFire is
+     * NOT called for that fire). Lets callers see the task id/cron/etc
+     * instead of just the prompt string.
+     */
+    onFireTask?: (task: CronTask) => void;
+    /**
+     * When provided, receives the missed one-shot tasks on initial load (and
+     * onFire is NOT called with the pre-formatted notification).
+     */
+    onMissed?: (tasks: CronTask[]) => void;
+    /**
+     * Directory containing .claude/scheduled_tasks.json. Required for durable tasks.
+     */
+    dir?: string;
+    /**
+     * Owner key written into the lock file. Defaults to a generated UUID.
+     * PID remains the liveness probe regardless.
+     */
+    lockIdentity?: string;
+    /**
+     * Returns the cron jitter config to use for this tick. Called once per
+     * check() cycle.
+     */
+    getJitterConfig?: () => CronJitterConfig;
+    /**
+     * Killswitch: polled once per check() tick. When true, check() bails
+     * before firing anything.
+     */
+    isKilled?: () => boolean;
+    /**
+     * Per-task gate applied before any side effect. Tasks returning false are
+     * invisible to this scheduler.
+     */
+    filter?: (t: CronTask) => boolean;
+};
+export type CronScheduler = {
+    start: () => void;
+    stop: () => void;
+    /**
+     * Epoch ms of the soonest scheduled fire across all loaded tasks, or null
+     * if nothing is scheduled.
+     */
+    getNextFireTime: () => number | null;
+};
+/**
+ * Build the missed-task notification text. Guidance precedes the task list
+ * and the list is wrapped in a code fence so a multi-line imperative prompt
+ * is not interpreted as immediate instructions to avoid self-inflicted
+ * prompt injection.
+ */
+export declare function buildMissedTaskNotification(missed: CronTask[]): string;
+export declare function createCronScheduler(options: CronSchedulerOptions): CronScheduler;
+export {};

package/dist/extensions/builtin/loop/cron/cron-scheduler.js

@@ -0,0 +1,10 @@
+var H=Object.defineProperty;var p=(a,r)=>H(a,"name",{value:r,configurable:!0});import{cronToHuman as U}from"./cron-parser.js";import{DEFAULT_CRON_JITTER_CONFIG as V,findMissedTasks as q,getCronFilePath as z,hasCronTasksSync as G,jitteredNextCronRunMs as O,markCronTasksFired as Q,oneShotJitteredNextCronRunMs as W,readCronTasks as Y,removeCronTasks as D,getSessionCronTasks as X,removeSessionCronTasks as Z}from"./cron-tasks.js";import{releaseSchedulerLock as R,tryAcquireSchedulerLock as P}from"./cron-tasks-lock.js";const j=1e3,ee=300,ne=5e3;function te(a,r,k){return k===0?!1:!!(a.recurring&&!a.permanent&&r-a.createdAt>=k)}p(te,"isRecurringTaskAged");function ie(a){const r=a.length>1,k=`The following one-shot scheduled task${r?"s were":" was"} missed while Claude was not running. ${r?"They have":"It has"} already been removed from .claude/scheduled_tasks.json.
+
+Do NOT execute ${r?"these prompts":"this prompt"} yet. First use the AskUserQuestion tool to ask whether to run ${r?"each one":"it"} now. Only execute if the user confirms.`,C=a.map(m=>{const x=`[${U(m.cron)}, created ${new Date(m.createdAt).toLocaleString()}]`,t=(m.prompt.match(/`+/g)??[]).reduce(($,M)=>Math.max($,M.length),0),v="`".repeat(Math.max(3,t+1));return`${x}
+${v}
+${m.prompt}
+${v}`});return`${k}
+
+${C.join(`
+
+`)}`}p(ie,"buildMissedTaskNotification");function le(a){const{onFire:r,isLoading:k,assistantMode:C=!1,onFireTask:m,onMissed:x,dir:t,lockIdentity:v,getJitterConfig:$,isKilled:M,filter:A}=a,c=t||v?{dir:t,lockIdentity:v}:void 0;let _=[];const o=new Map,E=new Set,I=new Set;let f=null,w=null,d=null,T=null,u=!1,h=!1,F=!1;const y=v??`session-${process.pid}-${Date.now()}`;async function L(n){if(!t)return;const i=await Y(t);if(u||(_=i,!n))return;const g=Date.now(),l=q(i,g).filter(s=>!s.recurring&&!E.has(s.id)&&(!A||A(s)));if(l.length>0){for(const s of l)E.add(s.id),o.set(s.id,1/0);x?x(l):r(ie(l)),D(l.map(s=>s.id),t).catch(()=>{})}}p(L,"load");function B(){if(M?.()||k()&&!C)return;const n=Date.now(),i=new Set,g=[],l=$?.()??V;function s(e,b){if(A&&!A(e)||(i.add(e.id),I.has(e.id)))return;let S=o.get(e.id);if(S===void 0&&(S=e.recurring?O(e.cron,e.lastFiredAt??e.createdAt,e.id,l)??1/0:W(e.cron,e.createdAt,e.id,l)??1/0,o.set(e.id,S)),n<S)return;m?m(e):r(e.prompt);const J=te(e,n,l.recurringMaxAgeMs);if(e.recurring&&!J){const K=O(e.cron,n,e.id,l)??1/0;o.set(e.id,K),b||g.push(e.id)}else b?(Z([e.id]),o.delete(e.id)):(I.add(e.id),D([e.id],t).catch(()=>{}).finally(()=>I.delete(e.id)),o.delete(e.id))}if(p(s,"process"),h){for(const e of _)s(e,!1);if(g.length>0){for(const e of g)I.add(e);Q(g,n,t).catch(()=>{}).finally(()=>{for(const e of g)I.delete(e)})}}for(const e of X())s(e,!0);if(i.size===0){o.clear();return}for(const e of o.keys())i.has(e)||o.delete(e)}p(B,"check");async function N(){if(u)return;f&&(clearInterval(f),f=null);const{default:n}=await import("chokidar");if(!u){if(c&&(h=await P(c,y).catch(()=>!1)),u){h&&c&&(h=!1,R(c,y));return}if(!h&&c&&(d=setInterval(()=>{P(c,y).then(i=>{if(u){i&&R(c,y);return}i&&(h=!0,d&&(clearInterval(d),d=null))}).catch(()=>{})},ne),d?.unref?.()),L(!0),t){const i=z(t);T=n.watch(i,{persistent:!1,ignoreInitial:!0,awaitWriteFinish:{stabilityThreshold:ee},ignorePermissionErrors:!0}),T.on("add",()=>{L(!1)}),T.on("change",()=>{L(!1)}),T.on("unlink",()=>{u||(_=[],o.clear())})}w=setInterval(B,j),w?.unref?.()}}return p(N,"enable"),{start(){if(u=!1,t!==void 0){N();return}if(t&&!F&&(C||G(t))&&(F=!0),F){N();return}f=setInterval(n=>{F&&n()},j,N),f?.unref?.()},stop(){u=!0,f&&(clearInterval(f),f=null),w&&(clearInterval(w),w=null),d&&(clearInterval(d),d=null),T?.close(),T=null,h&&c&&(h=!1,R(c,y))},getNextFireTime(){let n=1/0;for(const i of o.values())i<n&&(n=i);return n===1/0?null:n}}}p(le,"createCronScheduler");export{ie as buildMissedTaskNotification,le as createCronScheduler,te as isRecurringTaskAged};

package/dist/extensions/builtin/loop/cron/cron-tasks-lock.d.ts

@@ -0,0 +1,42 @@
+/**
+ * [WHO]: SchedulerLockOptions, tryAcquireSchedulerLock, releaseSchedulerLock
+ * [FROM]: Depends on node:fs/promises, node:path
+ * [TO]: Consumed by ./cron-scheduler, ./index
+ * [HERE]: extensions/builtin/loop/cron/cron-tasks-lock.ts - scheduler lease lock for scheduled_tasks.json
+ *
+ * Scheduler lease lock for .claude/scheduled_tasks.json.
+ *
+ * 1:1 port of Claude Code src/utils/cronTasksLock.ts
+ *
+ * When multiple Claude sessions run in the same project directory, only one
+ * should drive the cron scheduler. The first session to acquire this lock
+ * becomes the scheduler; others stay passive and periodically probe the lock.
+ * If the owner dies (PID no longer running), a passive session takes over.
+ *
+ * Pattern mirrors computerUseLock.ts: O_EXCL atomic create, PID liveness
+ * probe, stale-lock recovery, cleanup-on-exit.
+ */
+/**
+ * Options for callers that don't have bootstrap state.
+ * lockIdentity should be stable for the lifetime of one process.
+ */
+export type SchedulerLockOptions = {
+    dir?: string;
+    lockIdentity?: string;
+};
+/**
+ * Try to acquire the scheduler lock for the current session.
+ * Returns true on success, false if another live session holds it.
+ *
+ * Uses O_EXCL ('wx') for atomic test-and-set. If the file exists:
+ *   - Already ours → true (idempotent re-acquire)
+ *   - Another live PID → false
+ *   - Stale (PID dead / corrupt) → unlink and retry exclusive create once
+ *
+ * If two sessions race to recover a stale lock, only one create succeeds.
+ */
+export declare function tryAcquireSchedulerLock(opts: SchedulerLockOptions, sessionId: string): Promise<boolean>;
+/**
+ * Release the scheduler lock if the current session owns it.
+ */
+export declare function releaseSchedulerLock(opts: SchedulerLockOptions, sessionId: string): Promise<void>;

package/dist/extensions/builtin/loop/cron/cron-tasks-lock.js

@@ -0,0 +1 @@
+var w=Object.defineProperty;var c=(t,r)=>w(t,"name",{value:r,configurable:!0});import{mkdir as h,readFile as k,unlink as f,writeFile as u}from"node:fs/promises";import{dirname as E,join as l}from"node:path";const g=l(".claude","scheduled_tasks.lock");let a;function s(t){return l(t,g)}c(s,"getLockPath");async function y(t){let r;try{r=await k(s(t),"utf8")}catch{return}try{const e=JSON.parse(r);return e&&typeof e=="object"&&typeof e.sessionId=="string"&&typeof e.pid=="number"&&typeof e.acquiredAt=="number"?e:void 0}catch{return}}c(y,"readLock");async function p(t,r){const e=s(r),i=JSON.stringify(t);try{return await u(e,i,{flag:"wx"}),!0}catch(n){const o=n.code;if(o==="EEXIST")return!1;if(o==="ENOENT"){await h(E(e),{recursive:!0});try{return await u(e,i,{flag:"wx"}),!0}catch(d){if(d.code==="EEXIST")return!1;throw d}}throw n}}c(p,"tryCreateExclusive");function m(t){try{return process.kill(t,0),!0}catch{return!1}}c(m,"isProcessRunning");async function S(t,r){const e=t.dir;if(!e)return!1;const i={sessionId:r,pid:process.pid,acquiredAt:Date.now()};if(await p(i,e))return a=void 0,!0;const n=await y(e);return n?.sessionId===r?(n.pid!==process.pid&&await u(s(e),JSON.stringify(i)),!0):n&&m(n.pid)?(a!==n.sessionId&&(a=n.sessionId),!1):(await f(s(e)).catch(()=>{}),await p(i,e)?(a=void 0,!0):!1)}c(S,"tryAcquireSchedulerLock");async function N(t,r){a=void 0;const e=t.dir;if(!e)return;const i=await y(e);if(!(!i||i.sessionId!==r))try{await f(s(e))}catch{}}c(N,"releaseSchedulerLock");export{N as releaseSchedulerLock,S as tryAcquireSchedulerLock};

package/dist/extensions/builtin/loop/cron/cron-tasks.d.ts

@@ -0,0 +1,200 @@
+/**
+ * [WHO]: CronTask, add/get/removeSessionCronTasks, getCronFilePath, scheduled-task storage primitives
+ * [FROM]: Depends on node:crypto, node:fs, node:fs/promises, node:path, ./cron-parser
+ * [TO]: Consumed by ./cron-scheduler, ./index
+ * [HERE]: extensions/builtin/loop/cron/cron-tasks.ts - scheduled-prompt storage in .claude/scheduled_tasks.json
+ *
+ * Scheduled prompts, stored in <project>/.claude/scheduled_tasks.json.
+ *
+ * 1:1 port of Claude Code src/utils/cronTasks.ts
+ *
+ * Tasks come in two flavors:
+ *   - One-shot (recurring: false/undefined) — fire once, then auto-delete.
+ *   - Recurring (recurring: true) — fire on schedule, reschedule from now,
+ *     persist until explicitly deleted via CronDelete or auto-expire after
+ *     a configurable limit (DEFAULT_CRON_JITTER_CONFIG.recurringMaxAgeMs).
+ *
+ * File format:
+ *   { "tasks": [{ id, cron, prompt, createdAt, recurring?, permanent? }] }
+ */
+export declare function addSessionCronTask(task: CronTask): void;
+export declare function getSessionCronTasks(): CronTask[];
+/**
+ * Remove session-only tasks by ID. Returns count of actually removed tasks.
+ */
+export declare function removeSessionCronTasks(ids: string[]): number;
+export type CronTask = {
+    id: string;
+    /** 5-field cron string (local time) — validated on write, re-validated on read. */
+    cron: string;
+    /** Prompt to enqueue when the task fires. */
+    prompt: string;
+    /** Epoch ms when the task was created. Anchor for missed-task detection. */
+    createdAt: number;
+    /**
+     * Epoch ms of the most recent fire. Written back by the scheduler after
+     * each recurring fire so next-fire computation survives process restarts.
+     * The scheduler anchors first-sight from `lastFiredAt ?? createdAt` — a
+     * never-fired task uses createdAt (correct for pinned crons like
+     * `30 14 27 2 *` whose next-from-now is next year); a fired-before task
+     * reconstructs the same `nextFireAt` the prior process had in memory.
+     * Never set for one-shots (they're deleted on fire).
+     */
+    lastFiredAt?: number;
+    /** When true, the task reschedules after firing instead of being deleted. */
+    recurring?: boolean;
+    /**
+     * When true, the task is exempt from recurringMaxAgeMs auto-expiry.
+     * System escape hatch for assistant mode's built-in tasks.
+     */
+    permanent?: boolean;
+    /**
+     * Runtime-only flag. false → session-scoped (never written to disk).
+     * File-backed tasks leave this undefined; writeCronTasks strips it so
+     * the on-disk shape stays { id, cron, prompt, createdAt, lastFiredAt?, recurring?, permanent? }.
+     */
+    durable?: boolean;
+    /**
+     * Runtime-only. When set, the task was created by an in-process teammate.
+     * The scheduler routes fires to that teammate's queue instead of the main
+     * REPL's. Never written to disk (teammate crons are always session-only).
+     */
+    agentId?: string;
+};
+/**
+ * Path to the cron file. `dir` must be provided explicitly.
+ */
+export declare function getCronFilePath(dir: string): string;
+/**
+ * Read and parse .claude/scheduled_tasks.json. Returns an empty task list if the file
+ * is missing, empty, or malformed. Tasks with invalid cron strings are
+ * silently dropped (logged at debug level) so a single bad entry never
+ * blocks the whole file.
+ */
+export declare function readCronTasks(dir: string): Promise<CronTask[]>;
+/**
+ * Sync check for whether the cron file has any valid tasks. Used by
+ * cronScheduler.start() to decide whether to auto-enable. One file read.
+ */
+export declare function hasCronTasksSync(dir: string): boolean;
+/**
+ * Overwrite .claude/scheduled_tasks.json with the given tasks. Creates .claude/ if
+ * missing. Empty task list writes an empty file (rather than deleting) so
+ * the file watcher sees a change event on last-task-removed.
+ */
+export declare function writeCronTasks(tasks: CronTask[], dir: string): Promise<void>;
+/**
+ * Append a task. Returns the generated id. Caller is responsible for having
+ * already validated the cron string (the tool does this via validateInput).
+ *
+ * When `durable` is false the task is held in process memory only
+ * (sessionTasks Map) — it fires on schedule this session but is never
+ * written to .claude/scheduled_tasks.json and dies with the process. The
+ * scheduler merges session tasks into its tick loop directly, so no file
+ * change event is needed.
+ */
+export declare function addCronTask(cron: string, prompt: string, recurring: boolean, durable: boolean, dir?: string, agentId?: string): Promise<string>;
+/**
+ * Remove tasks by id. No-op if none match (e.g. another session raced us).
+ * Used for both fire-once cleanup and explicit CronDelete.
+ *
+ * When called with `dir` undefined (REPL path), also sweeps the in-memory
+ * session store — the caller doesn't know which store an id lives in.
+ * Daemon callers pass `dir` explicitly; they have no session, and the
+ * `dir !== undefined` guard keeps this function from touching the session
+ * store on that path.
+ */
+export declare function removeCronTasks(ids: string[], dir?: string): Promise<void>;
+/**
+ * Stamp `lastFiredAt` on the given recurring tasks and write back. Batched
+ * so N fires in one scheduler tick = one read-modify-write, not N. Only
+ * touches file-backed tasks — session tasks die with the process, no point
+ * persisting their fire time.
+ */
+export declare function markCronTasksFired(ids: string[], firedAt: number, dir?: string): Promise<void>;
+/**
+ * File-backed tasks + session-only tasks, merged. Session tasks get
+ * `durable: false` so callers can distinguish them. File tasks are
+ * returned as-is (durable undefined → truthy).
+ *
+ * In Catui, always merges session tasks since the extension API
+ * always provides `dir` (no daemon/REPL distinction like CC).
+ */
+export declare function listAllCronTasks(dir?: string): Promise<CronTask[]>;
+/**
+ * Next fire time in epoch ms for a cron string, strictly after `fromMs`.
+ * Returns null if invalid or no match in the next 366 days.
+ */
+export declare function nextCronRunMs(cron: string, fromMs: number): number | null;
+/**
+ * Cron scheduler tuning knobs. Sourced at runtime from config so ops can
+ * adjust behavior fleet-wide without shipping a client build.
+ * Defaults here preserve the pre-config behavior exactly.
+ */
+export type CronJitterConfig = {
+    /** Recurring-task forward delay as a fraction of the interval between fires. */
+    recurringFrac: number;
+    /** Upper bound on recurring forward delay regardless of interval length. */
+    recurringCapMs: number;
+    /** One-shot backward lead: maximum ms a task may fire early. */
+    oneShotMaxMs: number;
+    /**
+     * One-shot backward lead: minimum ms a task fires early when the minute-mod
+     * gate matches. 0 = taskIds hashing near zero fire on the exact mark. Raise
+     * this to guarantee nobody lands on the wall-clock boundary.
+     */
+    oneShotFloorMs: number;
+    /**
+     * Jitter fires landing on minutes where `minute % N === 0`. 30 → :00/:30
+     * (the human-rounding hotspots). 15 → :00/:15/:30/:45. 1 → every minute.
+     */
+    oneShotMinuteMod: number;
+    /**
+     * Recurring tasks auto-expire this many ms after creation (unless marked
+     * `permanent`). The default (7 days) covers "check my PRs every hour this
+     * week" workflows while capping worst-case session lifetime.
+     *
+     * `0` = unlimited (tasks never auto-expire).
+     */
+    recurringMaxAgeMs: number;
+};
+export declare const DEFAULT_CRON_JITTER_CONFIG: CronJitterConfig;
+/**
+ * Same as {@link nextCronRunMs}, plus a deterministic per-task delay to
+ * avoid a thundering herd when many sessions schedule the same cron string
+ * (e.g. `0 * * * *` → everyone hits inference at :00).
+ *
+ * The delay is proportional to the current gap between fires
+ * ({@link CronJitterConfig.recurringFrac}, capped at
+ * {@link CronJitterConfig.recurringCapMs}) so at defaults an hourly task
+ * spreads across [:00, :06) but a per-minute task only spreads by a few
+ * seconds.
+ *
+ * Only used for recurring tasks. One-shot tasks use
+ * {@link oneShotJitteredNextCronRunMs} (backward jitter, minute-gated).
+ */
+export declare function jitteredNextCronRunMs(cron: string, fromMs: number, taskId: string, cfg?: CronJitterConfig): number | null;
+/**
+ * Same as {@link nextCronRunMs}, minus a deterministic per-task lead time
+ * when the fire time lands on a minute boundary matching
+ * {@link CronJitterConfig.oneShotMinuteMod}.
+ *
+ * One-shot tasks are user-pinned ("remind me at 3pm") so delaying them
+ * breaks the contract — but firing slightly early is invisible and spreads
+ * the inference spike from everyone picking the same round wall-clock time.
+ * At defaults (mod 30, max 90 s, floor 0) only :00 and :30 get jitter,
+ * because humans round to the half-hour.
+ *
+ * Checks the computed fire time rather than the cron string so
+ * `0 15 * * *`, step expressions, and `0,30 9 * * *` all get jitter
+ * when they land on a matching minute. Clamped to `fromMs` so a task created
+ * inside its own jitter window doesn't fire before it was created.
+ */
+export declare function oneShotJitteredNextCronRunMs(cron: string, fromMs: number, taskId: string, cfg?: CronJitterConfig): number | null;
+/**
+ * A task is "missed" when its next scheduled run (computed from createdAt)
+ * is in the past. Surfaced to the user at startup. Works for both one-shot
+ * and recurring tasks — a recurring task whose window passed while Claude
+ * was down is still "missed".
+ */
+export declare function findMissedTasks(tasks: CronTask[], nowMs: number): CronTask[];

package/dist/extensions/builtin/loop/cron/cron-tasks.js

@@ -0,0 +1,2 @@
+var w=Object.defineProperty;var a=(t,r)=>w(t,"name",{value:r,configurable:!0});import{randomUUID as M}from"node:crypto";import{readFileSync as S}from"node:fs";import{mkdir as g,writeFile as C}from"node:fs/promises";import{join as f}from"node:path";import{computeNextCronRun as F,parseCronExpression as x}from"./cron-parser.js";const l=new Map;function T(t){l.set(t.id,t)}a(T,"addSessionCronTask");function A(){return[...l.values()]}a(A,"getSessionCronTasks");function b(t){let r=0;for(const e of t)l.delete(e)&&r++;return r}a(b,"removeSessionCronTasks");const N=f(".claude","scheduled_tasks.json");function p(t){return f(t,N)}a(p,"getCronFilePath");async function u(t){let r;try{r=await import("node:fs/promises").then(e=>e.readFile(p(t),{encoding:"utf-8"}))}catch{return[]}try{const e=JSON.parse(r);if(!e||typeof e!="object")return[];const n=e;if(!Array.isArray(n.tasks))return[];const s=[];for(const o of n.tasks)!o||typeof o.id!="string"||typeof o.cron!="string"||typeof o.prompt!="string"||typeof o.createdAt!="number"||x(o.cron)&&s.push({id:o.id,cron:o.cron,prompt:o.prompt,createdAt:o.createdAt,...typeof o.lastFiredAt=="number"?{lastFiredAt:o.lastFiredAt}:{},...o.recurring?{recurring:!0}:{},...o.permanent?{permanent:!0}:{}});return s}catch{return[]}}a(u,"readCronTasks");function D(t){let r;try{r=S(p(t),"utf-8")}catch{return!1}try{const e=JSON.parse(r);if(!e||typeof e!="object")return!1;const n=e.tasks;return Array.isArray(n)&&n.length>0}catch{return!1}}a(D,"hasCronTasksSync");async function d(t,r){await g(f(r,".claude"),{recursive:!0});const e={tasks:t.map(({durable:n,...s})=>s)};await C(p(r),JSON.stringify(e,null,2)+`
+`,"utf-8")}a(d,"writeCronTasks");async function J(t,r,e,n,s,o){const i=M().slice(0,8),m={id:i,cron:t,prompt:r,createdAt:Date.now(),...e?{recurring:!0}:{}};if(!n)return T({...m,...o?{agentId:o}:{}}),i;if(!s)throw new Error("dir required for durable tasks");const h=await u(s);return h.push(m),await d(h,s),i}a(J,"addCronTask");async function I(t,r){if(t.length===0||b(t)===t.length||!r)return;const n=new Set(t),s=await u(r),o=s.filter(i=>!n.has(i.id));o.length!==s.length&&await d(o,r)}a(I,"removeCronTasks");async function L(t,r,e){if(t.length===0||!e)return;const n=new Set(t),s=await u(e);let o=!1;for(const i of s)n.has(i.id)&&(i.lastFiredAt=r,o=!0);o&&await d(s,e)}a(L,"markCronTasksFired");async function U(t){const r=t?await u(t):[],e=A().map(n=>({...n,durable:!1}));return[...r,...e]}a(U,"listAllCronTasks");function c(t,r){const e=x(t);if(!e)return null;const n=F(e,new Date(r));return n?n.getTime():null}a(c,"nextCronRunMs");const k={recurringFrac:.1,recurringCapMs:900*1e3,oneShotMaxMs:90*1e3,oneShotFloorMs:0,oneShotMinuteMod:30,recurringMaxAgeMs:10080*60*1e3};function y(t){const r=parseInt(t.slice(0,8),16)/4294967296;return Number.isFinite(r)?r:0}a(y,"jitterFrac");function q(t,r,e,n=k){const s=c(t,r);if(s===null)return null;const o=c(t,s);if(o===null)return s;const i=Math.min(y(e)*n.recurringFrac*(o-s),n.recurringCapMs);return s+i}a(q,"jitteredNextCronRunMs");function G(t,r,e,n=k){const s=c(t,r);if(s===null)return null;if(new Date(s).getMinutes()%n.oneShotMinuteMod!==0)return s;const o=n.oneShotFloorMs+y(e)*(n.oneShotMaxMs-n.oneShotFloorMs);return Math.max(s-o,r)}a(G,"oneShotJitteredNextCronRunMs");function P(t,r){return t.filter(e=>{const n=c(e.cron,e.createdAt);return n!==null&&n<r})}a(P,"findMissedTasks");export{k as DEFAULT_CRON_JITTER_CONFIG,J as addCronTask,T as addSessionCronTask,P as findMissedTasks,p as getCronFilePath,A as getSessionCronTasks,D as hasCronTasksSync,q as jitteredNextCronRunMs,U as listAllCronTasks,L as markCronTasksFired,c as nextCronRunMs,G as oneShotJitteredNextCronRunMs,u as readCronTasks,I as removeCronTasks,b as removeSessionCronTasks,d as writeCronTasks};

package/dist/extensions/builtin/loop/cron/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * [WHO]: cron module barrel
+ * [FROM]: Re-exports ./cron-parser, ./cron-tasks, ./cron-scheduler, ./cron-tasks-lock
+ * [TO]: Consumed by loop/index, loop/cron-tools
+ * [HERE]: extensions/builtin/loop/cron/index.ts - cron module barrel export
+ *
+ * Cron module exports: types, parser, task storage, scheduler, lock
+ *
+ * 1:1 port of Claude Code cron module public API
+ */
+export type { CronFields } from "./cron-parser.js";
+export { parseCronExpression, computeNextCronRun, cronToHuman, intervalToCron, } from "./cron-parser.js";
+export type { CronTask, CronJitterConfig } from "./cron-tasks.js";
+export { DEFAULT_CRON_JITTER_CONFIG, getCronFilePath, readCronTasks, writeCronTasks, hasCronTasksSync, addCronTask, removeCronTasks, markCronTasksFired, listAllCronTasks, nextCronRunMs, jitteredNextCronRunMs, oneShotJitteredNextCronRunMs, findMissedTasks, addSessionCronTask, getSessionCronTasks, removeSessionCronTasks, } from "./cron-tasks.js";
+export { createCronScheduler, isRecurringTaskAged, buildMissedTaskNotification } from "./cron-scheduler.js";
+export type { CronScheduler } from "./cron-scheduler.js";
+export { tryAcquireSchedulerLock, releaseSchedulerLock } from "./cron-tasks-lock.js";
+export type { SchedulerLockOptions } from "./cron-tasks-lock.js";

package/dist/extensions/builtin/loop/cron/index.js

@@ -0,0 +1 @@
+import{parseCronExpression as o,computeNextCronRun as s,cronToHuman as n,intervalToCron as a}from"./cron-parser.js";import{DEFAULT_CRON_JITTER_CONFIG as i,getCronFilePath as C,readCronTasks as T,writeCronTasks as d,hasCronTasksSync as k,addCronTask as c,removeCronTasks as u,markCronTasksFired as l,listAllCronTasks as m,nextCronRunMs as x,jitteredNextCronRunMs as S,oneShotJitteredNextCronRunMs as p,findMissedTasks as R,addSessionCronTask as f,getSessionCronTasks as h,removeSessionCronTasks as N}from"./cron-tasks.js";import{createCronScheduler as g,isRecurringTaskAged as A,buildMissedTaskNotification as F}from"./cron-scheduler.js";import{tryAcquireSchedulerLock as E,releaseSchedulerLock as L}from"./cron-tasks-lock.js";export{i as DEFAULT_CRON_JITTER_CONFIG,c as addCronTask,f as addSessionCronTask,F as buildMissedTaskNotification,s as computeNextCronRun,g as createCronScheduler,n as cronToHuman,R as findMissedTasks,C as getCronFilePath,h as getSessionCronTasks,k as hasCronTasksSync,a as intervalToCron,A as isRecurringTaskAged,S as jitteredNextCronRunMs,m as listAllCronTasks,l as markCronTasksFired,x as nextCronRunMs,p as oneShotJitteredNextCronRunMs,o as parseCronExpression,T as readCronTasks,L as releaseSchedulerLock,u as removeCronTasks,N as removeSessionCronTasks,E as tryAcquireSchedulerLock,d as writeCronTasks};

package/dist/extensions/builtin/loop/cron-tools/cron-create-tool.d.ts

@@ -0,0 +1,35 @@
+/**
+ * [WHO]: createCronCreateTool, CronCreateInput
+ * [FROM]: Depends on @sinclair/typebox, @catui/agent-core, core/extensions-host/types, ../cron, ./prompt
+ * [TO]: Consumed by ./index
+ * [HERE]: extensions/builtin/loop/cron-tools/cron-create-tool.ts - CronCreate tool factory
+ *
+ * CronCreate tool — creates a scheduled cron task.
+ *
+ * 1:1 port of Claude Code src/tools/ScheduleCronTool/CronCreateTool.ts
+ */
+import type { Static } from "@sinclair/typebox";
+import type { AgentToolResult } from "@catui/agent-core";
+import type { ExtensionContext } from "../../../../core/extensions-host/types.js";
+declare const cronCreateSchema: import("@sinclair/typebox").TObject<{
+    cron: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+    recurring: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    durable: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export type CronCreateInput = Static<typeof cronCreateSchema>;
+export declare function createCronCreateTool(): {
+    name: string;
+    label: string;
+    searchHint: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{
+        cron: import("@sinclair/typebox").TString;
+        prompt: import("@sinclair/typebox").TString;
+        recurring: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        durable: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    guidance: string;
+    execute(_toolCallId: string, params: CronCreateInput, _signal: AbortSignal | undefined, _onUpdate: undefined, ctx: ExtensionContext): Promise<AgentToolResult<unknown>>;
+};
+export {};

package/dist/extensions/builtin/loop/cron-tools/cron-create-tool.js

@@ -0,0 +1 @@
+var p=Object.defineProperty;var d=(a,e)=>p(a,"name",{value:e,configurable:!0});import{Type as r}from"@sinclair/typebox";import{addCronTask as f,cronToHuman as m,listAllCronTasks as x,nextCronRunMs as C,parseCronExpression as y}from"../cron/index.js";import{buildCronCreateDescription as g,buildCronCreatePrompt as _,CRON_CREATE_TOOL_NAME as b,DEFAULT_MAX_AGE_DAYS as u,isDurableCronEnabled as s}from"./prompt.js";const h=50,D=r.Object({cron:r.String({description:'Standard 5-field cron expression in local time: "M H DoM Mon DoW" (e.g. "*/5 * * * *" = every 5 minutes, "30 14 28 2 *" = Feb 28 at 2:30pm local once).'}),prompt:r.String({description:"The prompt to enqueue at each fire time."}),recurring:r.Optional(r.Boolean({description:`true (default) = fire on every cron match until deleted or auto-expired after ${u} days. false = fire once at the next match, then auto-delete. Use false for "remind me at X" one-shot requests with pinned minute/hour/dom/month.`,default:!0})),durable:r.Optional(r.Boolean({description:"true = persist to .claude/scheduled_tasks.json and survive restarts. false (default) = in-memory only, dies when this Claude session ends. Use true only when the user asks the task to survive across sessions.",default:!1}))});function v(){return{name:b,label:"Create Scheduled Task",searchHint:"schedule a recurring or one-shot prompt",description:g(s()),parameters:D,guidance:_(s()),async execute(a,e,k,S,i){if(!y(e.cron))return{content:[{type:"text",text:`Invalid cron expression '${e.cron}'. Expected 5 fields: M H DoM Mon DoW.`}],details:{error:"invalid_cron"}};if(C(e.cron,Date.now())===null)return{content:[{type:"text",text:`Cron expression '${e.cron}' does not match any calendar date in the next year.`}],details:{error:"no_match"}};if((await x(i.agentDir)).length>=h)return{content:[{type:"text",text:`Too many scheduled jobs (max ${h}). Cancel one first.`}],details:{error:"max_jobs"}};try{const t=!!e.durable&&s(),n=await f(e.cron,e.prompt,e.recurring??!0,t,i.agentDir),o=m(e.cron),c=e.recurring??!0,l=t?"Persisted to .claude/scheduled_tasks.json":"Session-only (not written to disk, dies when Claude exits)";return{content:[{type:"text",text:c?`Scheduled recurring job ${n} (${o}). ${l}. Auto-expires after ${u} days. Use CronDelete to cancel sooner.`:`Scheduled one-shot task ${n} (${o}). ${l}. It will fire once then auto-delete.`}],details:{id:n,humanSchedule:o,recurring:c,durable:t}}}catch(t){const n=t instanceof Error?t.message:String(t);return{content:[{type:"text",text:`Error: Failed to create scheduled task: ${n}`}],details:{error:n}}}}}}d(v,"createCronCreateTool");export{v as createCronCreateTool};

package/dist/extensions/builtin/loop/cron-tools/cron-delete-tool.d.ts

@@ -0,0 +1,29 @@
+/**
+ * [WHO]: createCronDeleteTool, CronDeleteInput
+ * [FROM]: Depends on @sinclair/typebox, @catui/agent-core, core/extensions-host/types, ../cron, ./prompt
+ * [TO]: Consumed by ./index
+ * [HERE]: extensions/builtin/loop/cron-tools/cron-delete-tool.ts - CronDelete tool factory
+ *
+ * CronDelete tool — deletes a scheduled cron task.
+ *
+ * 1:1 port of Claude Code src/tools/ScheduleCronTool/CronDeleteTool.ts
+ */
+import type { Static } from "@sinclair/typebox";
+import type { AgentToolResult } from "@catui/agent-core";
+import type { ExtensionContext } from "../../../../core/extensions-host/types.js";
+declare const cronDeleteSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+export type CronDeleteInput = Static<typeof cronDeleteSchema>;
+export declare function createCronDeleteTool(): {
+    name: string;
+    label: string;
+    searchHint: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+    }>;
+    guidance: string;
+    execute(_toolCallId: string, params: CronDeleteInput, _signal: AbortSignal | undefined, _onUpdate: undefined, ctx: ExtensionContext): Promise<AgentToolResult<unknown>>;
+};
+export {};

package/dist/extensions/builtin/loop/cron-tools/cron-delete-tool.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var i=(r,e)=>a(r,"name",{value:e,configurable:!0});import{Type as d}from"@sinclair/typebox";import{listAllCronTasks as s,removeCronTasks as l}from"../cron/index.js";import{buildCronDeletePrompt as c,CRON_DELETE_DESCRIPTION as u,CRON_DELETE_TOOL_NAME as C,isDurableCronEnabled as D}from"./prompt.js";const E=d.Object({id:d.String({description:"Job ID returned by CronCreate."})});function k(){return{name:C,label:"Delete Scheduled Task",searchHint:"cancel a scheduled cron job",description:u,parameters:E,guidance:c(D()),async execute(r,e,b,m,o){if(!(await s(o.agentDir)).find(t=>t.id===e.id))return{content:[{type:"text",text:`No scheduled job with id '${e.id}'`}],details:{error:"not_found"}};try{return await l([e.id],o.agentDir),{content:[{type:"text",text:`Cancelled job ${e.id}.`}],details:{id:e.id}}}catch(t){const n=t instanceof Error?t.message:String(t);return{content:[{type:"text",text:`Error: Failed to delete scheduled task: ${n}`}],details:{error:n}}}}}}i(k,"createCronDeleteTool");export{k as createCronDeleteTool};

package/dist/extensions/builtin/loop/cron-tools/cron-list-tool.d.ts

@@ -0,0 +1,25 @@
+/**
+ * [WHO]: createCronListTool, CronListInput
+ * [FROM]: Depends on @sinclair/typebox, @catui/agent-core, core/extensions-host/types, ../cron, ./prompt
+ * [TO]: Consumed by ./index
+ * [HERE]: extensions/builtin/loop/cron-tools/cron-list-tool.ts - CronList tool factory
+ *
+ * CronList tool — lists all scheduled cron tasks.
+ *
+ * 1:1 port of Claude Code src/tools/ScheduleCronTool/CronListTool.ts
+ */
+import type { Static } from "@sinclair/typebox";
+import type { AgentToolResult } from "@catui/agent-core";
+import type { ExtensionContext } from "../../../../core/extensions-host/types.js";
+declare const cronListSchema: import("@sinclair/typebox").TObject<{}>;
+export type CronListInput = Static<typeof cronListSchema>;
+export declare function createCronListTool(): {
+    name: string;
+    label: string;
+    searchHint: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{}>;
+    guidance: string;
+    execute(_toolCallId: string, _params: CronListInput, _signal: AbortSignal | undefined, _onUpdate: undefined, ctx: ExtensionContext): Promise<AgentToolResult<unknown>>;
+};
+export {};

package/dist/extensions/builtin/loop/cron-tools/cron-list-tool.js

@@ -0,0 +1,2 @@
+var c=Object.defineProperty;var s=(r,n)=>c(r,"name",{value:n,configurable:!0});import{Type as l}from"@sinclair/typebox";import{cronToHuman as u,listAllCronTasks as d}from"../cron/index.js";import{buildCronListPrompt as p,CRON_LIST_DESCRIPTION as m,CRON_LIST_TOOL_NAME as h,isDurableCronEnabled as b}from"./prompt.js";const g=l.Object({});function f(r,n,a){return r.length<=n?r:r.slice(0,n-1)+"\u2026"}s(f,"truncate");function L(){return{name:h,label:"List Scheduled Tasks",searchHint:"list active cron jobs",description:m,parameters:g,guidance:p(b()),async execute(r,n,a,T,i){try{const t=await d(i.agentDir);if(t.length===0)return{content:[{type:"text",text:"No scheduled jobs."}],details:{jobs:[]}};const o=t.map(e=>({id:e.id,cron:e.cron,humanSchedule:u(e.cron),prompt:e.prompt,...e.recurring?{recurring:!0}:{},...e.durable===!1?{durable:!1}:{}}));return{content:[{type:"text",text:o.map(e=>`${e.id} \u2014 ${e.humanSchedule}${e.recurring?" (recurring)":" (one-shot)"}${e.durable===!1?" [session-only]":""}: ${f(e.prompt,80,!0)}`).join(`
+`)}],details:{jobs:o}}}catch(t){const o=t instanceof Error?t.message:String(t);return{content:[{type:"text",text:`Error: Failed to list scheduled tasks: ${o}`}],details:{error:o}}}}}}s(L,"createCronListTool");export{L as createCronListTool};

package/dist/extensions/builtin/loop/cron-tools/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * [WHO]: cron-tools barrel: createCronCreateTool, createCronDeleteTool, createCronListTool
+ * [FROM]: Re-exports ./cron-create-tool, ./cron-delete-tool, ./cron-list-tool
+ * [TO]: Consumed by loop/index
+ * [HERE]: extensions/builtin/loop/cron-tools/index.ts - cron tool barrel export
+ *
+ * Cron tool exports: createCronCreateTool, createCronDeleteTool, createCronListTool
+ *
+ * 1:1 port matching CC tool registration pattern
+ */
+export { createCronCreateTool } from "./cron-create-tool.js";
+export { createCronDeleteTool } from "./cron-delete-tool.js";
+export { createCronListTool } from "./cron-list-tool.js";
+export type { CronCreateInput } from "./cron-create-tool.js";
+export type { CronDeleteInput } from "./cron-delete-tool.js";
+export type { CronListInput } from "./cron-list-tool.js";

package/dist/extensions/builtin/loop/cron-tools/index.js

@@ -0,0 +1 @@
+import{createCronCreateTool as r}from"./cron-create-tool.js";import{createCronDeleteTool as a}from"./cron-delete-tool.js";import{createCronListTool as C}from"./cron-list-tool.js";export{r as createCronCreateTool,a as createCronDeleteTool,C as createCronListTool};

package/dist/extensions/builtin/loop/cron-tools/prompt.d.ts

@@ -0,0 +1,35 @@
+/**
+ * [WHO]: CRON_*_TOOL_NAME constants, isKairosCronEnabled, isDurableCronEnabled, buildCronCreate/Delete/List descriptions and prompts
+ * [FROM]: No first-party dependencies
+ * [TO]: Consumed by ./cron-create-tool, ./cron-delete-tool, ./cron-list-tool, ../loop-skill
+ * [HERE]: extensions/builtin/loop/cron-tools/prompt.ts - cron tool prompts, names, and feature flags
+ *
+ * Cron tool prompts and constants.
+ *
+ * 1:1 port of Claude Code src/tools/ScheduleCronTool/prompt.ts
+ *
+ * Simplified: feature gates (GrowthBook, bun:bundle) replaced with
+ * constant true since Catui doesn't have those systems.
+ */
+export declare const DEFAULT_MAX_AGE_DAYS = 7;
+/**
+ * Unified gate for the cron scheduling system.
+ * In CC this combines build-time feature('AGENT_TRIGGERS') with runtime
+ * GrowthBook tengu_kairos_cron. In Catui, always enabled.
+ */
+export declare function isKairosCronEnabled(): boolean;
+/**
+ * Kill switch for disk-persistent (durable) cron tasks.
+ * In CC this consults GrowthBook tengu_kairos_cron_durable. In Catui,
+ * always enabled.
+ */
+export declare function isDurableCronEnabled(): boolean;
+export declare const CRON_CREATE_TOOL_NAME = "CronCreate";
+export declare const CRON_DELETE_TOOL_NAME = "CronDelete";
+export declare const CRON_LIST_TOOL_NAME = "CronList";
+export declare function buildCronCreateDescription(durableEnabled: boolean): string;
+export declare function buildCronCreatePrompt(durableEnabled: boolean): string;
+export declare const CRON_DELETE_DESCRIPTION = "Cancel a scheduled cron job by ID";
+export declare function buildCronDeletePrompt(durableEnabled: boolean): string;
+export declare const CRON_LIST_DESCRIPTION = "List scheduled cron jobs";
+export declare function buildCronListPrompt(durableEnabled: boolean): string;

package/dist/extensions/builtin/loop/cron-tools/prompt.js

@@ -0,0 +1,38 @@
+var r=Object.defineProperty;var t=(e,s)=>r(e,"name",{value:s,configurable:!0});const u=7;function l(){return!0}t(l,"isKairosCronEnabled");function d(){return!0}t(d,"isDurableCronEnabled");const o="CronCreate",n="CronDelete",h="CronList";function c(e){return e?"Schedule a prompt to run at a future time \u2014 either recurring on a cron schedule, or once at a specific time. Pass durable: true to persist to .claude/scheduled_tasks.json; otherwise session-only.":"Schedule a prompt to run at a future time within this Claude session \u2014 either recurring on a cron schedule, or once at a specific time."}t(c,"buildCronCreateDescription");function m(e){return`Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.
+
+Uses standard 5-field cron in the user's local timezone: minute hour day-of-month month day-of-week. "0 9 * * *" means 9am local \u2014 no timezone conversion needed.
+
+## One-shot tasks (recurring: false)
+
+For "remind me at X" or "at <time>, do Y" requests \u2014 fire once then auto-delete.
+Pin minute/hour/day-of-month/month to specific values:
+  "remind me at 2:30pm today to check the deploy" \u2192 cron: "30 14 <today_dom> <today_month> *", recurring: false
+  "tomorrow morning, run the smoke test" \u2192 cron: "57 8 <tomorrow_dom> <tomorrow_month> *", recurring: false
+
+## Recurring jobs (recurring: true, the default)
+
+For "every N minutes" / "every hour" / "weekdays at 9am" requests:
+  "*/5 * * * *" (every 5 min), "0 * * * *" (hourly), "0 9 * * 1-5" (weekdays at 9am local)
+
+## Avoid the :00 and :30 minute marks when the task allows it
+
+Every user who asks for "9am" gets \`0 9\`, and every user who asks for "hourly" gets \`0 *\` \u2014 which means requests from across the planet land on the API at the same instant. When the user's request is approximate, pick a minute that is NOT 0 or 30:
+  "every morning around 9" \u2192 "57 8 * * *" or "3 9 * * *" (not "0 9 * * *")
+  "hourly" \u2192 "7 * * * *" (not "0 * * * *")
+  "in an hour or so, remind me to..." \u2192 pick whatever minute you land on, don't round
+
+Only use minute 0 or 30 when the user names that exact time and clearly means it ("at 9:00 sharp", "at half past", coordinating with a meeting). When in doubt, nudge a few minutes early or late \u2014 the user will not notice, and the fleet will.
+
+${e?`## Durability
+
+By default (durable: false) the job lives only in this Claude session \u2014 nothing is written to disk, and the job is gone when Claude exits. Pass durable: true to write to .claude/scheduled_tasks.json so the job survives restarts. Only use durable: true when the user explicitly asks for the task to persist ("keep doing this every day", "set this up permanently"). Most "remind me in 5 minutes" / "check back in an hour" requests should stay session-only.`:`## Session-only
+
+Jobs live only in this Claude session \u2014 nothing is written to disk, and the job is gone when Claude exits.`}
+
+## Runtime behavior
+
+Jobs only fire while the REPL is idle (not mid-query). ${e?"Durable jobs persist to .claude/scheduled_tasks.json and survive session restarts \u2014 on next launch they resume automatically. One-shot durable tasks that were missed while the REPL was closed are surfaced for catch-up. Session-only jobs die with the process. ":""}The scheduler adds a small deterministic jitter on top of whatever you pick: recurring tasks fire up to 10% of their period late (max 15 min); one-shot tasks landing on :00 or :30 fire up to 90 s early. Picking an off-minute is still the bigger lever.
+
+Recurring tasks auto-expire after 7 days \u2014 they fire one final time, then are deleted. This bounds session lifetime. Tell the user about the 7-day limit when scheduling recurring jobs.
+
+Returns a job ID you can pass to ${n}.`}t(m,"buildCronCreatePrompt");const y="Cancel a scheduled cron job by ID";function p(e){return e?`Cancel a cron job previously scheduled with ${o}. Removes it from .claude/scheduled_tasks.json (durable jobs) or the in-memory session store (session-only jobs).`:`Cancel a cron job previously scheduled with ${o}. Removes it from the in-memory session store.`}t(p,"buildCronDeletePrompt");const b="List scheduled cron jobs";function f(e){return e?`List all cron jobs scheduled via ${o}, both durable (.claude/scheduled_tasks.json) and session-only.`:`List all cron jobs scheduled via ${o} in this session.`}t(f,"buildCronListPrompt");export{o as CRON_CREATE_TOOL_NAME,y as CRON_DELETE_DESCRIPTION,n as CRON_DELETE_TOOL_NAME,b as CRON_LIST_DESCRIPTION,h as CRON_LIST_TOOL_NAME,u as DEFAULT_MAX_AGE_DAYS,c as buildCronCreateDescription,m as buildCronCreatePrompt,p as buildCronDeletePrompt,f as buildCronListPrompt,d as isDurableCronEnabled,l as isKairosCronEnabled};

package/dist/extensions/builtin/loop/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * [WHO]: loop extension default export
+ * [FROM]: Depends on @catui/tui, core/extensions-host/types, ./cron/cron-scheduler, ./cron-tools, ./loop-skill
+ * [TO]: Auto-loaded by builtin-extensions.ts as a default extension
+ * [HERE]: extensions/builtin/loop/index.ts - extension entry; /loop command, CronCreate/Delete/List tools, scheduler wiring
+ *
+ * Loop extension — registers /loop command, CronCreate/Delete/List tools,
+ * and the unified cron scheduler.
+ *
+ * 1:1 port of Claude Code's cron/loop system:
+ * - /loop skill (src/skills/bundled/loop.ts) → registered as /loop command
+ * - CronCreate/Delete/List tools (src/tools/ScheduleCronTool/)
+ * - Cron scheduler (src/utils/cronScheduler.ts)
+ * - Cron task storage (src/utils/cronTasks.ts)
+ * - Cron parser (src/utils/cron.ts)
+ * - Scheduler lock (src/utils/cronTasksLock.ts)
+ */
+import type { ExtensionAPI } from "../../../core/extensions-host/types.js";
+export default function loopExtension(api: ExtensionAPI): Promise<void>;

package/dist/extensions/builtin/loop/index.js

@@ -0,0 +1,2 @@
+var w=Object.defineProperty;var r=(e,t)=>w(e,"name",{value:t,configurable:!0});import{Box as y,Text as T}from"@catui/tui";import{createCronScheduler as M}from"./cron/cron-scheduler.js";import{createCronCreateTool as v,createCronDeleteTool as x,createCronListTool as C}from"./cron-tools/index.js";import{buildLoopPrompt as h,getLoopUsageMessage as B}from"./loop-skill.js";const f="loop",u=new WeakMap,c=new WeakMap;function g(e,t,s="info"){e.sendMessage({customType:f,content:t,display:!0,details:{message:t,level:s,timestamp:Date.now()}})}r(g,"notify");async function U(e){const t=e.events;c.set(t,e),e.registerTool(v()),e.registerTool(x()),e.registerTool(C()),e.registerMessageRenderer(f,(o,n,i)=>{const p=typeof o.content=="string"?o.content:o.content.filter(l=>l.type==="text").map(l=>l.text).join(`
+`),d=typeof o.details=="object"&&o.details!==null&&"level"in o.details?o.details.level??"info":"info",m=d==="error"?"error":d==="warning"?"warning":"dim",a=new y(1,1,l=>i.bg("customMessageBg",l));return a.addChild(new T(i.fg(m,p),0,0)),a});const s=M({onFire:r(o=>{const n=c.get(t);n&&(n.sendUserMessage(o,{deliverAs:"followUp"}),g(n,`Fired scheduled task: ${o.slice(0,80)}`,"info"))},"onFire"),isLoading:r(()=>!e.isIdle(),"isLoading"),dir:e.agentDir});u.set(t,s),e.on("session_start",()=>{s.start()}),e.on("session_shutdown",()=>{s.stop(),u.delete(t),c.delete(t)}),e.registerCommand("loop",{description:"Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo, defaults to 10m)",handler:r(async o=>{const n=o.trim();if(!n){g(e,B(),"warning");return}const i=h(n);e.sendUserMessage(i,{deliverAs:"followUp"})},"handler")})}r(U,"loopExtension");export{U as default};