@fungi.computer/watchdog 0.0.0-stage → 0.0.1

package/dist/internal/async-sql.js

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { WatchdogQueuedJobSchema } from "../effect.js";
+import { laneMaxLength } from "./lane.js";
+export const columns = `sequence, job_id, queue_name, lane, priority, payload_json,
+  recovery_max, state, outcome, claim_token, recovery_count, cancellation_id, failure_reason`;
+export function schemaStatements(postgres) {
+    return [
+        `CREATE TABLE IF NOT EXISTS watchdog_jobs (
+      sequence ${postgres ? "SERIAL PRIMARY KEY" : "INTEGER PRIMARY KEY AUTOINCREMENT"},
+      job_id TEXT NOT NULL UNIQUE CHECK(length(job_id) BETWEEN 1 AND 256),
+      queue_name TEXT NOT NULL CHECK(length(queue_name) BETWEEN 1 AND 256),
+      lane TEXT NOT NULL CHECK(length(lane) BETWEEN 1 AND ${String(laneMaxLength)}),
+      priority ${postgres ? "DOUBLE PRECISION" : "INTEGER"} NOT NULL,
+      payload_json TEXT NOT NULL,
+      recovery_max ${postgres ? "DOUBLE PRECISION" : "INTEGER"} CHECK(recovery_max IS NULL OR recovery_max >= 0),
+      state TEXT NOT NULL CHECK(state IN ('queued','running','settled')),
+      outcome TEXT CHECK(outcome IN ('completed','failed','cancelled','outcome_unknown','interrupted')),
+      claim_token TEXT,
+      recovery_count ${postgres ? "DOUBLE PRECISION" : "INTEGER"} NOT NULL DEFAULT 0,
+      cancellation_id TEXT UNIQUE,
+      failure_reason TEXT,
+      lease_until ${postgres ? "DOUBLE PRECISION" : "INTEGER"},
+      CHECK ((state='queued' AND outcome IS NULL AND claim_token IS NULL) OR
+        (state='running' AND outcome IS NULL AND claim_token IS NOT NULL AND lease_until IS NOT NULL) OR
+        (state='settled' AND outcome IS NOT NULL))
+    )`,
+        "CREATE INDEX IF NOT EXISTS idx_watchdog_lane_failure ON watchdog_jobs(lane,state DESC,sequence ASC)",
+        "CREATE INDEX IF NOT EXISTS idx_watchdog_ready ON watchdog_jobs(state,priority DESC,sequence)",
+        "CREATE INDEX IF NOT EXISTS idx_watchdog_queue_head ON watchdog_jobs(queue_name,state,priority DESC,sequence)",
+        "CREATE INDEX IF NOT EXISTS idx_watchdog_lease ON watchdog_jobs(state,lease_until,sequence)",
+    ];
+}
+// A conflicting replay must fail the caller's entire native transaction. Setting
+// the NOT NULL identity to NULL is a portable constraint failure, not a silent
+// DO NOTHING that would commit the producer fact with an unrelated old job.
+export function enqueueSelect(source) {
+    return {
+        text: `INSERT INTO watchdog_jobs
+      (job_id,queue_name,lane,priority,payload_json,recovery_max,state)
+      SELECT job_id,queue_name,lane,priority,payload_json,recovery_max,'queued'
+      FROM (${source.text}) AS admission WHERE true
+      ON CONFLICT(job_id) DO UPDATE SET job_id = NULL WHERE NOT (
+        watchdog_jobs.queue_name=excluded.queue_name AND watchdog_jobs.lane=excluded.lane AND
+        watchdog_jobs.priority=excluded.priority AND watchdog_jobs.payload_json=excluded.payload_json AND
+        (watchdog_jobs.recovery_max=excluded.recovery_max OR
+          (watchdog_jobs.recovery_max IS NULL AND excluded.recovery_max IS NULL))
+        )
+      RETURNING ${columns}`,
+        values: source.values,
+    };
+}
+export function enqueueStatement(input) {
+    const job = Schema.decodeUnknownSync(WatchdogQueuedJobSchema)(input);
+    return enqueueSelect({
+        text: `SELECT CAST($1 AS TEXT) AS job_id,CAST($2 AS TEXT) AS queue_name,CAST($3 AS TEXT) AS lane,CAST($4 AS DOUBLE PRECISION) AS priority,
+      CAST($5 AS TEXT) AS payload_json,CAST($6 AS DOUBLE PRECISION) AS recovery_max`,
+        values: [
+            job.jobId,
+            job.queue,
+            job.lane,
+            job.priority,
+            Schema.encodeSync(Schema.fromJsonString(Schema.Unknown))(job.payload),
+            job.recovery?.maxRecoveries ?? null,
+        ],
+    });
+}

package/dist/internal/async-store.d.ts

@@ -0,0 +1,58 @@
+import * as Effect from "effect/Effect";
+import { WatchdogError } from "./watchdog-error.js";
+import { type SqlDatabase } from "./async-sql.js";
+export declare const heartbeatMs = 10000;
+export declare const attempt: <A>(run: () => Promise<A>) => Effect.Effect<A, WatchdogError>;
+export declare function openAsyncStore(database: SqlDatabase, now: () => number): {
+    store: Readonly<{
+        hasPendingWork: Effect.Effect<boolean, WatchdogError>;
+        ingest: (job: import("../effect.js").WatchdogQueuedJob) => Effect.Effect<import("../effect.js").WatchdogIngestResult, WatchdogError>;
+        read: (jobId: string) => Effect.Effect<(Extract<import("../effect.js").WatchdogReadResult, {
+            status: "found";
+        }> & Readonly<{
+            claimToken: string | null;
+            recoveryCount: number;
+        }>) | Extract<import("../effect.js").WatchdogReadResult, {
+            status: "missing";
+        }>, WatchdogError>;
+        readQueueHead: (queue: string) => Effect.Effect<import("../effect.js").WatchdogQueueHead, WatchdogError>;
+        readSettled: (limit: number, afterSequence?: number) => Effect.Effect<readonly import("../effect.js").WatchdogSettledRecord[], WatchdogError>;
+        selectAndClaim: (claimToken: string) => Effect.Effect<import("./sqlite-store.js").WatchdogSelection, WatchdogError>;
+        settleExactClaim: (input: Readonly<{
+            jobId: string;
+            claimToken: string;
+            decision: import("../effect.js").WatchdogExecutionDecision;
+        }>) => Effect.Effect<Readonly<{
+            status: "settled" | "replayed";
+            job: import("../effect.js").WatchdogSettledJob;
+        }> | Readonly<{
+            status: "conflict" | "missing";
+        }>, WatchdogError>;
+        recordCancellation: (input: import("../effect.js").WatchdogCancellationIntent) => Effect.Effect<import("../effect.js").WatchdogCancellationResult, WatchdogError>;
+        failLane: (input: import("../effect.js").WatchdogLaneFailure) => Effect.Effect<Readonly<{
+            jobs: readonly import("../effect.js").WatchdogSettledJob[];
+            more: boolean;
+        }>, WatchdogError>;
+        purgeQueued: (queue: string) => Effect.Effect<void, WatchdogError>;
+        nextRunningClaim: () => Effect.Effect<Readonly<{
+            job: import("../effect.js").WatchdogRunningJob;
+            claimToken: string;
+            recoveryCount: number;
+        }> | undefined, WatchdogError>;
+        reconcileDisappearedClaim: (input: Readonly<{
+            job: import("../effect.js").WatchdogRunningJob;
+            claimToken: string;
+            recoveryCount: number;
+            disposition: "requeue" | "interrupted";
+        }>) => Effect.Effect<Readonly<{
+            status: "requeued";
+        }> | Readonly<{
+            status: "settled";
+            job: import("../effect.js").WatchdogSettledJob;
+        }> | Readonly<{
+            status: "conflict" | "missing";
+        }>, WatchdogError>;
+    }>;
+    isAlive: (jobId: string) => Effect.Effect<boolean, WatchdogError, never>;
+    renew: (jobId: string) => Effect.Effect<void, WatchdogError, never>;
+};

package/dist/internal/async-store.js

@@ -0,0 +1,235 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { parseJobRow, parseLaneFailure, laneFailureBatchSize, } from "./sqlite-store.js";
+import { WatchdogError } from "./watchdog-error.js";
+import { columns, enqueueStatement, } from "./async-sql.js";
+const leaseMs = 120_000;
+export const heartbeatMs = 10_000;
+const Alive = Schema.Struct({ alive: Schema.Literals([0, 1]) });
+export const attempt = (run) => Effect.tryPromise({
+    try: run,
+    catch: (error) => error instanceof WatchdogError
+        ? error
+        : new WatchdogError("store_unavailable", error),
+});
+export function openAsyncStore(database, now) {
+    // The database checks wall time when the mutation executes, so a delayed
+    // renewal cannot resurrect a lease that expired while the request was in flight.
+    const at = (parameter) => database.clock === undefined
+        ? `CAST($${String(parameter)} AS DOUBLE PRECISION)`
+        : `(CASE WHEN $${String(parameter)}>${database.clock} THEN $${String(parameter)} ELSE ${database.clock} END)`;
+    const query = (text, values = []) => database.query({ text, values });
+    const row = async (id) => {
+        const raw = (await query(`SELECT ${columns} FROM watchdog_jobs WHERE job_id=$1`, [id]))[0];
+        return raw === undefined ? undefined : parseJobRow(raw);
+    };
+    // Private to this runtime: claims never escape through a public job.
+    const claims = new Map();
+    const store = {
+        hasPendingWork: attempt(async () => (await query("SELECT job_id FROM watchdog_jobs WHERE state IN ('queued','running') LIMIT 1")).length > 0),
+        ingest: (job) => attempt(async () => ({
+            status: (await database.query(enqueueStatement(job))).length > 0
+                ? "queued"
+                : "duplicate",
+        })),
+        read: (id) => attempt(async () => {
+            const observedClaim = claims.get(id);
+            const found = await row(id);
+            // A delayed claim reply can arrive after failLane deleted its entry.
+            // Retire only this read's claim; a pre-claim snapshot cannot erase a newer one.
+            if ((found === undefined || found.job.state === "settled") &&
+                claims.get(id) === observedClaim)
+                claims.delete(id);
+            if (found === undefined)
+                return { status: "missing" };
+            return {
+                status: "found",
+                job: found.job,
+                claimToken: found.row.claim_token,
+                recoveryCount: found.row.recovery_count,
+                cancellation: found.row.cancellation_id === null
+                    ? { status: "absent" }
+                    : {
+                        status: "present",
+                        cancellation: {
+                            jobId: id,
+                            cancellationId: found.row.cancellation_id,
+                        },
+                    },
+            };
+        }),
+        readQueueHead: (queue) => attempt(async () => {
+            const raw = (await query(`SELECT ${columns} FROM watchdog_jobs WHERE queue_name=$1
+        AND state IN ('queued','running') ORDER BY CASE state WHEN 'running' THEN 0 ELSE 1 END,
+        priority DESC,sequence LIMIT 1`, [queue]))[0];
+            if (raw === undefined)
+                return { state: "idle" };
+            const found = parseJobRow(raw);
+            if (found.job.state === "settled")
+                throw new WatchdogError("store_unavailable");
+            return {
+                state: found.job.state,
+                jobId: found.job.jobId,
+                cancellationRequested: found.row.cancellation_id !== null,
+            };
+        }),
+        readSettled: (limit, afterSequence = 0) => attempt(async () => {
+            Schema.decodeUnknownSync(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(256)))(limit);
+            const rows = await query(`SELECT ${columns} FROM watchdog_jobs WHERE state='settled'
+        AND sequence>$1 ORDER BY sequence LIMIT $2`, [afterSequence, limit]);
+            return rows.map((raw) => {
+                const parsed = parseJobRow(raw);
+                if (parsed.job.state !== "settled")
+                    throw new WatchdogError("store_unavailable");
+                return { sequence: parsed.row.sequence, job: parsed.job };
+            });
+        }),
+        selectAndClaim: (token) => attempt(async () => {
+            const raw = (await query(`UPDATE watchdog_jobs SET
+        state=CASE WHEN cancellation_id IS NULL THEN 'running' ELSE 'settled' END,
+        outcome=CASE WHEN cancellation_id IS NULL THEN NULL ELSE 'cancelled' END,
+        claim_token=CASE WHEN cancellation_id IS NULL THEN $1 ELSE NULL END,
+        lease_until=CASE WHEN cancellation_id IS NULL THEN ${at(2)}+${String(leaseMs)} ELSE NULL END
+        WHERE job_id=(SELECT job_id FROM watchdog_jobs WHERE state='queued'
+          ORDER BY priority DESC,sequence LIMIT 1) AND state='queued' RETURNING ${columns}`, [token, now()]))[0];
+            if (raw === undefined)
+                return { status: "no_ready" };
+            const parsed = parseJobRow(raw);
+            if (parsed.job.state === "settled")
+                return { status: "cancelled", job: parsed.job };
+            if (parsed.job.state !== "running")
+                throw new WatchdogError("claim_unavailable");
+            claims.set(parsed.job.jobId, token);
+            return { status: "claimed", job: parsed.job, claimToken: token };
+        }),
+        settleExactClaim: (input) => attempt(async () => {
+            try {
+                const raw = (await query(`UPDATE watchdog_jobs SET state='settled',
+          outcome=CASE WHEN cancellation_id IS NULL THEN $1 ELSE 'cancelled' END,
+          failure_reason=CASE WHEN cancellation_id IS NULL THEN $2 ELSE NULL END,lease_until=NULL
+          WHERE job_id=$3 AND state='running' AND claim_token=$4 AND lease_until>${at(5)} RETURNING ${columns}`, [
+                    input.decision.kind,
+                    input.decision.kind === "failed"
+                        ? (input.decision.reason ?? null)
+                        : null,
+                    input.jobId,
+                    input.claimToken,
+                    now(),
+                ]))[0];
+                if (raw !== undefined) {
+                    const parsed = parseJobRow(raw);
+                    if (parsed.job.state === "settled")
+                        return { status: "settled", job: parsed.job };
+                }
+                const prior = await row(input.jobId);
+                if (prior === undefined)
+                    return { status: "missing" };
+                const outcome = prior.row.cancellation_id === null
+                    ? input.decision.kind
+                    : "cancelled";
+                return prior.job.state === "settled" &&
+                    prior.row.claim_token === input.claimToken &&
+                    prior.job.outcome === outcome
+                    ? { status: "replayed", job: prior.job }
+                    : { status: "conflict" };
+            }
+            finally {
+                claims.delete(input.jobId);
+            }
+        }),
+        recordCancellation: (intent) => attempt(async () => {
+            const updated = await query(`UPDATE watchdog_jobs SET cancellation_id=$1 WHERE job_id=$2
+        AND cancellation_id IS NULL ${intent.onlyIfQueued === true ? "AND state='queued'" : ""}
+        RETURNING job_id`, [intent.cancellationId, intent.jobId]);
+            if (updated.length > 0)
+                return { status: "recorded" };
+            const prior = await row(intent.jobId);
+            return {
+                status: prior === undefined
+                    ? "missing"
+                    : prior.row.cancellation_id === intent.cancellationId
+                        ? "replayed"
+                        : "conflict",
+            };
+        }),
+        failLane: (raw) => attempt(async () => {
+            const input = parseLaneFailure(raw);
+            // Under the declared state grammar, DESC puts running before queued.
+            const rows = await query(`UPDATE watchdog_jobs SET state='settled', outcome='failed', failure_reason=$1, lease_until=NULL, claim_token=NULL
+         WHERE job_id IN (SELECT job_id FROM watchdog_jobs WHERE lane=$2 AND state IN ('queued','running')
+           ORDER BY state DESC, sequence ASC LIMIT $3)
+           AND state IN ('queued','running') RETURNING ${columns}`, [input.reason, input.lane, laneFailureBatchSize]);
+            const jobs = rows.map((row) => {
+                const parsed = parseJobRow(row);
+                if (parsed.job.state !== "settled")
+                    throw new WatchdogError("store_unavailable");
+                claims.delete(parsed.job.jobId);
+                return parsed.job;
+            });
+            const more = (await query("SELECT 1 AS pending FROM watchdog_jobs WHERE lane=$1 AND state IN ('queued','running') LIMIT 1", [input.lane])).length !== 0;
+            return { jobs, more };
+        }),
+        purgeQueued: (queue) => attempt(async () => {
+            await query("DELETE FROM watchdog_jobs WHERE queue_name=$1 AND state='queued'", [queue]);
+        }),
+        nextRunningClaim: () => attempt(async () => {
+            const raw = (await query(`SELECT ${columns} FROM watchdog_jobs WHERE state='running'
+        ORDER BY lease_until,sequence LIMIT 1`))[0];
+            if (raw === undefined)
+                return undefined;
+            const found = parseJobRow(raw);
+            if (found.job.state !== "running" || found.row.claim_token === null)
+                throw new WatchdogError("store_unavailable");
+            return {
+                job: found.job,
+                claimToken: found.row.claim_token,
+                recoveryCount: found.row.recovery_count,
+            };
+        }),
+        reconcileDisappearedClaim: (input) => attempt(async () => {
+            const requeue = input.disposition === "requeue";
+            const reason = input.job.recovery === undefined
+                ? "Execution disappeared without a recovery policy"
+                : `Restart recovery budget exhausted (${String(input.job.recovery.maxRecoveries)} recoveries)`;
+            const raw = (await query(`UPDATE watchdog_jobs SET
+        state=CASE WHEN $1=1 AND cancellation_id IS NULL THEN 'queued' ELSE 'settled' END,
+        outcome=CASE WHEN cancellation_id IS NOT NULL THEN 'cancelled' WHEN $1=1 THEN NULL ELSE 'interrupted' END,
+        claim_token=CASE WHEN $1=1 AND cancellation_id IS NULL THEN NULL ELSE claim_token END,
+        recovery_count=recovery_count+CASE WHEN $1=1 AND cancellation_id IS NULL THEN 1 ELSE 0 END,
+        failure_reason=CASE WHEN $1=0 AND cancellation_id IS NULL THEN $2 ELSE NULL END,lease_until=NULL
+        WHERE job_id=$3 AND state='running' AND claim_token=$4 AND recovery_count=$5 AND lease_until<=${at(6)}
+        RETURNING ${columns}`, [
+                requeue ? 1 : 0,
+                reason,
+                input.job.jobId,
+                input.claimToken,
+                input.recoveryCount,
+                now(),
+            ]))[0];
+            if (raw === undefined)
+                return { status: "conflict" };
+            const parsed = parseJobRow(raw);
+            if (parsed.job.state === "queued")
+                return { status: "requeued" };
+            if (parsed.job.state === "settled")
+                return { status: "settled", job: parsed.job };
+            throw new WatchdogError("store_unavailable");
+        }),
+    };
+    return {
+        store,
+        isAlive: (jobId) => attempt(async () => {
+            const raw = (await query(`SELECT CASE WHEN lease_until>${at(2)} THEN 1 ELSE 0 END AS alive FROM watchdog_jobs WHERE job_id=$1 AND state='running'`, [jobId, now()]))[0];
+            return (raw !== undefined && Schema.decodeUnknownSync(Alive)(raw).alive === 1);
+        }),
+        renew: (jobId) => attempt(async () => {
+            const token = claims.get(jobId);
+            if (token === undefined)
+                throw new WatchdogError("claim_unavailable");
+            const rows = await query(`UPDATE watchdog_jobs SET lease_until=${at(1)}+${String(leaseMs)} WHERE job_id=$2 AND state='running'
+        AND claim_token=$3 AND lease_until>${at(4)} AND cancellation_id IS NULL RETURNING job_id`, [now(), jobId, token, now()]);
+            if (rows.length === 0)
+                throw new WatchdogError("claim_unavailable");
+        }),
+    };
+}

package/dist/internal/identities.d.ts

@@ -0,0 +1,3 @@
+export declare const watchdogIds: Readonly<{
+    readonly claim: import("@fungi.computer/cairn").IdCodec<"watchdog", "claim", 1>;
+}>;

package/dist/internal/identities.js

@@ -0,0 +1,8 @@
+import { defineIdFamily } from "@fungi.computer/cairn";
+export const watchdogIds = defineIdFamily({
+    family: "watchdog",
+    version: 1,
+    kinds: {
+        claim: { prefix: "watchdog_claim" },
+    },
+});

package/dist/internal/lane.d.ts

@@ -0,0 +1,3 @@
+import * as Schema from "effect/Schema";
+export declare const laneMaxLength = 512;
+export declare const laneSchema: Schema.String;

package/dist/internal/lane.js

@@ -0,0 +1,6 @@
+import * as Schema from "effect/Schema";
+// A 256-character identity plus "team-key:" is 265 characters ("member:"
+// needs 263). Leave composition headroom without changing the identity or
+// widening job/queue identifiers. Admission, storage and runtime share this bound.
+export const laneMaxLength = 512;
+export const laneSchema = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(laneMaxLength));

package/dist/internal/promise-watchdog-host.d.ts

@@ -0,0 +1,4 @@
+import type { EffectWatchdogOptions } from "../effect.js";
+import type { WatchdogOptions } from "../index.js";
+/** Lift Promise host ports into the Effect-owned runtime. */
+export declare const adaptPromiseWatchdogHost: (options: WatchdogOptions) => EffectWatchdogOptions;

package/dist/internal/promise-watchdog-host.js

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import { WatchdogError } from "./watchdog-error.js";
+/** Lift Promise host ports into the Effect-owned runtime. */
+export const adaptPromiseWatchdogHost = (options) => {
+    return {
+        owner: options.owner,
+        project: options.project,
+        isAlive: (job) => Effect.tryPromise({
+            try: () => options.isAlive(job),
+            catch: (error) => new WatchdogError("liveness_unavailable", error),
+        }),
+        executor: {
+            execute: (job) => Effect.tryPromise({
+                try: (signal) => options.execute(job, signal),
+                catch: () => new WatchdogError("execution_failed"),
+            }),
+        },
+        wake: {
+            recompute: () => Effect.tryPromise({
+                try: () => options.wake.recompute(),
+                catch: () => new WatchdogError("wake_unavailable"),
+            }),
+        },
+    };
+};

package/dist/internal/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { EffectWatchdogOptions, WatchdogRuntimeEffect } from "../effect.js";
+import type { WatchdogStore } from "./sqlite-store.js";
+export declare const bindWatchdogEngine: (options: Pick<EffectWatchdogOptions, "isAlive" | "executor" | "wake">, store: WatchdogStore) => Omit<WatchdogRuntimeEffect, "transactional">;

package/dist/internal/runtime.js

@@ -0,0 +1,199 @@
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { WatchdogError } from "./watchdog-error.js";
+import { watchdogIds } from "./identities.js";
+/**
+ * The engine's own reason for an executor exit that returned no decision: the
+ * executor's typed failure code, an unexpected defect, or an interruption.
+ */
+function failureReasonOf(cause) {
+    if (Cause.hasInterruptsOnly(cause))
+        return "execution_interrupted";
+    const failure = Cause.findErrorOption(cause);
+    return failure._tag === "Some" ? failure.value.cause : "execution_defect";
+}
+export const bindWatchdogEngine = (options, store) => {
+    let tickState = "idle";
+    let activeExecution;
+    const ingest = (job) => store.ingest(job);
+    const read = (jobId) => store.read(jobId).pipe(Effect.map((result) => result.status === "missing"
+        ? result
+        : {
+            status: "found",
+            job: result.job,
+            cancellation: result.cancellation,
+        }));
+    const readQueueHead = (queue) => store.readQueueHead(queue);
+    const readSettled = (limit, afterSequence) => store.readSettled(limit, afterSequence);
+    const cancel = (input) => store.recordCancellation(input).pipe(Effect.tap((result) => {
+        if (result.status !== "recorded" && result.status !== "replayed")
+            return Effect.void;
+        const active = activeExecution;
+        return active?.jobId === input.jobId
+            ? Effect.sync(() => {
+                // Tick retains the fiber and awaits cleanup before settlement.
+                active.fiber.interruptUnsafe();
+            })
+            : options.wake.recompute();
+    }));
+    const failLane = (input) => store.failLane(input).pipe(Effect.tap((result) => {
+        const active = activeExecution;
+        const failed = result.jobs.find((job) => job.jobId === active?.jobId);
+        if (active !== undefined && failed !== undefined) {
+            active.failed = failed;
+            active.fiber.interruptUnsafe();
+        }
+        return result.jobs.length === 0
+            ? Effect.void
+            : options.wake.recompute();
+    }), Effect.map(({ jobs, more }) => ({ settled: jobs.length, more })));
+    const purge = (queue) => store.purgeQueued(queue);
+    const claimNext = () => Effect.try({
+        try: () => watchdogIds.claim.generate(),
+        catch: () => new WatchdogError("claim_unavailable"),
+    }).pipe(Effect.flatMap((claimToken) => store.selectAndClaim(claimToken)));
+    const inspectDisappearedClaim = () => {
+        return Effect.gen(function* () {
+            const claim = yield* store.nextRunningClaim();
+            if (claim === undefined)
+                return { status: "none" };
+            const probe = yield* Effect.result(options.isAlive(claim.job));
+            // A failed probe is not an answer: never alive, never dead.
+            if (probe._tag === "Failure")
+                return {
+                    status: "liveness_unknown",
+                    jobId: claim.job.jobId,
+                    reason: probe.failure.cause,
+                };
+            if (probe.success)
+                return { status: "none" };
+            const disposition = claim.job.recovery !== undefined &&
+                claim.recoveryCount < claim.job.recovery.maxRecoveries
+                ? "requeue"
+                : "interrupted";
+            const result = yield* store.reconcileDisappearedClaim({
+                ...claim,
+                disposition,
+            });
+            switch (result.status) {
+                case "requeued":
+                    yield* options.wake.recompute();
+                    return { status: "none" };
+                case "settled":
+                    yield* options.wake.recompute();
+                    return { status: "recovered", job: result.job };
+                case "conflict":
+                case "missing": {
+                    // This is an observer's recovery attempt, not its own execution claim.
+                    // Another owner can advance the stored generation during the probe.
+                    const current = yield* store.read(claim.job.jobId);
+                    if (current.status === "found" &&
+                        (current.job.state !== "running" ||
+                            current.claimToken !== claim.claimToken ||
+                            current.recoveryCount !== claim.recoveryCount))
+                        return { status: "none" };
+                    return yield* Effect.fail(new WatchdogError("settlement_rejected"));
+                }
+            }
+        });
+    };
+    const tick = () => Effect.suspend(() => {
+        if (tickState !== "idle")
+            return Effect.succeed({ status: "busy" });
+        tickState = "running";
+        return inspectDisappearedClaim().pipe(Effect.flatMap((inspection) => {
+            if (inspection.status === "recovered")
+                return Effect.succeed({
+                    status: "recovered",
+                    job: inspection.job,
+                });
+            // Other work still proceeds; only an otherwise idle tick has
+            // nothing to say but the unanswered probe.
+            return claimNext().pipe(Effect.map((selection) => selection.status === "no_ready" &&
+                inspection.status === "liveness_unknown"
+                ? inspection
+                : selection));
+        }), Effect.flatMap((selection) => {
+            if (selection.status === "no_ready")
+                return Effect.succeed({ status: "no_ready" });
+            if (selection.status === "liveness_unknown")
+                return Effect.succeed(selection);
+            if (selection.status === "claim_unavailable")
+                return Effect.fail(new WatchdogError("claim_unavailable"));
+            if (selection.status === "cancelled")
+                return options.wake.recompute().pipe(Effect.as({
+                    status: "settled",
+                    job: selection.job,
+                }));
+            if (selection.status === "recovered")
+                return Effect.succeed({
+                    status: "settled",
+                    job: selection.job,
+                });
+            return Effect.gen(function* () {
+                const start = yield* Deferred.make();
+                const fiber = yield* Effect.forkChild(Deferred.await(start).pipe(Effect.andThen(options.executor.execute(selection.job))));
+                const owned = {
+                    jobId: selection.job.jobId,
+                    fiber,
+                };
+                activeExecution = owned;
+                const current = yield* store.read(selection.job.jobId);
+                if (current.status !== "found" ||
+                    current.job.state !== "running" ||
+                    current.cancellation.status === "present") {
+                    if (current.status === "found" &&
+                        current.job.state === "settled" &&
+                        current.job.outcome === "failed")
+                        owned.failed = current.job;
+                    yield* Fiber.interrupt(fiber);
+                }
+                else
+                    yield* Deferred.succeed(start, undefined);
+                const execution = yield* Fiber.await(fiber).pipe(Effect.ensuring(Effect.sync(() => {
+                    if (activeExecution?.fiber === fiber)
+                        activeExecution = undefined;
+                })));
+                if (owned.failed !== undefined)
+                    return yield* options.wake
+                        .recompute()
+                        .pipe(Effect.as({ status: "settled", job: owned.failed }));
+                const decision = Exit.isSuccess(execution)
+                    ? execution.value
+                    : { kind: "failed", reason: failureReasonOf(execution.cause) };
+                const settled = yield* store.settleExactClaim({
+                    jobId: selection.job.jobId,
+                    claimToken: selection.claimToken,
+                    decision,
+                });
+                switch (settled.status) {
+                    case "settled":
+                    case "replayed":
+                        return yield* options.wake.recompute().pipe(Effect.as({
+                            status: "settled",
+                            job: settled.job,
+                        }));
+                    case "conflict":
+                    case "missing":
+                        return yield* Effect.fail(new WatchdogError("settlement_rejected"));
+                }
+            });
+        }), Effect.ensuring(Effect.sync(() => {
+            tickState = "idle";
+        })));
+    });
+    return Object.freeze({
+        hasPendingWork: store.hasPendingWork,
+        ingest,
+        read,
+        readQueueHead,
+        readSettled,
+        tick,
+        cancel,
+        failLane,
+        purge,
+    });
+};