@jini-ai/daemon 0.3.8 → 0.5.1

package/dist/routines/routine-store.d.ts

@@ -23,22 +23,34 @@ export interface RoutineUpdateInput {
 /**
  * Storage-agnostic CRUD + read-only run-history port for routines. `@jini-ai/daemon` ships
  * {@link createInMemoryRoutineStore} as the reference implementation; a durable adapter
- * (`@jini-ai/sqlite`, future work) implements the same interface.
+ * (`@jini-ai/sqlite-chat`, future work) implements the same interface.
  */
 export interface RoutineStore {
     list(): Promise<readonly Routine[]>;
     /** Returns `null` when no routine with `id` exists — never throws for a missing id. */
-    get(id: string): Promise<Routine | null>;
+    get(args: {
+        readonly id: string;
+    }): Promise<Routine | null>;
     /** Assigns and returns the new routine's `id` — never supplied by the caller, matching `EventLog.append`'s cursor-assignment precedent. */
-    create(input: RoutineCreateInput): Promise<Routine>;
+    create(requiredArgs: Pick<RoutineCreateInput, "name" | "prompt" | "schedule" | "target">, optionalArgs?: Pick<RoutineCreateInput, "skillId" | "agentId" | "context" | "enabled">): Promise<Routine>;
     /** Applies a partial patch and returns the updated routine, or `null` if `id` does not exist. */
-    update(id: string, patch: RoutineUpdateInput): Promise<Routine | null>;
+    update(args: {
+        readonly id: string;
+        readonly patch: RoutineUpdateInput;
+    }): Promise<Routine | null>;
     /** Returns whether a routine with `id` existed (and was removed). */
-    delete(id: string): Promise<boolean>;
+    delete(args: {
+        readonly id: string;
+    }): Promise<boolean>;
     /** Returns up to `limit` runs for `routineId`, newest first. Returns `[]` for an unknown routine rather than throwing — mirrors `list()`'s empty-collection convention. */
-    listRuns(routineId: string, limit: number): Promise<readonly RoutineRun[]>;
+    listRuns(args: {
+        readonly routineId: string;
+        readonly limit: number;
+    }): Promise<readonly RoutineRun[]>;
     /** Returns the most recently started run for `routineId`, or `null` if none has ever run. */
-    getLatestRun(routineId: string): Promise<RoutineRun | null>;
+    getLatestRun(args: {
+        readonly routineId: string;
+    }): Promise<RoutineRun | null>;
 }
 /**
  * The display-shaped run summary OD's own `routineDbRowToContract` embedded on `Routine.lastRun`
@@ -47,7 +59,9 @@ export interface RoutineStore {
  * Kept as its own exported pure function (not inlined) so it is directly unit-testable, matching
  * this repo's "extract to a testable pure function" convention for awkward-to-cover branches.
  */
-export declare function summarizeLastRun(run: RoutineRun | null): Record<string, unknown> | null;
+export declare function summarizeLastRun({ run }: {
+    readonly run: RoutineRun | null;
+}): Record<string, unknown> | null;
 /**
  * `RoutineStore` plus two extra write hooks for run history that are deliberately NOT part of
  * the public {@link RoutineStore} contract (see this module's doc comment for why run-writing
@@ -59,19 +73,27 @@ export declare function summarizeLastRun(run: RoutineRun | null): Record<string,
  */
 export interface InMemoryRoutineStore extends RoutineStore {
     /** Records a run — mirrors `RoutinePersistence.insertRun`'s signature minus the scheduled-slot claim (this reference store has no concept of a "slot," only a flat run history), returning `false` if `run.id` was already recorded. */
-    recordRun(run: RoutineRun): boolean;
+    recordRun(args: {
+        readonly run: RoutineRun;
+    }): boolean;
     /** Patches a previously recorded run in place. A patch for an unknown `id` is a no-op, mirroring `RoutinePersistence.updateRun`'s own silent-no-op-on-unknown-id convention (see `./scheduler.js`'s `updateRun` call sites, none of which check a return value). */
-    patchRun(id: string, patch: Partial<RoutineRun>): void;
+    patchRun(args: {
+        readonly id: string;
+        readonly patch: Partial<RoutineRun>;
+    }): void;
 }
 /**
  * Reference `RoutineStore` implementation: an in-process `Map` of routines plus a flat array of
  * runs, no durable copy — matching `createInMemoryEventLog`'s own scope (a real persistent
- * adapter is `@jini-ai/sqlite`'s job).
+ * adapter is `@jini-ai/sqlite-chat`'s job).
  *
  * @complexity `get`/`create`/`update`/`delete` are O(1). `list` is O(n log n) (stable id-sort for
  * deterministic ordering). `listRuns`/`getLatestRun` are O(m log m) in the number of runs
  * recorded for the routine (m), since each sorts by `startedAt` descending on every call rather
  * than maintaining a secondary index — acceptable at this reference implementation's scale.
  */
-export declare function createInMemoryRoutineStore(): InMemoryRoutineStore;
+export declare function createInMemoryRoutineStore(_requiredArgs: Record<string, never>, { now, newId }?: {
+    now?: () => number;
+    newId?: () => string;
+}): InMemoryRoutineStore;
 //# sourceMappingURL=routine-store.d.ts.map

package/dist/routines/routine-store.js

@@ -4,13 +4,13 @@
  * comment is the explicit template named by the porting proposal,
  * `ADS-memory/reports/proposals/PROP-http-route-packs-automation-routines-2026-07-21.md`): a
  * storage-agnostic interface plus an in-memory reference implementation, async-only from day one
- * (extraction-plan §2.6) so a durable `@jini-ai/sqlite` adapter is a drop-in swap later without an
+ * (extraction-plan §2.6) so a durable `@jini-ai/sqlite-chat` adapter is a drop-in swap later without an
  * API break.
  *
  * No such port existed anywhere in this repo before this file — OD's own `routine.ts` route file
  * called eight raw `db.js` SQL functions directly (`getRoutine`/`insertRoutine`/`updateRoutine`/
  * `deleteRoutine`/`listRoutines`/`listRoutineRuns`/`getLatestRoutineRun`/`getRoutineRun`) against
- * `routines`/`routine_runs` tables that `packages/sqlite/source-map.md` already documents as
+ * `routines`/`routine_runs` tables that `packages/sqlite/archived provenance ledger` already documents as
  * explicitly out of scope for the db-barrel port. This is the missing design.
  *
  * **Deliberately separate from `./scheduler.js`'s `RoutinePersistence`, not a shared interface**,
@@ -21,7 +21,7 @@
  * mirrors that same split: `RoutineStore` owns Routine CRUD and *read-only* run history
  * (`listRuns`/`getLatestRun`); it does not write run records — that stays the scheduler's job via
  * its own separately-injected `RoutinePersistence`. A host wiring both together against one real
- * durable table (a future `@jini-ai/sqlite` adapter) is host-level integration wiring, the same way
+ * durable table (a future `@jini-ai/sqlite-chat` adapter) is host-level integration wiring, the same way
  * `runs.ts`'s `onStarted` driver is host-supplied rather than built into `RunLifecycle` itself —
  * not attempted here, out of this port's scope.
  */
@@ -33,7 +33,7 @@ import { randomUUID } from 'node:crypto';
  * Kept as its own exported pure function (not inlined) so it is directly unit-testable, matching
  * this repo's "extract to a testable pure function" convention for awkward-to-cover branches.
  */
-export function summarizeLastRun(run) {
+export function summarizeLastRun({ run }) {
     if (!run)
         return null;
     return {
@@ -70,14 +70,14 @@ function cloneRoutine(routine) {
 /**
  * Reference `RoutineStore` implementation: an in-process `Map` of routines plus a flat array of
  * runs, no durable copy — matching `createInMemoryEventLog`'s own scope (a real persistent
- * adapter is `@jini-ai/sqlite`'s job).
+ * adapter is `@jini-ai/sqlite-chat`'s job).
  *
  * @complexity `get`/`create`/`update`/`delete` are O(1). `list` is O(n log n) (stable id-sort for
  * deterministic ordering). `listRuns`/`getLatestRun` are O(m log m) in the number of runs
  * recorded for the routine (m), since each sorts by `startedAt` descending on every call rather
  * than maintaining a secondary index — acceptable at this reference implementation's scale.
  */
-export function createInMemoryRoutineStore() {
+export function createInMemoryRoutineStore(_requiredArgs, { now = Date.now, newId = randomUUID } = {}) {
     const routines = new Map();
     const runs = [];
     function runsFor(routineId) {
@@ -87,21 +87,22 @@ export function createInMemoryRoutineStore() {
     }
     async function withLastRun(routine) {
         const latest = runsFor(routine.id)[0] ?? null;
-        return { ...cloneRoutine(routine), lastRun: summarizeLastRun(latest) };
+        return { ...cloneRoutine(routine), lastRun: summarizeLastRun({ run: latest }) };
     }
     return {
         async list() {
             const ids = Array.from(routines.keys()).sort();
             return Promise.all(ids.map((id) => withLastRun(routines.get(id))));
         },
-        async get(id) {
+        async get({ id }) {
             const routine = routines.get(id);
             return routine ? withLastRun(routine) : null;
         },
-        async create(input) {
-            const now = Date.now();
+        async create(requiredArgs, optionalArgs = {}) {
+            const input = { ...requiredArgs, ...optionalArgs };
+            const createdAt = now();
             const routine = {
-                id: `routine-${randomUUID()}`,
+                id: `routine-${newId()}`,
                 name: input.name,
                 prompt: input.prompt,
                 schedule: input.schedule,
@@ -112,13 +113,13 @@ export function createInMemoryRoutineStore() {
                 enabled: input.enabled ?? true,
                 nextRunAt: null,
                 lastRun: null,
-                createdAt: now,
-                updatedAt: now,
+                createdAt: createdAt,
+                updatedAt: createdAt,
             };
             routines.set(routine.id, routine);
             return withLastRun(routine);
         },
-        async update(id, patch) {
+        async update({ id, patch }) {
             const existing = routines.get(id);
             if (!existing)
                 return null;
@@ -132,27 +133,27 @@ export function createInMemoryRoutineStore() {
                 ...(patch.agentId !== undefined ? { agentId: patch.agentId } : {}),
                 ...(patch.context !== undefined ? { context: patch.context } : {}),
                 ...(patch.enabled !== undefined ? { enabled: patch.enabled } : {}),
-                updatedAt: Date.now(),
+                updatedAt: now(),
             };
             routines.set(id, updated);
             return withLastRun(updated);
         },
-        async delete(id) {
+        async delete({ id }) {
             return routines.delete(id);
         },
-        async listRuns(routineId, limit) {
+        async listRuns({ routineId, limit }) {
             return runsFor(routineId).slice(0, limit);
         },
-        async getLatestRun(routineId) {
+        async getLatestRun({ routineId }) {
             return runsFor(routineId)[0] ?? null;
         },
-        recordRun(run) {
+        recordRun({ run }) {
             if (runs.some((existing) => existing.id === run.id))
                 return false;
             runs.push({ ...run });
             return true;
         },
-        patchRun(id, patch) {
+        patchRun({ id, patch }) {
             const run = runs.find((candidate) => candidate.id === id);
             if (run)
                 Object.assign(run, patch);

package/dist/routines/schedule.d.ts

@@ -18,7 +18,10 @@ import type { RoutineProjectTarget, RoutineSchedule, Weekday } from './types.js'
  * edge cases no timezone on this test runner's ICU data naturally triggers — directly testable
  * with a mocked `Intl.DateTimeFormat.prototype.formatToParts` instead of left unreachable.
  */
-export declare function partsInTimezone(timezone: string, atUtc: Date): {
+export declare function partsInTimezone({ timezone, atUtc }: {
+    readonly timezone: string;
+    readonly atUtc: Date;
+}): {
     year: number;
     month: number;
     day: number;
@@ -42,7 +45,14 @@ export declare function partsInTimezone(timezone: string, atUtc: Date): {
  * the unguarded `partsInTimezone` earlier in its own loop body, so an invalid timezone throws
  * there first — this function's defensive catch is otherwise unreachable through that call path.
  */
-export declare function tzWallToUtcCandidates(timezone: string, year: number, month: number, day: number, hour: number, minute: number): Date[];
+export declare function tzWallToUtcCandidates({ timezone, year, month, day, hour, minute }: {
+    readonly timezone: string;
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+}): Date[];
 /**
  * Spring-forward gap fallback: when the requested wall time doesn't exist in `timezone` on this
  * day (clocks jumped over it), return the later of the two probe candidates. That instant has
@@ -53,12 +63,40 @@ export declare function tzWallToUtcCandidates(timezone: string, year: number, mo
  * Exported for the same reason as {@link tzWallToUtcCandidates} — its own `catch` branch is
  * otherwise unreachable through {@link nextWallTimeMatching}'s call path.
  */
-export declare function tzWallToUtcGapFallback(timezone: string, year: number, month: number, day: number, hour: number, minute: number): Date | null;
-export declare function nextHourlyRunAt(minute: number, now?: Date): Date;
-export declare function nextWallTimeMatching(timezone: string, time: string, predicate: (weekday: Weekday) => boolean, now: Date): Date | null;
-export declare function nextRunAtForSchedule(schedule: RoutineSchedule, now?: Date): Date | null;
-export declare function isValidWallTime(time: string): boolean;
-export declare function isValidTimezone(tz: string): boolean;
-export declare function validateSchedule(schedule: RoutineSchedule): void;
-export declare function validateTarget(target: RoutineProjectTarget): void;
+export declare function tzWallToUtcGapFallback({ timezone, year, month, day, hour, minute }: {
+    readonly timezone: string;
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+}): Date | null;
+export declare function nextHourlyRunAt({ minute }: {
+    readonly minute: number;
+}, { now }?: {
+    readonly now?: Date;
+}): Date;
+export declare function nextWallTimeMatching({ timezone, time, predicate, now }: {
+    readonly timezone: string;
+    readonly time: string;
+    readonly predicate: (weekday: Weekday) => boolean;
+    readonly now: Date;
+}): Date | null;
+export declare function nextRunAtForSchedule({ schedule }: {
+    readonly schedule: RoutineSchedule;
+}, { now }?: {
+    readonly now?: Date;
+}): Date | null;
+export declare function isValidWallTime({ time }: {
+    readonly time: string;
+}): boolean;
+export declare function isValidTimezone({ tz }: {
+    readonly tz: string;
+}): boolean;
+export declare function validateSchedule({ schedule }: {
+    readonly schedule: RoutineSchedule;
+}): void;
+export declare function validateTarget({ target }: {
+    readonly target: RoutineProjectTarget;
+}): void;
 //# sourceMappingURL=schedule.d.ts.map

package/dist/routines/schedule.js

@@ -9,7 +9,7 @@
  * edge cases no timezone on this test runner's ICU data naturally triggers — directly testable
  * with a mocked `Intl.DateTimeFormat.prototype.formatToParts` instead of left unreachable.
  */
-export function partsInTimezone(timezone, atUtc) {
+export function partsInTimezone({ timezone, atUtc }) {
     const dtf = new Intl.DateTimeFormat('en-US', {
         timeZone: timezone,
         hour12: false,
@@ -62,7 +62,7 @@ export function partsInTimezone(timezone, atUtc) {
  * the unguarded `partsInTimezone` earlier in its own loop body, so an invalid timezone throws
  * there first — this function's defensive catch is otherwise unreachable through that call path.
  */
-export function tzWallToUtcCandidates(timezone, year, month, day, hour, minute) {
+export function tzWallToUtcCandidates({ timezone, year, month, day, hour, minute }) {
     try {
         const tentative = Date.UTC(year, month - 1, day, hour, minute, 0);
         const probeOffsetsMs = [-12, 0, 12].map((h) => h * 60 * 60_000);
@@ -95,7 +95,7 @@ export function tzWallToUtcCandidates(timezone, year, month, day, hour, minute)
  * Exported for the same reason as {@link tzWallToUtcCandidates} — its own `catch` branch is
  * otherwise unreachable through {@link nextWallTimeMatching}'s call path.
  */
-export function tzWallToUtcGapFallback(timezone, year, month, day, hour, minute) {
+export function tzWallToUtcGapFallback({ timezone, year, month, day, hour, minute }) {
     try {
         const tentative = Date.UTC(year, month - 1, day, hour, minute, 0);
         const t1 = tzOffsetMinutes(timezone, new Date(tentative));
@@ -109,17 +109,17 @@ export function tzWallToUtcGapFallback(timezone, year, month, day, hour, minute)
     }
 }
 function matchesWallClock(timezone, at, year, month, day, hour, minute) {
-    const p = partsInTimezone(timezone, at);
+    const p = partsInTimezone({ timezone: timezone, atUtc: at });
     return p.year === year && p.month === month && p.day === day && p.hour === hour && p.minute === minute;
 }
 /** Minutes east of UTC for `timezone` at instant `at`. e.g. Asia/Shanghai returns 480. */
 function tzOffsetMinutes(timezone, at) {
-    const p = partsInTimezone(timezone, at);
+    const p = partsInTimezone({ timezone: timezone, atUtc: at });
     const asIfUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
     return Math.round((asIfUtc - at.getTime()) / 60_000);
 }
 // ---------- next-fire calculation ----------
-export function nextHourlyRunAt(minute, now = new Date()) {
+export function nextHourlyRunAt({ minute }, { now = new Date() } = {}) {
     const next = new Date(now);
     next.setSeconds(0, 0);
     next.setMinutes(minute);
@@ -157,11 +157,11 @@ function parseWallTime(time) {
  * — see {@link nextWallTimeMatching} for when that actually happens.
  */
 function resolveDayFireInstant(timezone, date, hour, minute, now) {
-    const candidates = tzWallToUtcCandidates(timezone, date.year, date.month, date.day, hour, minute);
+    const candidates = tzWallToUtcCandidates({ timezone: timezone, year: date.year, month: date.month, day: date.day, hour: hour, minute: minute });
     if (candidates.length === 0) {
         // Spring-forward gap: no valid wall instant exists today; pick the synthesized post-gap
         // fallback so the routine still fires today.
-        const fallback = tzWallToUtcGapFallback(timezone, date.year, date.month, date.day, hour, minute);
+        const fallback = tzWallToUtcGapFallback({ timezone: timezone, year: date.year, month: date.month, day: date.day, hour: hour, minute: minute });
         if (!fallback)
             return { kind: 'abandon' };
         return fallback.getTime() > now.getTime() ? { kind: 'fire', at: fallback } : { kind: 'next-day' };
@@ -175,14 +175,14 @@ function resolveDayFireInstant(timezone, date, hour, minute, now) {
     }
     return { kind: 'next-day' };
 }
-export function nextWallTimeMatching(timezone, time, predicate, now) {
+export function nextWallTimeMatching({ timezone, time, predicate, now }) {
     const wall = parseWallTime(time);
     if (!wall)
         return null;
     // Walk day by day in the target timezone.
     for (let offset = 0; offset < 14; offset += 1) {
         const probe = new Date(now.getTime() + offset * 24 * 60 * 60_000);
-        const parts = partsInTimezone(timezone, probe);
+        const parts = partsInTimezone({ timezone: timezone, atUtc: probe });
         if (!predicate(parts.weekday))
             continue;
         const resolution = resolveDayFireInstant(timezone, parts, wall.hour, wall.minute, now);
@@ -202,24 +202,24 @@ export function nextWallTimeMatching(timezone, time, predicate, now) {
     }
     return null;
 }
-export function nextRunAtForSchedule(schedule, now = new Date()) {
+export function nextRunAtForSchedule({ schedule }, { now = new Date() } = {}) {
     if (schedule.kind === 'hourly') {
-        return nextHourlyRunAt(schedule.minute, now);
+        return nextHourlyRunAt({ minute: schedule.minute }, { now: now });
     }
     if (schedule.kind === 'daily') {
-        return nextWallTimeMatching(schedule.timezone, schedule.time, () => true, now);
+        return nextWallTimeMatching({ timezone: schedule.timezone, time: schedule.time, predicate: () => true, now: now });
     }
     if (schedule.kind === 'weekdays') {
         // Mon=1 .. Fri=5
-        return nextWallTimeMatching(schedule.timezone, schedule.time, (w) => w >= 1 && w <= 5, now);
+        return nextWallTimeMatching({ timezone: schedule.timezone, time: schedule.time, predicate: (w) => w >= 1 && w <= 5, now: now });
     }
     if (schedule.kind === 'weekly') {
-        return nextWallTimeMatching(schedule.timezone, schedule.time, (w) => w === schedule.weekday, now);
+        return nextWallTimeMatching({ timezone: schedule.timezone, time: schedule.time, predicate: (w) => w === schedule.weekday, now: now });
     }
     return null;
 }
 // ---------- validation ----------
-export function isValidWallTime(time) {
+export function isValidWallTime({ time }) {
     const m = /^(\d{2}):(\d{2})$/.exec(time);
     if (!m)
         return false;
@@ -227,7 +227,7 @@ export function isValidWallTime(time) {
     const mm = Number(m[2]);
     return h >= 0 && h <= 23 && mm >= 0 && mm <= 59;
 }
-export function isValidTimezone(tz) {
+export function isValidTimezone({ tz }) {
     if (!tz || typeof tz !== 'string')
         return false;
     try {
@@ -249,17 +249,17 @@ function validateWeekday(weekday) {
     }
 }
 function validateWallClockSchedule(schedule) {
-    if (!isValidWallTime(schedule.time)) {
+    if (!isValidWallTime({ time: schedule.time })) {
         throw new Error(`Invalid time: ${schedule.time}`);
     }
-    if (!isValidTimezone(schedule.timezone)) {
+    if (!isValidTimezone({ tz: schedule.timezone })) {
         throw new Error(`Invalid timezone: ${schedule.timezone}`);
     }
     if (schedule.kind === 'weekly') {
         validateWeekday(schedule.weekday);
     }
 }
-export function validateSchedule(schedule) {
+export function validateSchedule({ schedule }) {
     if (!schedule || typeof schedule !== 'object') {
         throw new Error('schedule is required');
     }
@@ -273,7 +273,7 @@ export function validateSchedule(schedule) {
     }
     throw new Error(`Unsupported schedule kind: ${schedule.kind}`);
 }
-export function validateTarget(target) {
+export function validateTarget({ target }) {
     if (!target || typeof target !== 'object') {
         throw new Error('target is required');
     }

package/dist/routines/scheduler.d.ts

@@ -9,26 +9,47 @@ export declare class ScheduledRunPersistenceError extends Error {
     readonly routineId: string;
     readonly slotAt: number;
     readonly originalError: unknown;
-    constructor(routineId: string, slotAt: number, originalError: unknown);
+    constructor({ routineId, slotAt, originalError }: {
+        readonly routineId: string;
+        readonly slotAt: number;
+        readonly originalError: unknown;
+    });
 }
 export declare class RoutineService {
-    private readonly persistence;
     private timers;
     private inflight;
     private runHandler;
     private started;
-    constructor(persistence: RoutinePersistence);
-    setRunHandler(handler: RoutineRunHandler): void;
-    start(): void;
-    stop(): void;
-    rescheduleAll(): void;
-    rescheduleOne(routineId: string): void;
-    unschedule(routineId: string): void;
+    private readonly persistence;
+    private readonly now;
+    private readonly newId;
+    constructor({ persistence }: {
+        readonly persistence: RoutinePersistence;
+    }, { now, newId }?: {
+        now?: () => number;
+        newId?: () => string;
+    });
+    setRunHandler({ handler }: {
+        readonly handler: RoutineRunHandler;
+    }): void;
+    start(_args: Record<string, never>): void;
+    stop(_args: Record<string, never>): void;
+    rescheduleAll(_args: Record<string, never>): void;
+    rescheduleOne({ routineId }: {
+        readonly routineId: string;
+    }): void;
+    unschedule({ routineId }: {
+        readonly routineId: string;
+    }): void;
     private scheduleRoutine;
     private retryScheduledSlot;
     private scheduleRoutineAt;
-    nextRunAt(routineId: string): Date | null;
-    runNow(routineId: string): Promise<RoutineRunHandlerStart>;
+    nextRunAt({ routineId }: {
+        readonly routineId: string;
+    }): Date | null;
+    runNow({ routineId }: {
+        readonly routineId: string;
+    }): Promise<RoutineRunHandlerStart>;
     /**
      * Wraps a persistence failure as a {@link ScheduledRunPersistenceError} when this attempt was a
      * scheduled fire, so the caller retries the same slot instead of advancing the cadence. Manual