@ashlr/hub 3.5.1 → 3.8.0

package/dist/core/daemon/run-window.d.ts

@@ -0,0 +1,218 @@
+/**
+ * run-window.ts — the BOUNDED RUN WINDOW. Pure maths, no I/O, never throws.
+ *
+ * ── WHY THIS EXISTS ────────────────────────────────────────────────────────
+ * Every scheduler in this repo is relative-elapsed: `Date.now()` deltas and
+ * `setTimeout`. Nothing parses a time of day, nothing knows a timezone, and
+ * `StartCalendarInterval` appears nowhere — the two launch-trigger allowlists
+ * (`daemon/runtime-activation-transaction.ts`, `daemon/resident-service-
+ * readiness.ts`) actively REJECT an extra OS trigger and their tests lock that.
+ * So an overnight run window cannot be an OS launch trigger. It is IN-PROCESS,
+ * and this module is the whole of its arithmetic.
+ *
+ * Three stop rules, chosen per run:
+ *
+ *   { kind: 'until-paused' }                  run until the operator parks it
+ *   { kind: 'until-clock', at: '07:00' }      stop at a wall-clock local time
+ *   { kind: 'iterations', max: 40 }           stop after N loop iterations
+ *
+ * ── THE THINGS A NAIVE CLOCK GETS WRONG ────────────────────────────────────
+ *
+ * 1. THE MACHINE SLEEPS AND WAKES PAST THE END TIME.
+ *    A window must NEVER be held as "remaining milliseconds" counted down by
+ *    elapsed time, and must never be armed as one long `setTimeout`. A laptop
+ *    suspended at 01:00 and opened at 09:00 fired no timers in between; a
+ *    single `setTimeout(6h)` scheduled for 07:00 fires at 15:00 on macOS,
+ *    eight hours of wall-clock too late, and a countdown of elapsed awake time
+ *    never reaches zero at all. So the window is stored as an ABSOLUTE epoch
+ *    instant (`endsAtMs`) and every check is `Date.now() >= endsAtMs`. A run
+ *    that slept through its own end time is expired the first moment it looks,
+ *    with `reason: 'clock-reached'` and a negative remaining — which is the
+ *    correct answer, not an error. {@link runWindowParkMs} additionally caps
+ *    every park at {@link RUN_WINDOW_MAX_PARK_MS} so a woken process re-checks
+ *    within a minute instead of finishing a stale timer.
+ *
+ * 2. A STOP TIME THAT IS TOMORROW. The overnight case IS the case: a run
+ *    started at 23:00 that stops at 07:00 must resolve to TOMORROW's 07:00,
+ *    not to an instant eight hours in the past. {@link nextWallClockOccurrenceMs}
+ *    always resolves strictly forward — when today's occurrence is already at
+ *    or behind `now`, it advances one LOCAL CALENDAR DAY (not `+24h`, which is
+ *    wrong across a DST transition by exactly the offset change).
+ *
+ * 3. THE LOCAL TIMEZONE, AND DST. '07:00' means 07:00 where the operator is.
+ *    Offsets are resolved per-instant from the IANA zone via `Intl`, so a
+ *    window spanning a DST boundary is 7 or 9 hours of real time as the clock
+ *    requires, not a fixed 8. A local time that does not exist (the spring-
+ *    forward gap) resolves to the instant the clock jumps to; a local time
+ *    that happens twice (the autumn fall-back) resolves to the FIRST of the
+ *    two. Both are documented choices, not accidents — see
+ *    {@link wallClockToEpochMs}.
+ *
+ * This module decides nothing about stopping. It reports that the window is
+ * over; `loop.ts` parks the daemon by PAUSING (`~/.ashlr/daemon.paused`), never
+ * by `stopDaemon()`, which is `setKill(true)` and would also refuse the agent's
+ * own write tools. See `daemon/pause.ts`.
+ *
+ * No new runtime deps; `Intl` only. Never throws out of a public API.
+ */
+/**
+ * The three stop rules. A run picks exactly one.
+ *
+ * This is the wire shape `POST /api/verse/overnight` sends, shared verbatim
+ * with the client's `overnight-contract.ts`.
+ *
+ * `at` is an ABSOLUTE ISO-8601 instant, deliberately NOT a time of day. The
+ * caller resolves the operator's wall-clock pick to the next occurrence in
+ * their own timezone BEFORE arming, which removes the ambiguity entirely: a
+ * 23:50 arming for "07:00" can never be read here as ten minutes ago. A caller
+ * with no browser (the CLI) resolves it with {@link resolveWallClockStopRule},
+ * which is the same arithmetic the browser does.
+ */
+export type RunWindowStopRule = {
+    readonly kind: 'until-paused';
+} | {
+    readonly kind: 'at-time';
+    readonly at: string;
+} | {
+    readonly kind: 'after-iterations';
+    readonly iterations: number;
+};
+/** A stop rule resolved against a concrete `now` into absolute quantities. */
+export interface ResolvedRunWindow {
+    readonly kind: RunWindowStopRule['kind'];
+    /** Epoch ms the window was armed at. */
+    readonly startedAtMs: number;
+    /**
+     * ABSOLUTE epoch ms the window ends, or null when the rule has no clock
+     * component. Never a duration — see note 1 in the file header.
+     */
+    readonly endsAtMs: number | null;
+    /** Iteration ceiling, or null when the rule has no iteration component. */
+    readonly maxIterations: number | null;
+    /** The absolute ISO instant for an `at-time` rule; null otherwise. */
+    readonly at: string | null;
+    /** One line, safe for an audit summary. Metadata only. */
+    readonly describe: string;
+}
+/** Why a window is over. `null` while it is still open. */
+export type RunWindowExpiry = 'clock-reached' | 'iterations-reached';
+export interface RunWindowEvaluation {
+    readonly expired: boolean;
+    readonly reason: RunWindowExpiry | null;
+    /**
+     * Signed ms until `endsAtMs` (NEGATIVE when the end time already passed,
+     * which is how a slept-through window reports itself), or null.
+     */
+    readonly remainingMs: number | null;
+    readonly remainingIterations: number | null;
+    readonly detail: string;
+}
+/** {@link resolveRunWindow}'s result. A refusal is a value, never a throw. */
+export type ResolveRunWindowResult = {
+    readonly ok: true;
+    readonly window: ResolvedRunWindow;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * The longest a caller may park in one go while a window is open. A machine
+ * that suspends mid-park wakes with a stale timer; capping the chunk bounds
+ * how long a woken process can run past its own end time to one minute.
+ * Matches `sleepUntilNextUtcBudgetDay`'s existing 60s chunking in loop.ts.
+ */
+export declare const RUN_WINDOW_MAX_PARK_MS = 60000;
+/** The host's IANA zone, or 'UTC' when the runtime cannot say. Never throws. */
+export declare function hostTimeZone(): string;
+/** True when `timeZone` is a zone this runtime can actually resolve. */
+export declare function isResolvableTimeZone(timeZone: string): boolean;
+/**
+ * The epoch instant at which `timeZone`'s clock reads the given local
+ * date-and-time. Returns null when the zone cannot be resolved.
+ *
+ * Two passes: guess with the offset in force at the naive-UTC instant, then
+ * re-read the offset at the corrected instant and correct again if it changed.
+ * That second pass is what makes DST boundaries land correctly.
+ *
+ * AMBIGUOUS AND NONEXISTENT LOCAL TIMES — both documented, neither an error:
+ *  - Spring forward (02:30 does not exist): both passes agree on an instant
+ *    whose clock reads 03:30, i.e. the moment the clock jumps past the request.
+ *    A window asking to stop at a skipped time stops when that time would have
+ *    arrived, which is the operator's intent.
+ *  - Autumn fall-back (01:30 happens twice): resolves to the FIRST occurrence,
+ *    the earlier instant, so a window never runs an extra hour by surprise.
+ *    Erring short is the safe direction for a bound on autonomous work.
+ */
+export declare function wallClockToEpochMs(year: number, month: number, day: number, hour: number, minute: number, timeZone: string): number | null;
+/** Parse 'HH:MM' (24h). Returns null for anything else — no throw, no guess. */
+export declare function parseWallClockTime(at: string): {
+    hour: number;
+    minute: number;
+} | null;
+/**
+ * The next instant at which `timeZone`'s clock reads `at`, STRICTLY AFTER
+ * `nowMs`. This is the overnight wrap: at 23:00 local, '07:00' is tomorrow's
+ * 07:00, because today's has already gone.
+ *
+ * Advances by one LOCAL CALENDAR DAY, never by `+24h` — across a DST boundary
+ * those differ by the offset change, and only the calendar-day advance keeps
+ * the clock reading the requested time.
+ */
+export declare function nextWallClockOccurrenceMs(at: string, nowMs: number, timeZone: string): number | null;
+/**
+ * The iteration ceiling, matching the client contract's documented 1..500.
+ * A bound a typo can turn into "forever" is not a bound.
+ */
+export declare const RUN_WINDOW_MAX_ITERATIONS = 500;
+/**
+ * The furthest ahead an `at-time` stop may be armed. A window is a NIGHT, not
+ * a standing instruction; an instant six weeks out is a mistake, not a plan.
+ */
+export declare const RUN_WINDOW_MAX_HORIZON_MS: number;
+/**
+ * Turn an operator's wall-clock pick into the contract's absolute `at-time`
+ * rule. This is the arithmetic the browser does before it POSTs; it lives here
+ * so the CLI, which has no browser to do it, resolves it identically instead
+ * of inventing a second, subtly different answer.
+ *
+ * Handles the overnight wrap and DST — see {@link nextWallClockOccurrenceMs}.
+ */
+export declare function resolveWallClockStopRule(at: string, opts?: {
+    nowMs?: number;
+    timeZone?: string;
+}): {
+    ok: true;
+    rule: RunWindowStopRule;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Resolve a stop rule against `nowMs` into absolute quantities. Never throws;
+ * every rejection is an `{ ok: false, reason }` value, and every reason is a
+ * SENTENCE, because it is rendered verbatim to the operator as the refusal
+ * `note` on `POST /api/verse/overnight`.
+ */
+export declare function resolveRunWindow(rule: RunWindowStopRule, opts?: {
+    nowMs?: number;
+}): ResolveRunWindowResult;
+/**
+ * Is the window over? Compares an ABSOLUTE deadline against an ABSOLUTE now,
+ * so a process that was suspended across its own end time reports expired on
+ * its first look, with a negative `remainingMs`.
+ *
+ * `iterations` is the count of iterations ALREADY COMPLETED.
+ */
+export declare function evaluateRunWindow(window: ResolvedRunWindow, state?: {
+    nowMs?: number;
+    iterations?: number;
+}): RunWindowEvaluation;
+/**
+ * How long a caller may park before it must look at the window again.
+ *
+ * Never longer than {@link RUN_WINDOW_MAX_PARK_MS}, so a suspended host that
+ * wakes past its end time notices within a minute instead of serving out a
+ * timer armed before the suspend. Never longer than the time actually left,
+ * so the window is not overshot by a park. Never negative.
+ */
+export declare function runWindowParkMs(window: ResolvedRunWindow, requestedMs: number, nowMs?: number): number;

package/dist/core/daemon/run-window.js

@@ -0,0 +1,420 @@
+/**
+ * run-window.ts — the BOUNDED RUN WINDOW. Pure maths, no I/O, never throws.
+ *
+ * ── WHY THIS EXISTS ────────────────────────────────────────────────────────
+ * Every scheduler in this repo is relative-elapsed: `Date.now()` deltas and
+ * `setTimeout`. Nothing parses a time of day, nothing knows a timezone, and
+ * `StartCalendarInterval` appears nowhere — the two launch-trigger allowlists
+ * (`daemon/runtime-activation-transaction.ts`, `daemon/resident-service-
+ * readiness.ts`) actively REJECT an extra OS trigger and their tests lock that.
+ * So an overnight run window cannot be an OS launch trigger. It is IN-PROCESS,
+ * and this module is the whole of its arithmetic.
+ *
+ * Three stop rules, chosen per run:
+ *
+ *   { kind: 'until-paused' }                  run until the operator parks it
+ *   { kind: 'until-clock', at: '07:00' }      stop at a wall-clock local time
+ *   { kind: 'iterations', max: 40 }           stop after N loop iterations
+ *
+ * ── THE THINGS A NAIVE CLOCK GETS WRONG ────────────────────────────────────
+ *
+ * 1. THE MACHINE SLEEPS AND WAKES PAST THE END TIME.
+ *    A window must NEVER be held as "remaining milliseconds" counted down by
+ *    elapsed time, and must never be armed as one long `setTimeout`. A laptop
+ *    suspended at 01:00 and opened at 09:00 fired no timers in between; a
+ *    single `setTimeout(6h)` scheduled for 07:00 fires at 15:00 on macOS,
+ *    eight hours of wall-clock too late, and a countdown of elapsed awake time
+ *    never reaches zero at all. So the window is stored as an ABSOLUTE epoch
+ *    instant (`endsAtMs`) and every check is `Date.now() >= endsAtMs`. A run
+ *    that slept through its own end time is expired the first moment it looks,
+ *    with `reason: 'clock-reached'` and a negative remaining — which is the
+ *    correct answer, not an error. {@link runWindowParkMs} additionally caps
+ *    every park at {@link RUN_WINDOW_MAX_PARK_MS} so a woken process re-checks
+ *    within a minute instead of finishing a stale timer.
+ *
+ * 2. A STOP TIME THAT IS TOMORROW. The overnight case IS the case: a run
+ *    started at 23:00 that stops at 07:00 must resolve to TOMORROW's 07:00,
+ *    not to an instant eight hours in the past. {@link nextWallClockOccurrenceMs}
+ *    always resolves strictly forward — when today's occurrence is already at
+ *    or behind `now`, it advances one LOCAL CALENDAR DAY (not `+24h`, which is
+ *    wrong across a DST transition by exactly the offset change).
+ *
+ * 3. THE LOCAL TIMEZONE, AND DST. '07:00' means 07:00 where the operator is.
+ *    Offsets are resolved per-instant from the IANA zone via `Intl`, so a
+ *    window spanning a DST boundary is 7 or 9 hours of real time as the clock
+ *    requires, not a fixed 8. A local time that does not exist (the spring-
+ *    forward gap) resolves to the instant the clock jumps to; a local time
+ *    that happens twice (the autumn fall-back) resolves to the FIRST of the
+ *    two. Both are documented choices, not accidents — see
+ *    {@link wallClockToEpochMs}.
+ *
+ * This module decides nothing about stopping. It reports that the window is
+ * over; `loop.ts` parks the daemon by PAUSING (`~/.ashlr/daemon.paused`), never
+ * by `stopDaemon()`, which is `setKill(true)` and would also refuse the agent's
+ * own write tools. See `daemon/pause.ts`.
+ *
+ * No new runtime deps; `Intl` only. Never throws out of a public API.
+ */
+/**
+ * The longest a caller may park in one go while a window is open. A machine
+ * that suspends mid-park wakes with a stale timer; capping the chunk bounds
+ * how long a woken process can run past its own end time to one minute.
+ * Matches `sleepUntilNextUtcBudgetDay`'s existing 60s chunking in loop.ts.
+ */
+export const RUN_WINDOW_MAX_PARK_MS = 60_000;
+// ---------------------------------------------------------------------------
+// Timezone arithmetic
+// ---------------------------------------------------------------------------
+/** The host's IANA zone, or 'UTC' when the runtime cannot say. Never throws. */
+export function hostTimeZone() {
+    try {
+        const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return typeof zone === 'string' && zone.length > 0 ? zone : 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+/** True when `timeZone` is a zone this runtime can actually resolve. */
+export function isResolvableTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The wall-clock components `instantMs` shows in `timeZone`.
+ * Returns null when the zone cannot be resolved.
+ */
+function partsInZone(instantMs, timeZone) {
+    try {
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hour12: false,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        const read = {};
+        for (const part of formatter.formatToParts(new Date(instantMs))) {
+            if (part.type === 'literal')
+                continue;
+            const value = Number(part.value);
+            if (!Number.isFinite(value))
+                continue;
+            read[part.type] = value;
+        }
+        const year = read['year'];
+        const month = read['month'];
+        const day = read['day'];
+        // `hour12: false` yields 24 rather than 0 for midnight in some ICU builds.
+        const hour = read['hour'] === 24 ? 0 : read['hour'];
+        const minute = read['minute'];
+        const second = read['second'];
+        if (year === undefined || month === undefined || day === undefined ||
+            hour === undefined || minute === undefined || second === undefined) {
+            return null;
+        }
+        return { year, month, day, hour, minute, second };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The zone's UTC offset (ms) AT a given instant. Positive east of Greenwich.
+ * Derived by reading the instant's wall clock in the zone and treating those
+ * components as if they were UTC — the difference is the offset in force then,
+ * which is what makes this DST-correct rather than fixed per zone.
+ */
+function zoneOffsetMsAt(instantMs, timeZone) {
+    const parts = partsInZone(instantMs, timeZone);
+    if (!parts)
+        return null;
+    const asIfUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    // Second-truncate the probe so the sub-second remainder does not leak in.
+    return asIfUtc - Math.floor(instantMs / 1000) * 1000;
+}
+/**
+ * The epoch instant at which `timeZone`'s clock reads the given local
+ * date-and-time. Returns null when the zone cannot be resolved.
+ *
+ * Two passes: guess with the offset in force at the naive-UTC instant, then
+ * re-read the offset at the corrected instant and correct again if it changed.
+ * That second pass is what makes DST boundaries land correctly.
+ *
+ * AMBIGUOUS AND NONEXISTENT LOCAL TIMES — both documented, neither an error:
+ *  - Spring forward (02:30 does not exist): both passes agree on an instant
+ *    whose clock reads 03:30, i.e. the moment the clock jumps past the request.
+ *    A window asking to stop at a skipped time stops when that time would have
+ *    arrived, which is the operator's intent.
+ *  - Autumn fall-back (01:30 happens twice): resolves to the FIRST occurrence,
+ *    the earlier instant, so a window never runs an extra hour by surprise.
+ *    Erring short is the safe direction for a bound on autonomous work.
+ */
+export function wallClockToEpochMs(year, month, day, hour, minute, timeZone) {
+    const naive = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+    if (!Number.isFinite(naive))
+        return null;
+    const firstOffset = zoneOffsetMsAt(naive, timeZone);
+    if (firstOffset === null)
+        return null;
+    const firstGuess = naive - firstOffset;
+    const secondOffset = zoneOffsetMsAt(firstGuess, timeZone);
+    if (secondOffset === null)
+        return null;
+    if (secondOffset === firstOffset)
+        return firstGuess;
+    const secondGuess = naive - secondOffset;
+    // Fall-back hour: both candidates are real instants reading the requested
+    // clock time. Take the earlier one — a bound that errs short, never long.
+    const thirdOffset = zoneOffsetMsAt(secondGuess, timeZone);
+    if (thirdOffset === secondOffset)
+        return Math.min(firstGuess, secondGuess);
+    return firstGuess;
+}
+/** Parse 'HH:MM' (24h). Returns null for anything else — no throw, no guess. */
+export function parseWallClockTime(at) {
+    if (typeof at !== 'string')
+        return null;
+    const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(at.trim());
+    if (!match)
+        return null;
+    return { hour: Number(match[1]), minute: Number(match[2]) };
+}
+/**
+ * The next instant at which `timeZone`'s clock reads `at`, STRICTLY AFTER
+ * `nowMs`. This is the overnight wrap: at 23:00 local, '07:00' is tomorrow's
+ * 07:00, because today's has already gone.
+ *
+ * Advances by one LOCAL CALENDAR DAY, never by `+24h` — across a DST boundary
+ * those differ by the offset change, and only the calendar-day advance keeps
+ * the clock reading the requested time.
+ */
+export function nextWallClockOccurrenceMs(at, nowMs, timeZone) {
+    const hhmm = parseWallClockTime(at);
+    if (!hhmm)
+        return null;
+    if (!Number.isFinite(nowMs))
+        return null;
+    const today = partsInZone(nowMs, timeZone);
+    if (!today)
+        return null;
+    const sameDay = wallClockToEpochMs(today.year, today.month, today.day, hhmm.hour, hhmm.minute, timeZone);
+    if (sameDay !== null && sameDay > nowMs)
+        return sameDay;
+    // Already gone today (or landed exactly on now) — take tomorrow's. Date.UTC
+    // normalises a day overflow (e.g. the 32nd) into the next month/year for us;
+    // we only use it to get the next calendar date, never as an instant.
+    const tomorrowProbe = new Date(Date.UTC(today.year, today.month - 1, today.day + 1));
+    const nextDay = wallClockToEpochMs(tomorrowProbe.getUTCFullYear(), tomorrowProbe.getUTCMonth() + 1, tomorrowProbe.getUTCDate(), hhmm.hour, hhmm.minute, timeZone);
+    if (nextDay !== null && nextDay > nowMs)
+        return nextDay;
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Resolve
+// ---------------------------------------------------------------------------
+/**
+ * The iteration ceiling, matching the client contract's documented 1..500.
+ * A bound a typo can turn into "forever" is not a bound.
+ */
+export const RUN_WINDOW_MAX_ITERATIONS = 500;
+/**
+ * The furthest ahead an `at-time` stop may be armed. A window is a NIGHT, not
+ * a standing instruction; an instant six weeks out is a mistake, not a plan.
+ */
+export const RUN_WINDOW_MAX_HORIZON_MS = 7 * 24 * 3_600_000;
+/**
+ * Turn an operator's wall-clock pick into the contract's absolute `at-time`
+ * rule. This is the arithmetic the browser does before it POSTs; it lives here
+ * so the CLI, which has no browser to do it, resolves it identically instead
+ * of inventing a second, subtly different answer.
+ *
+ * Handles the overnight wrap and DST — see {@link nextWallClockOccurrenceMs}.
+ */
+export function resolveWallClockStopRule(at, opts = {}) {
+    const nowMs = opts.nowMs ?? Date.now();
+    if (!parseWallClockTime(at)) {
+        return { ok: false, reason: `A stop time must look like 'HH:MM' on a 24-hour clock. '${at}' does not.` };
+    }
+    const timeZone = opts.timeZone ?? hostTimeZone();
+    if (!isResolvableTimeZone(timeZone)) {
+        return { ok: false, reason: `This machine cannot resolve the timezone '${timeZone}', so '${at}' has no fixed meaning.` };
+    }
+    const endsAtMs = nextWallClockOccurrenceMs(at, nowMs, timeZone);
+    if (endsAtMs === null) {
+        return { ok: false, reason: `Could not work out when '${at}' next happens in ${timeZone}.` };
+    }
+    return { ok: true, rule: { kind: 'at-time', at: new Date(endsAtMs).toISOString() } };
+}
+/**
+ * Resolve a stop rule against `nowMs` into absolute quantities. Never throws;
+ * every rejection is an `{ ok: false, reason }` value, and every reason is a
+ * SENTENCE, because it is rendered verbatim to the operator as the refusal
+ * `note` on `POST /api/verse/overnight`.
+ */
+export function resolveRunWindow(rule, opts = {}) {
+    const nowMs = opts.nowMs ?? Date.now();
+    if (!Number.isFinite(nowMs)) {
+        return { ok: false, reason: 'This machine could not read its own clock, so a timed run cannot be bounded.' };
+    }
+    if (rule === null || typeof rule !== 'object') {
+        return { ok: false, reason: 'A run needs exactly one stop rule, and none was given.' };
+    }
+    if (rule.kind === 'until-paused') {
+        return {
+            ok: true,
+            window: {
+                kind: 'until-paused',
+                startedAtMs: nowMs,
+                endsAtMs: null,
+                maxIterations: null,
+                at: null,
+                describe: 'run until paused (~/.ashlr/daemon.paused)',
+            },
+        };
+    }
+    if (rule.kind === 'after-iterations') {
+        const iterations = rule.iterations;
+        if (typeof iterations !== 'number' || !Number.isInteger(iterations) || iterations < 1) {
+            return { ok: false, reason: 'An iteration budget must be a whole number of at least 1.' };
+        }
+        if (iterations > RUN_WINDOW_MAX_ITERATIONS) {
+            return {
+                ok: false,
+                reason: `An iteration budget may be at most ${RUN_WINDOW_MAX_ITERATIONS}; ${iterations} was asked for.`,
+            };
+        }
+        return {
+            ok: true,
+            window: {
+                kind: 'after-iterations',
+                startedAtMs: nowMs,
+                endsAtMs: null,
+                maxIterations: iterations,
+                at: null,
+                describe: `stop after ${iterations} iteration${iterations === 1 ? '' : 's'}`,
+            },
+        };
+    }
+    if (rule.kind === 'at-time') {
+        if (typeof rule.at !== 'string' || rule.at.trim().length === 0) {
+            return { ok: false, reason: 'A timed run needs an absolute ISO-8601 instant to stop at, and none was given.' };
+        }
+        const endsAtMs = Date.parse(rule.at);
+        if (!Number.isFinite(endsAtMs)) {
+            return {
+                ok: false,
+                reason: `'${rule.at}' is not an ISO-8601 instant. A stop time must be absolute (for example ` +
+                    `2026-09-24T07:00:00.000Z), not a time of day.`,
+            };
+        }
+        // The client resolves forward before sending, but a request can still
+        // arrive stale — a queued POST, a hand-written call, a host whose clock
+        // moved. A window that already ended must REFUSE, not run zero iterations
+        // and not silently become unbounded.
+        if (endsAtMs <= nowMs) {
+            const agoMin = ((nowMs - endsAtMs) / 60_000).toFixed(1);
+            return {
+                ok: false,
+                reason: `That stop time (${rule.at}) is ${agoMin} minutes in the past, so the run would end before ` +
+                    `it began. Pick a time later than now.`,
+            };
+        }
+        if (endsAtMs - nowMs > RUN_WINDOW_MAX_HORIZON_MS) {
+            const days = ((endsAtMs - nowMs) / 86_400_000).toFixed(1);
+            return {
+                ok: false,
+                reason: `That stop time is ${days} days away. An unattended run is bounded to at most ` +
+                    `${RUN_WINDOW_MAX_HORIZON_MS / 86_400_000} days.`,
+            };
+        }
+        const hours = (endsAtMs - nowMs) / 3_600_000;
+        return {
+            ok: true,
+            window: {
+                kind: 'at-time',
+                startedAtMs: nowMs,
+                endsAtMs,
+                maxIterations: null,
+                at: new Date(endsAtMs).toISOString(),
+                describe: `stop at ${new Date(endsAtMs).toISOString()} (in ${hours.toFixed(2)}h)`,
+            },
+        };
+    }
+    return {
+        ok: false,
+        reason: `'${String(rule.kind)}' is not a stop rule this engine knows.`,
+    };
+}
+// ---------------------------------------------------------------------------
+// Evaluate
+// ---------------------------------------------------------------------------
+/**
+ * Is the window over? Compares an ABSOLUTE deadline against an ABSOLUTE now,
+ * so a process that was suspended across its own end time reports expired on
+ * its first look, with a negative `remainingMs`.
+ *
+ * `iterations` is the count of iterations ALREADY COMPLETED.
+ */
+export function evaluateRunWindow(window, state = {}) {
+    const nowMs = state.nowMs ?? Date.now();
+    const iterations = state.iterations ?? 0;
+    const remainingIterations = window.maxIterations === null
+        ? null
+        : window.maxIterations - iterations;
+    const remainingMs = window.endsAtMs === null ? null : window.endsAtMs - nowMs;
+    if (window.endsAtMs !== null && Number.isFinite(nowMs) && nowMs >= window.endsAtMs) {
+        const overshootMs = nowMs - window.endsAtMs;
+        return {
+            expired: true,
+            reason: 'clock-reached',
+            remainingMs,
+            remainingIterations,
+            detail: overshootMs > RUN_WINDOW_MAX_PARK_MS
+                ? `run window ended at ${window.at}; ` +
+                    `noticed ${(overshootMs / 60_000).toFixed(1)} min late (the host was likely asleep)`
+                : `run window ended at ${window.at}`,
+        };
+    }
+    if (remainingIterations !== null && remainingIterations <= 0) {
+        return {
+            expired: true,
+            reason: 'iterations-reached',
+            remainingMs,
+            remainingIterations,
+            detail: `run window completed its ${window.maxIterations}-iteration budget`,
+        };
+    }
+    return {
+        expired: false,
+        reason: null,
+        remainingMs,
+        remainingIterations,
+        detail: window.describe,
+    };
+}
+/**
+ * How long a caller may park before it must look at the window again.
+ *
+ * Never longer than {@link RUN_WINDOW_MAX_PARK_MS}, so a suspended host that
+ * wakes past its end time notices within a minute instead of serving out a
+ * timer armed before the suspend. Never longer than the time actually left,
+ * so the window is not overshot by a park. Never negative.
+ */
+export function runWindowParkMs(window, requestedMs, nowMs = Date.now()) {
+    const requested = Number.isFinite(requestedMs) ? Math.max(0, requestedMs) : 0;
+    let park = Math.min(requested, RUN_WINDOW_MAX_PARK_MS);
+    if (window.endsAtMs !== null && Number.isFinite(nowMs)) {
+        park = Math.min(park, Math.max(0, window.endsAtMs - nowMs));
+    }
+    return park;
+}
+//# sourceMappingURL=run-window.js.map

package/dist/core/daemon/run-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-window.js","sourceRoot":"","sources":["../../../src/core/daemon/run-window.ts"],"names":[],"mappings":"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"}