@kafca/agentdock 0.1.63 → 0.1.65

package/dist-electron/services/local-ai-core/src/scheduler/cron.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileCronExpression = compileCronExpression;
+exports.extractFieldsInTimezone = extractFieldsInTimezone;
+exports.cronMatchesFieldsDay = cronMatchesFieldsDay;
 exports.cronMatchesFields = cronMatchesFields;
 exports.cronMatchesDate = cronMatchesDate;
 exports.findNextCronMatchUtc = findNextCronMatchUtc;
 exports.findPreviousCronMatchUtc = findPreviousCronMatchUtc;
+exports.findNextCronMatchInTimezone = findNextCronMatchInTimezone;
+exports.findPreviousCronMatchInTimezone = findPreviousCronMatchInTimezone;
 exports.floorToMinute = floorToMinute;
+exports.isValidTimezone = isValidTimezone;
+exports.assertSupportedTimezone = assertSupportedTimezone;
 const DAY_MS = 24 * 60 * 60 * 1000;
 const GREGORIAN_CYCLE_DAYS = 146_097;
 const MIN_DATE_MS = -8_640_000_000_000_000;
@@ -25,6 +31,62 @@ function compileCronExpression(expression) {
         daysOfWeek: compileField(normalized, 'day-of-week', fields[4], 0, 6),
     });
 }
+function extractFieldsInTimezone(date, timezone) {
+    return stripYear(extractWallClock(date, timezone));
+}
+function extractWallClock(date, timezone) {
+    const parts = getFormatter(timezone).formatToParts(date);
+    const map = {};
+    for (const part of parts) {
+        if (part.type !== 'literal')
+            map[part.type] = part.value;
+    }
+    const weekday = String(map.weekday ?? '').toLowerCase();
+    const dayOfWeek = WEEKDAY_SHORT_TO_NUMBER[weekday];
+    return {
+        year: Number(map.year ?? '1970'),
+        minute: Number(map.minute ?? '0'),
+        hour: Number(map.hour ?? '0'),
+        dayOfMonth: Number(map.day ?? '1'),
+        month: Number(map.month ?? '1'),
+        dayOfWeek: dayOfWeek ?? 0,
+    };
+}
+function stripYear(fields) {
+    return {
+        minute: fields.minute,
+        hour: fields.hour,
+        dayOfMonth: fields.dayOfMonth,
+        month: fields.month,
+        dayOfWeek: fields.dayOfWeek,
+    };
+}
+// Convert a wall-clock time (Y/M/D h:m) in `timezone` to the matching UTC instant.
+// Returns null when that wall clock never exists on that day (DST spring-forward gap),
+// so callers can treat the slot as non-matching.
+function wallClockToUtc(year, month, dayOfMonth, hour, minute, timezone) {
+    const targetWallMs = Date.UTC(year, month - 1, dayOfMonth, hour, minute, 0, 0);
+    let utc = targetWallMs;
+    for (let i = 0; i < 5; i += 1) {
+        const f = extractWallClock(new Date(utc), timezone);
+        const wallAsUtc = Date.UTC(f.year, f.month - 1, f.dayOfMonth, f.hour, f.minute, 0, 0);
+        if (wallAsUtc === targetWallMs) {
+            // Round-trip verified — this instant really is the requested wall clock in `timezone`.
+            return utc;
+        }
+        // Fixed-point step: shift utc by the gap between where its wall clock lands and the target.
+        utc = utc - wallAsUtc + targetWallMs;
+    }
+    // Did not converge to a self-consistent wall clock: the requested time is in a DST gap.
+    return null;
+}
+// Day-level match: day-of-month AND month AND day-of-week (cron DOM+DOW AND semantics).
+// Hour and minute are matched separately once a wall-clock day qualifies.
+function cronMatchesFieldsDay(compiled, fields) {
+    return compiled.daysOfMonth.includes(fields.dayOfMonth)
+        && compiled.months.includes(fields.month)
+        && compiled.daysOfWeek.includes(fields.dayOfWeek);
+}
 function cronMatchesFields(compiled, fields) {
     // Preserve the legacy scheduler's DOM+DOW AND behavior.
     return compiled.minutes.includes(fields.minute)
@@ -107,6 +169,84 @@ function findPreviousCronMatchUtc(compiled, atOrBefore, afterExclusive) {
     }
     return { date: null, inspectedDays: GREGORIAN_CYCLE_DAYS + 1 };
 }
+// Timezone-aware variants: iterate in the target timezone's wall clock rather than UTC.
+// These replace the UTC-only search used by the activation engine when timezone !== 'UTC'.
+function findNextCronMatchInTimezone(compiled, after, timezone) {
+    assertSupportedTimezone(timezone);
+    const afterMs = validDateMs(after, 'cron search date');
+    const startFields = extractWallClock(after, timezone);
+    // Begin at the start of the current wall-clock day so a later match on the same day is found.
+    const startDay = wallClockToUtc(startFields.year, startFields.month, startFields.dayOfMonth, 0, 0, timezone);
+    let dayMs = startDay ?? startOfUtcDay(Date.UTC(startFields.year, startFields.month - 1, startFields.dayOfMonth, 0, 0, 0, 0));
+    for (let inspectedDays = 1; inspectedDays <= GREGORIAN_CYCLE_DAYS + 1; inspectedDays += 1) {
+        if (dayMs > MAX_DATE_MS)
+            return { date: null, inspectedDays };
+        const dayFields = extractWallClock(new Date(dayMs), timezone);
+        if (cronMatchesFieldsDay(compiled, stripYear(dayFields))) {
+            for (const hour of compiled.hours) {
+                for (const minute of compiled.minutes) {
+                    const candidateMs = wallClockToUtc(dayFields.year, dayFields.month, dayFields.dayOfMonth, hour, minute, timezone);
+                    if (candidateMs !== null && candidateMs > afterMs && candidateMs <= MAX_DATE_MS) {
+                        return { date: new Date(candidateMs), inspectedDays };
+                    }
+                }
+            }
+        }
+        const nextDay = wallClockToUtc(dayFields.year, dayFields.month, dayFields.dayOfMonth + 1, 0, 0, timezone);
+        // A null here only means the next wall-clock midnight is in a DST gap (a handful of
+        // zones transition at midnight). Fall back to 24 h later — the loop extracts the wall-clock
+        // day from dayMs itself, so a one-day-probe offset cannot drop or duplicate a match.
+        if (nextDay === null) {
+            dayMs += DAY_MS;
+        }
+        else {
+            dayMs = nextDay;
+        }
+    }
+    return { date: null, inspectedDays: GREGORIAN_CYCLE_DAYS + 1 };
+}
+function findPreviousCronMatchInTimezone(compiled, atOrBefore, timezone, afterExclusive) {
+    assertSupportedTimezone(timezone);
+    const atOrBeforeMs = validDateMs(atOrBefore, 'cron search date');
+    const afterExclusiveMs = afterExclusive ? validDateMs(afterExclusive, 'cron search lower bound') : undefined;
+    if (afterExclusiveMs !== undefined && afterExclusiveMs >= atOrBeforeMs) {
+        return { date: null, inspectedDays: 0 };
+    }
+    const upperFields = extractWallClock(atOrBefore, timezone);
+    const upperDay = wallClockToUtc(upperFields.year, upperFields.month, upperFields.dayOfMonth, 0, 0, timezone);
+    let dayMs = upperDay ?? startOfUtcDay(Date.UTC(upperFields.year, upperFields.month - 1, upperFields.dayOfMonth, 0, 0, 0, 0));
+    for (let inspectedDays = 1; inspectedDays <= GREGORIAN_CYCLE_DAYS + 1; inspectedDays += 1) {
+        if (dayMs < MIN_DATE_MS)
+            return { date: null, inspectedDays };
+        if (afterExclusiveMs !== undefined && dayMs <= afterExclusiveMs) {
+            return { date: null, inspectedDays: inspectedDays - 1 };
+        }
+        const dayFields = extractWallClock(new Date(dayMs), timezone);
+        if (cronMatchesFieldsDay(compiled, stripYear(dayFields))) {
+            for (let hourIndex = compiled.hours.length - 1; hourIndex >= 0; hourIndex -= 1) {
+                for (let minuteIndex = compiled.minutes.length - 1; minuteIndex >= 0; minuteIndex -= 1) {
+                    const candidateMs = wallClockToUtc(dayFields.year, dayFields.month, dayFields.dayOfMonth, compiled.hours[hourIndex], compiled.minutes[minuteIndex], timezone);
+                    if (candidateMs !== null
+                        && candidateMs <= atOrBeforeMs
+                        && candidateMs >= MIN_DATE_MS
+                        && (afterExclusiveMs === undefined || candidateMs > afterExclusiveMs)) {
+                        return { date: new Date(candidateMs), inspectedDays };
+                    }
+                }
+            }
+        }
+        const prevDay = wallClockToUtc(dayFields.year, dayFields.month, dayFields.dayOfMonth - 1, 0, 0, timezone);
+        // See findNextCronMatchInTimezone: a null only marks a DST-at-midnight quirk, not the end
+        // of schedulable time. Step back 24 h and let the loop read the wall-clock day from dayMs.
+        if (prevDay === null) {
+            dayMs -= DAY_MS;
+        }
+        else {
+            dayMs = prevDay;
+        }
+    }
+    return { date: null, inspectedDays: GREGORIAN_CYCLE_DAYS + 1 };
+}
 function floorToMinute(date) {
     return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), 0, 0);
 }
@@ -163,3 +303,60 @@ function validDateMs(date, label) {
 function invalidCron(expression, reason) {
     return new Error(`Invalid cron expression "${expression}": ${reason}.`);
 }
+const WEEKDAY_SHORT_TO_NUMBER = {
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6,
+};
+// formatToParts is dramatically faster when the formatter is reused; cache one per zone.
+const formatterCache = new Map();
+function getFormatter(timezone) {
+    const cached = formatterCache.get(timezone);
+    if (cached)
+        return cached;
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        hourCycle: 'h23',
+        minute: '2-digit',
+        hour: '2-digit',
+        day: '2-digit',
+        month: '2-digit',
+        weekday: 'short',
+        year: 'numeric',
+    });
+    formatterCache.set(timezone, formatter);
+    return formatter;
+}
+// Intl.supportedValuesOf('timeZone') builds a full IANA list on first call; cache it per runtime.
+let supportedTimezones = null;
+function getSupportedTimezones() {
+    if (supportedTimezones)
+        return supportedTimezones;
+    supportedTimezones = Intl.supportedValuesOf ? new Set(Intl.supportedValuesOf('timeZone')) : null;
+    return supportedTimezones;
+}
+function isValidTimezone(timezone) {
+    // "UTC"/"Z" are valid cron timezones but may be missing from Intl's list (which uses "Etc/UTC").
+    if (timezone === 'UTC' || timezone === 'Z' || timezone === 'Etc/UTC')
+        return true;
+    const supported = getSupportedTimezones();
+    if (supported)
+        return supported.has(timezone);
+    // Fallback for old runtimes: let the formatter constructor throw on bad zones.
+    try {
+        Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertSupportedTimezone(timezone) {
+    if (!isValidTimezone(timezone)) {
+        throw new Error(`Automation scheduling received an unsupported timezone: ${timezone}`);
+    }
+}

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-job-application-service.js

@@ -10,9 +10,10 @@ class ScheduledJobApplicationService {
         this.options = options;
     }
     listJobs(workspaceId) {
-        return this.options.automations.list(workspaceId)
-            .filter((automation) => automation.originKind === 'scheduled-job')
-            .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(this.options.automations.listRuns(automation.id))));
+        const latestRunById = this.options.automations.listLatestRunByOrigin('scheduled-job', workspaceId);
+        return this.options.automations
+            .list(workspaceId, 'scheduled-job')
+            .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, latestRunById.get(automation.id)));
     }
     getJob(jobId) {
         const resolved = this.resolveJobId(jobId);

package/dist-electron/services/local-ai-core/src/scheduler/scheduler-service.js

@@ -41,9 +41,9 @@ class SchedulerService extends node_events_1.EventEmitter {
     listJobs(workspaceId) {
         const automations = this.options.automations;
         if (automations) {
-            return automations.list(workspaceId)
-                .filter((automation) => automation.originKind === 'scheduled-job')
-                .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, (0, legacy_automation_mappers_js_1.latestAutomationRun)(automations.listRuns(automation.id))));
+            const latestRunById = automations.listLatestRunByOrigin('scheduled-job', workspaceId);
+            return automations.list(workspaceId, 'scheduled-job')
+                .map((automation) => (0, legacy_automation_mappers_js_1.automationToScheduledJob)(automation, latestRunById.get(automation.id)));
         }
         return this.options.store.listScheduledJobs(workspaceId);
     }

package/dist-electron/tests/electron/automation-compatibility.test.js

@@ -53,7 +53,12 @@ function fixture(executeAction, conditionEvaluator) {
         description: 'Daily report',
         enabled: true,
     });
-    strict_1.default.deepEqual(input.activation, { kind: 'cron', expression: '0 9 * * *', timezone: 'UTC' });
+    // Legacy cron jobs default to the host's local IANA timezone (matches the old
+    // SchedulerService, which matched cron in local wall clock). Any valid IANA zone is correct.
+    strict_1.default.equal(input.activation.kind, 'cron');
+    strict_1.default.equal(input.activation.expression, '0 9 * * *');
+    strict_1.default.equal(typeof input.activation.timezone, 'string');
+    strict_1.default.ok(input.activation.timezone.length > 0, 'timezone should be a non-empty IANA zone');
     strict_1.default.deepEqual(input.condition, { kind: 'always' });
     strict_1.default.equal(input.originKind, 'scheduled-job');
     strict_1.default.equal(input.action.executionMode, 'same-thread');

package/dist-electron/tests/electron/automation-engine.test.js

@@ -62,8 +62,13 @@ const at = (value) => new Date(value);
     strict_1.default.equal((0, automation_trigger_engine_js_1.isActivationDue)(activation, now, '2026-07-05T09:00:00.000Z'), false);
     strict_1.default.equal((0, automation_trigger_engine_js_1.missedActivationAt)(activation, undefined, now), null);
 });
-(0, node_test_1.default)('cron timezone limitations are explicit', () => {
-    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 9 * * *', timezone: 'Asia/Shanghai' }, at('2026-07-05T00:00:00.000Z')), /only UTC cron timezones/i);
+(0, node_test_1.default)('cron now supports IANA timezones beyond UTC', () => {
+    // Shanghai is UTC+8 with no DST: next match of "0 1 * * *" after 2026-07-15T00:00Z
+    // (08:00 CST) should be 2026-07-16 01:00 CST = 2026-07-15T17:00Z.
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 1 * * *', timezone: 'Asia/Shanghai' }, at('2026-07-15T00:00:00.000Z'))?.toISOString(), '2026-07-15T17:00:00.000Z');
+});
+(0, node_test_1.default)('cron rejects unknown timezones', () => {
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 9 * * *', timezone: 'Not/AZone' }, at('2026-07-05T00:00:00.000Z')), /unsupported timezone/i);
 });
 (0, node_test_1.default)('cron compilation is strict and all activation entry points reject invalid expressions', () => {
     const invalidExpressions = [
@@ -129,7 +134,66 @@ const at = (value) => new Date(value);
 });
 (0, node_test_1.default)('cron search does not return dates outside the JavaScript Date range', () => {
     const activation = { kind: 'cron', expression: '* * * * *', timezone: 'UTC' };
-    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)(activation, new Date(8_640_000_000_000_000)), /no UTC cron activation exists/i);
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)(activation, new Date(8_640_000_000_000_000)), /no cron activation exists/i);
+});
+(0, node_test_1.default)('timezone-aware cron next match honors the target zone', () => {
+    // 0 1 * * * in Asia/Shanghai (UTC+8) after 2026-07-15T00:00Z (08:00 CST) → next 01:00 CST.
+    strict_1.default.equal((0, cron_js_1.findNextCronMatchInTimezone)((0, cron_js_1.compileCronExpression)('0 1 * * *'), at('2026-07-15T00:00:00.000Z'), 'Asia/Shanghai').date?.toISOString(), '2026-07-15T17:00:00.000Z');
+});
+(0, node_test_1.default)('timezone-aware cron next match lands later when the target-zone hour has already passed', () => {
+    // After 2026-07-15T18:00Z, Shanghai wall clock is 2026-07-16 02:00. Next 01:00 CST is a day later.
+    strict_1.default.equal((0, cron_js_1.findNextCronMatchInTimezone)((0, cron_js_1.compileCronExpression)('0 1 * * *'), at('2026-07-15T18:00:00.000Z'), 'Asia/Shanghai').date?.toISOString(), '2026-07-16T17:00:00.000Z');
+});
+(0, node_test_1.default)('timezone-aware previous match finds the most recent wall-clock hit', () => {
+    // At 2026-07-15T05:00Z (13:00 CST), previous 01:00 CST is 2026-07-14T17:00Z.
+    strict_1.default.equal((0, cron_js_1.findPreviousCronMatchInTimezone)((0, cron_js_1.compileCronExpression)('0 1 * * *'), at('2026-07-15T05:00:00.000Z'), 'Asia/Shanghai').date?.toISOString(), '2026-07-14T17:00:00.000Z');
+});
+(0, node_test_1.default)('extractFieldsInTimezone reads wall clock in the given zone', () => {
+    // 2026-07-15T09:00Z = 2026-07-15 17:00 CST = a Wednesday (dayOfWeek 3).
+    const fields = (0, cron_js_1.extractFieldsInTimezone)(at('2026-07-15T09:00:00.000Z'), 'Asia/Shanghai');
+    strict_1.default.equal(fields.hour, 17);
+    strict_1.default.equal(fields.minute, 0);
+    strict_1.default.equal(fields.dayOfMonth, 15);
+    strict_1.default.equal(fields.month, 7);
+    strict_1.default.equal(fields.dayOfWeek, 3);
+});
+(0, node_test_1.default)('extractFieldsInTimezone accounts for DST (America/New_York)', () => {
+    // 2026-07-15 is in EDT (UTC-4): 09:00Z = 05:00 local.
+    const fields = (0, cron_js_1.extractFieldsInTimezone)(at('2026-07-15T09:00:00.000Z'), 'America/New_York');
+    strict_1.default.equal(fields.hour, 5);
+    strict_1.default.equal(fields.minute, 0);
+    strict_1.default.equal(fields.dayOfMonth, 15);
+    // 2026-01-15 is in EST (UTC-5): 09:00Z = 04:00 local — DST shift confirmed.
+    const winter = (0, cron_js_1.extractFieldsInTimezone)(at('2026-01-15T09:00:00.000Z'), 'America/New_York');
+    strict_1.default.equal(winter.hour, 4);
+});
+(0, node_test_1.default)('cron next activation skips a DST gap and returns the next valid wall clock', () => {
+    // US spring-forward 2026: clocks jump from 02:00 to 03:00 local on 2026-03-08.
+    // A cron of "0 2 * * *" has no valid 02:00 local that day; the next match is 02:00
+    // the following day (2026-03-09), which does exist.
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 2 * * *', timezone: 'America/New_York' }, at('2026-03-07T07:00:00.000Z'))?.toISOString(), '2026-03-09T06:00:00.000Z');
+});
+(0, node_test_1.default)('cron resolves ambiguous fall-back wall clocks to a single instant', () => {
+    // US fall-back 2026: 2026-11-01 01:00 local happens twice (EDT 05:00Z then EST 06:00Z).
+    // The engine must resolve "0 1 * * *" to exactly one instant, not two or zero.
+    const first = (0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 1 * * *', timezone: 'America/New_York' }, at('2026-10-31T05:00:00.000Z'))?.toISOString();
+    strict_1.default.ok(first === '2026-11-01T05:00:00.000Z' || first === '2026-11-01T06:00:00.000Z', `fall-back resolved to ${first}`);
+    // And the following day still triggers exactly once, at EST 01:00 = 06:00Z.
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 1 * * *', timezone: 'America/New_York' }, at('2026-11-01T06:00:00.000Z'))?.toISOString(), '2026-11-02T06:00:00.000Z');
+});
+(0, node_test_1.default)('cron accepts Z and Etc/UTC as aliases of UTC', () => {
+    // All three aliases must produce identical, UTC-aligned matches.
+    const after = at('2026-07-15T00:00:00.000Z');
+    const expr = '0 * * * *';
+    const viaUtc = (0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: expr, timezone: 'UTC' }, after)?.toISOString();
+    strict_1.default.equal(viaUtc, '2026-07-15T01:00:00.000Z');
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: expr, timezone: 'Z' }, after)?.toISOString(), viaUtc, 'Z alias should match UTC');
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: expr, timezone: 'Etc/UTC' }, after)?.toISOString(), viaUtc, 'Etc/UTC alias should match UTC');
+});
+(0, node_test_1.default)('timezone-aware search handles a half-hour offset zone', () => {
+    // Pacific/Chatham is UTC+12:45 in winter (July). 2026-07-16 00:00 local = 2026-07-15T11:15Z,
+    // so a "0 0 * * *" cron resolved right after 2026-07-15T23:00Z lands on the next calendar day.
+    strict_1.default.equal((0, cron_js_1.findNextCronMatchInTimezone)((0, cron_js_1.compileCronExpression)('0 0 * * *'), at('2026-07-15T23:00:00.000Z'), 'Pacific/Chatham').date?.toISOString(), '2026-07-16T11:15:00.000Z');
 });
 (0, node_test_1.default)('restart recovery returns only the most recent missed activation', () => {
     const now = at('2026-07-05T10:05:30.000Z');

package/dist-electron/tests/electron/automation-store.test.js

@@ -69,6 +69,195 @@ function fixture() {
         context.close();
     }
 });
+(0, node_test_1.default)('listDueAutomationIds returns only automations whose next_check_at is at or before now', () => {
+    const context = fixture();
+    try {
+        const due = context.store.create(createInput({ title: 'Due' }));
+        const future = context.store.create(createInput({ title: 'Future' }));
+        const unset = context.store.create(createInput({ title: 'Unset' }));
+        const disabled = context.store.create(createInput({ title: 'Disabled' }));
+        const blocked = context.store.create(createInput({ title: 'Blocked' }));
+        context.store.updateState(due.id, { nextCheckAt: '2026-07-05T01:05:00.000Z' });
+        context.store.updateState(future.id, { nextCheckAt: '2026-07-05T02:00:00.000Z' });
+        context.store.updateState(disabled.id, { nextCheckAt: '2026-07-05T01:05:00.000Z' });
+        context.store.update(disabled.id, { enabled: false });
+        context.store.updateState(blocked.id, {
+            nextCheckAt: '2026-07-05T01:05:00.000Z',
+            health: 'blocked',
+            blockedReason: 'Provider unavailable',
+        });
+        const atDue = context.store.listDueAutomationIds(new Date('2026-07-05T01:05:00.000Z'));
+        strict_1.default.equal(atDue.size, 1);
+        strict_1.default.equal(atDue.has(due.id), true);
+        strict_1.default.equal(atDue.has(future.id), false);
+        strict_1.default.equal(atDue.has(unset.id), false);
+        strict_1.default.equal(atDue.has(disabled.id), false);
+        strict_1.default.equal(atDue.has(blocked.id), false);
+        const atLater = context.store.listDueAutomationIds(new Date('2026-07-05T02:00:00.000Z'));
+        strict_1.default.equal(atLater.size, 2);
+        strict_1.default.equal(atLater.has(due.id), true);
+        strict_1.default.equal(atLater.has(future.id), true);
+        const facadeDue = context.facade.listDueAutomationIds(new Date('2026-07-05T01:05:00.000Z'));
+        strict_1.default.equal(facadeDue.size, 1);
+        strict_1.default.equal(facadeDue.has(due.id), true);
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('listLatestFinishedEvaluationByOrigin returns the most recent finished evaluation per automation', () => {
+    const context = fixture();
+    try {
+        const monitor = context.store.createTrusted({
+            ...createInput({ title: 'Monitor' }),
+            originKind: 'automation-monitor',
+        });
+        const otherWorkspace = context.store.createTrusted({
+            ...createInput({ workspaceId: 'workspace-2', title: 'Other' }),
+            originKind: 'automation-monitor',
+        });
+        const earlier = context.store.createEvaluation(monitor.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T01:00:00.000Z',
+        });
+        context.store.finishEvaluation(earlier.id, {
+            conditionOutcome: 'matched',
+            triggerDecision: 'triggered',
+            finishedAt: '2026-07-05T01:00:05.000Z',
+        });
+        const later = context.store.createEvaluation(monitor.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T02:00:00.000Z',
+        });
+        context.store.finishEvaluation(later.id, {
+            conditionOutcome: 'matched',
+            triggerDecision: 'triggered',
+            finishedAt: '2026-07-05T02:00:05.000Z',
+        });
+        const running = context.store.createEvaluation(monitor.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T03:00:00.000Z',
+        });
+        const other = context.store.createEvaluation(otherWorkspace.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T01:00:00.000Z',
+        });
+        context.store.finishEvaluation(other.id, {
+            conditionOutcome: 'matched',
+            triggerDecision: 'triggered',
+            finishedAt: '2026-07-05T01:00:05.000Z',
+        });
+        void running;
+        const all = context.store.listLatestFinishedEvaluationByOrigin('automation-monitor');
+        strict_1.default.equal(all.size, 2);
+        strict_1.default.equal(all.get(monitor.id)?.id, later.id);
+        strict_1.default.equal(all.get(otherWorkspace.id)?.id, other.id);
+        const scoped = context.store.listLatestFinishedEvaluationByOrigin('automation-monitor', 'workspace-1');
+        strict_1.default.equal(scoped.size, 1);
+        strict_1.default.equal(scoped.get(monitor.id)?.id, later.id);
+        const facadeScoped = context.facade.listLatestFinishedAutomationEvaluationByOrigin('automation-monitor', 'workspace-1');
+        strict_1.default.equal(facadeScoped.get(monitor.id)?.id, later.id);
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('listLatestRunByOrigin returns the most recent run per automation', () => {
+    const context = fixture();
+    try {
+        const job = context.store.createTrusted({
+            ...createInput({ title: 'Job' }),
+            originKind: 'scheduled-job',
+        });
+        const evaluations = ['2026-07-05T01:00:00.000Z', '2026-07-05T02:00:00.000Z'].map((finishedAt, index) => {
+            const evaluation = context.store.createEvaluation(job.id, {
+                activationKind: 'cron',
+                startedAt: `2026-07-05T0${index + 1}:00:00.000Z`,
+            });
+            context.store.finishEvaluation(evaluation.id, {
+                conditionOutcome: 'matched',
+                triggerDecision: 'triggered',
+                finishedAt,
+            });
+            return evaluation;
+        });
+        const earlierRun = context.store.createRun(job.id, evaluations[0].id, { status: 'succeeded' });
+        const laterRun = context.store.createRun(job.id, evaluations[1].id, { status: 'failed', error: 'boom' });
+        void earlierRun;
+        const all = context.store.listLatestRunByOrigin('scheduled-job');
+        strict_1.default.equal(all.size, 1);
+        strict_1.default.equal(all.get(job.id)?.id, laterRun.id);
+        strict_1.default.equal(all.get(job.id)?.status, 'failed');
+        const facadeAll = context.facade.listLatestAutomationRunByOrigin('scheduled-job');
+        strict_1.default.equal(facadeAll.get(job.id)?.id, laterRun.id);
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('listLatestEvaluationWithStateByOrigin returns the most recent finished-with-state evaluation per automation', () => {
+    const context = fixture();
+    try {
+        const monitor = context.store.createTrusted({
+            ...createInput({ title: 'Monitor' }),
+            originKind: 'automation-monitor',
+        });
+        const withoutState = context.store.createEvaluation(monitor.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T01:00:00.000Z',
+        });
+        context.store.finishEvaluation(withoutState.id, {
+            conditionOutcome: 'matched',
+            triggerDecision: 'triggered',
+            finishedAt: '2026-07-05T01:00:05.000Z',
+        });
+        const withState = context.store.createEvaluation(monitor.id, {
+            activationKind: 'provider-event',
+            startedAt: '2026-07-05T02:00:00.000Z',
+        });
+        context.store.finishEvaluation(withState.id, {
+            conditionOutcome: 'matched',
+            triggerDecision: 'triggered',
+            finishedAt: '2026-07-05T02:00:05.000Z',
+            nextState: { counter: 1 },
+        });
+        const all = context.store.listLatestEvaluationWithStateByOrigin('automation-monitor');
+        strict_1.default.equal(all.size, 1);
+        strict_1.default.equal(all.get(monitor.id)?.id, withState.id);
+        const finished = all.get(monitor.id);
+        strict_1.default.equal(finished?.status, 'finished');
+        if (finished?.status === 'finished') {
+            strict_1.default.deepEqual(finished.nextState, { counter: 1 });
+        }
+        const facadeAll = context.facade.listLatestAutomationEvaluationWithStateByOrigin('automation-monitor');
+        strict_1.default.equal(facadeAll.get(monitor.id)?.id, withState.id);
+    }
+    finally {
+        context.close();
+    }
+});
+(0, node_test_1.default)('list filters by origin kind when provided', () => {
+    const context = fixture();
+    try {
+        const monitor = context.store.createTrusted({
+            ...createInput({ title: 'Monitor' }),
+            originKind: 'automation-monitor',
+        });
+        const job = context.store.createTrusted({
+            ...createInput({ title: 'Job' }),
+            originKind: 'scheduled-job',
+        });
+        void monitor;
+        void job;
+        strict_1.default.equal(context.store.list().length, 2);
+        strict_1.default.equal(context.store.list(undefined, 'automation-monitor').length, 1);
+        strict_1.default.equal(context.store.list(undefined, 'scheduled-job').length, 1);
+        strict_1.default.equal(context.facade.listAutomations(undefined, 'scheduled-job').length, 1);
+    }
+    finally {
+        context.close();
+    }
+});
 (0, node_test_1.default)('reconciles queued and running action runs as interrupted after restart', () => {
     const context = fixture();
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",
   "main": "dist-electron/electron/main.js",