waterplane 0.0.1 → 0.1.6

package/packages/host/dist/intents/manager.d.ts

@@ -0,0 +1,239 @@
+/**
+ * The Intent store: one file, one tick, one lifecycle, one place a piece of
+ * deferred work can be.
+ *
+ * ── What this replaces, and why it is a store rather than a fourth manager ──
+ *
+ * `launch.ts` and `schedule.ts` were the same 240 lines twice — launch's own
+ * header admits "shape borrowed wholesale from `schedule.ts`" — and both were
+ * right about the two rules that matter:
+ *
+ *   • at-most-once by an ID the client minted, upserted on replay;
+ *   • the mutating state persisted BEFORE the side effect.
+ *
+ * What they were wrong about is that there were two of them. Five subsystems
+ * said "queued" and meant five different things, each with its own JSON file,
+ * its own poll loop and its own failure ladder, and the sixth — the phone's
+ * send queue — deleted work on a clock. This is that pattern generalized, with
+ * the other five to be folded in behind it.
+ *
+ * ── The rules this file exists to keep ──────────────────────────────────────
+ *
+ * **`op.ack ok` means "on the desktop's disk".** Not "accepted", not "in
+ * memory": the whole promise being made to the user is that the moment the ack
+ * lands the phone may forget the words, so `post()` persists SYNCHRONOUSLY and
+ * the caller acks afterwards. The ordering is store → ack ledger → socket, and
+ * it is the reason `post` is not async.
+ *
+ * **`starting` is written before the executor runs.** A crash between the two
+ * leaves a row that is visibly stuck, never two claude processes in one
+ * worktree and never a sweep that runs twice. Same argument for an `at`
+ * trigger's `lastOccurrence`, which is stamped before the fire, exactly as
+ * `schedule.ts` did.
+ *
+ * **At-most-once by intent id, forever.** The ack ledger's TTL is 45 minutes
+ * and a `files` trigger may wait six hours; a row that outlived its ack record
+ * used to re-execute on a retry. The id lives in this store for the row's whole
+ * life, so a replayed post finds the row and returns it. That second guard is
+ * what will make deleting the phone's 30-minute TTL safe.
+ *
+ * **Nothing is armed with a timer.** A tick re-asks the pure rule
+ * (`@waterplane/shared`'s `intentVerdict`), so a restart, a laptop sleep, a clock
+ * jump and a DST switch cannot mis-fire anything. Events that make an answer
+ * change — an upload landing, a turn ending, a post — kick the tick rather than
+ * scheduling their own.
+ *
+ * **Eviction is compaction, never deletion of un-run work.** Nothing queued,
+ * blocked, starting, running or recurring may leave the file at all, and what
+ * does leave is appended to `intents-archive.jsonl` first. "Where did my words
+ * go" has to have an answer, always.
+ *
+ * **Recurrence decides the list, and a one-off RUNS ITSELF.** An `at` trigger
+ * is not one thing: a standing rule is a clock to arm, pause and skip, while a
+ * one-off aimed at one place is waiting work that happens to carry an instant
+ * (`@waterplane/shared`'s `isTimedWorkRow`). Three rules in this file turn on that
+ * distinction and each of them was wrong for a one-off before it existed:
+ * `execute()` only hands a `schedule:work` row to the child-making executor
+ * when it is a standing rule — a one-off used to be TWO rows, and the first
+ * could fail at rung 3 before the second existed, which is how seven of this
+ * desktop's items ended up failed and in no backlog at all; `fire()` only
+ * returns a hand-run row to `queued` when it has a next run to protect; and
+ * `update()` may revive a FAILED one-off, because a row whose one instant has
+ * passed is exactly the row a person still means.
+ */
+import { EventEmitter } from "node:events";
+import type { Intent, IntentDraft, IntentPatch, IntentRequeue, IntentTarget, ItemName, NameAuthor } from "@waterplane/shared";
+import { type IntentDeps } from "./contract.js";
+import { DiskSlice } from "./disk.js";
+import { WriteSlice } from "./write.js";
+/**
+ * Origins the manager ROUTES on.
+ *
+ * `origin` is otherwise free-form provenance ("rescue", "retry:<id>", a fan-out
+ * target). These two are the schedule adapters, and they exist because "at
+ * 03:00, queue a work item in this repo" needs no session to be READY — which
+ * the ladder expresses as a `fresh` repo target — while what it actually does is
+ * add a row rather than spawn anything. Two shapes, one target: the origin is
+ * what tells them apart, and the fan-out's targets and follow-ups are routed the
+ * same way for the same reason.
+ */
+export { ORIGIN_SCHEDULE_WORK, ORIGIN_SCHEDULE_SWEEP } from "@waterplane/shared";
+export type { ExecutorResult, IntentExecutors, IntentDeps } from "./contract.js";
+export declare class IntentManager extends EventEmitter {
+    private readonly deps;
+    private rows;
+    private timer;
+    /** Ids whose executor is in flight, so a tick cannot re-enter a slow spawn.
+     *  The persisted `starting` state covers restarts; this covers overlap. */
+    private readonly inflight;
+    private ticking;
+    /**
+     * The last repo listing a pass actually took, for `wouldNotRun()`.
+     *
+     * `IntentDeps.knownDirs()` is async and a pass only spends it when a LIVE row
+     * is aimed at `repos`; the pre-flight is synchronous and runs off a wire op,
+     * so it reuses this rather than going and getting one. `null` until a pass
+     * has read one, and `null` is read as "nobody said" there — never as "none of
+     * those repos exist", which is the answer that would refuse a sweep on a
+     * listing this host has never seen.
+     */
+    private lastKnownDirs;
+    /**
+     * The completion baseline: the target session's finished-turn count at the
+     * moment BEFORE anything was typed. The row completes on the first `Stop`
+     * past it — its own turn's end — so the pre-delivery Stop that made the
+     * session ready in the first place cannot instantly complete it.
+     *
+     * In memory, deliberately: a stop count is per-boot, and a row that was
+     * `running` when the process died is reconciled from the CLI's own log
+     * instead. This is the backlog's `fireStop`, moved here so there is one copy
+     * for every executor rather than one per manager.
+     */
+    private readonly stopBase;
+    /**
+     * A `Stop` seen while the row was still `starting`.
+     *
+     * Delivery is not instant, and on a fast turn the agent can finish before
+     * `deliverPrompt` has finished proving that it typed. The turn-end signal
+     * arrives against a row that is not yet `running`, and dropping it would
+     * leave that row waiting for ever for a Stop that already happened.
+     */
+    private readonly stopSeen;
+    /** How each `running` row is allowed to finish — see `ExecutorResult.watch`. */
+    private readonly watchMode;
+    /**
+     * Rows `reconcile()` RE-ADOPTED: delivered before a restart, into a session
+     * that came back with it (tmux), so they went back to `running` rather than
+     * being settled off the log. Only the sentence depends on it — the row still
+     * finishes on its Stop or on the silence sweep, like any other — but that
+     * sentence is the one place a person learns the ending was watched across a
+     * restart rather than seen whole. In memory, like `stopBase`: a second
+     * restart re-adopts it again.
+     */
+    private readonly readopted;
+    /** Every slice's way in — see the constructor. */
+    private readonly core;
+    /** `intents.json`, its archive and the boot conversions (`intents/disk.ts`). */
+    private readonly disk;
+    /** The write verbs — post, upsert and the edits (`intents/write.ts`). */
+    private readonly writer;
+    /** The tick's pass over the pending rows, and `block` (`intents/ladder.ts`). */
+    private readonly ladder;
+    /** Firing one row and the transitions it ends in (`intents/fire.ts`). */
+    private readonly fireSlice;
+    /** Completion and restart reconciliation; owns `reconciled` (`intents/watch.ts`). */
+    private readonly watch;
+    constructor(deps: IntentDeps);
+    /** Newest first — the order every list in this app is read in. */
+    list(): Intent[];
+    get(id: string): Intent | undefined;
+    /** Rows still expecting to run — what a badge counts. */
+    pending(): Intent[];
+    post(draft: IntentDraft, now?: number): {
+        ok: boolean;
+        intent?: Intent;
+        existing?: boolean;
+        reason?: string;
+    };
+    upsert(draft: IntentDraft, now?: number): Intent | null;
+    waive(id: string, rung: string, on: boolean): {
+        ok: boolean;
+        reason?: string;
+    };
+    update(id: string, patch: IntentPatch, now?: number): {
+        ok: boolean;
+        reason?: string;
+    };
+    retarget(id: string, target: IntentTarget, cwd?: string, now?: number): {
+        ok: boolean;
+        reason?: string;
+    };
+    edit(id: string, patch: Parameters<WriteSlice["edit"]>[1]): {
+        ok: boolean;
+        refused?: string;
+    };
+    name(id: string, n: ItemName, by: Exclude<NameAuthor, "hand">): {
+        headline: boolean;
+        category: boolean;
+    };
+    markDone(id: string, detail?: string): boolean;
+    requeue(id: string, opts?: {
+        allowDone?: true;
+        by?: IntentRequeue["by"];
+    }): boolean;
+    requeueFailed(id: string, by: {
+        kind: "assess";
+        runId: string;
+    } | {
+        kind: "hand";
+    } | {
+        kind: "run";
+    }, opts?: {
+        kick?: false;
+    }): {
+        ok: boolean;
+        reason?: string;
+    };
+    emitChanged(): void;
+    cancel(id: string, reason?: string): boolean;
+    dismiss(id: string): boolean;
+    remove(id: string): boolean;
+    runNow(id: string): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    noteSession(id: string, sessionId: string): void;
+    fileLanded(cwd: string): void;
+    start(): void;
+    stop(): void;
+    kick(): void;
+    private tick;
+    /** `ladderpass.test.mjs` calls `store.pass()` — the body is `intents/ladder.ts`. */
+    private pass;
+    onTurnEnded(sessionId: string, stopCount: number): void;
+    onSessionExit(sessionId: string): void;
+    /** Called once by `main.ts`, after `sessions.rediscover()`. */
+    reconcile(): Promise<void>;
+    /** `requeue.test.mjs` calls `store.fire(row, {})`, and the core's `fire` arrow forwards here — the body is `intents/fire.ts`. */
+    private fire;
+    /** `backlogedit.test.mjs` calls `store.settle(…)`, and the core's `settle` arrow forwards here — the body is `intents/fire.ts`. */
+    private settle;
+    skipNext(id: string): {
+        ok: boolean;
+        reason?: string;
+        nextAt?: number | null;
+    };
+    setArmed(id: string, armed: boolean): boolean;
+    migrateLegacy(convert: Parameters<DiskSlice["migrateLegacy"]>[0]): void;
+    migrateFileAt(src: string, label: string, convert: (raw: unknown, now: number) => IntentDraft[]): void;
+    /** Write now, whatever a debounce would have said. Called on SIGTERM. */
+    flush(): void;
+    /** `intents.json`: the read-only sentence (a newer schema), why the last write failed (null once one landed), and the boot feed row `main.ts` notifies (`intents/disk.ts`). */
+    readOnly(): string | null;
+    lastWriteError(): string | null;
+    storeNotice(): {
+        title: string;
+        body: string;
+        tag: string;
+    } | null;
+}

package/packages/host/dist/intents/manager.js

@@ -0,0 +1,292 @@
+/**
+ * The Intent store: one file, one tick, one lifecycle, one place a piece of
+ * deferred work can be.
+ *
+ * ── What this replaces, and why it is a store rather than a fourth manager ──
+ *
+ * `launch.ts` and `schedule.ts` were the same 240 lines twice — launch's own
+ * header admits "shape borrowed wholesale from `schedule.ts`" — and both were
+ * right about the two rules that matter:
+ *
+ *   • at-most-once by an ID the client minted, upserted on replay;
+ *   • the mutating state persisted BEFORE the side effect.
+ *
+ * What they were wrong about is that there were two of them. Five subsystems
+ * said "queued" and meant five different things, each with its own JSON file,
+ * its own poll loop and its own failure ladder, and the sixth — the phone's
+ * send queue — deleted work on a clock. This is that pattern generalized, with
+ * the other five to be folded in behind it.
+ *
+ * ── The rules this file exists to keep ──────────────────────────────────────
+ *
+ * **`op.ack ok` means "on the desktop's disk".** Not "accepted", not "in
+ * memory": the whole promise being made to the user is that the moment the ack
+ * lands the phone may forget the words, so `post()` persists SYNCHRONOUSLY and
+ * the caller acks afterwards. The ordering is store → ack ledger → socket, and
+ * it is the reason `post` is not async.
+ *
+ * **`starting` is written before the executor runs.** A crash between the two
+ * leaves a row that is visibly stuck, never two claude processes in one
+ * worktree and never a sweep that runs twice. Same argument for an `at`
+ * trigger's `lastOccurrence`, which is stamped before the fire, exactly as
+ * `schedule.ts` did.
+ *
+ * **At-most-once by intent id, forever.** The ack ledger's TTL is 45 minutes
+ * and a `files` trigger may wait six hours; a row that outlived its ack record
+ * used to re-execute on a retry. The id lives in this store for the row's whole
+ * life, so a replayed post finds the row and returns it. That second guard is
+ * what will make deleting the phone's 30-minute TTL safe.
+ *
+ * **Nothing is armed with a timer.** A tick re-asks the pure rule
+ * (`@waterplane/shared`'s `intentVerdict`), so a restart, a laptop sleep, a clock
+ * jump and a DST switch cannot mis-fire anything. Events that make an answer
+ * change — an upload landing, a turn ending, a post — kick the tick rather than
+ * scheduling their own.
+ *
+ * **Eviction is compaction, never deletion of un-run work.** Nothing queued,
+ * blocked, starting, running or recurring may leave the file at all, and what
+ * does leave is appended to `intents-archive.jsonl` first. "Where did my words
+ * go" has to have an answer, always.
+ *
+ * **Recurrence decides the list, and a one-off RUNS ITSELF.** An `at` trigger
+ * is not one thing: a standing rule is a clock to arm, pause and skip, while a
+ * one-off aimed at one place is waiting work that happens to carry an instant
+ * (`@waterplane/shared`'s `isTimedWorkRow`). Three rules in this file turn on that
+ * distinction and each of them was wrong for a one-off before it existed:
+ * `execute()` only hands a `schedule:work` row to the child-making executor
+ * when it is a standing rule — a one-off used to be TWO rows, and the first
+ * could fail at rung 3 before the second existed, which is how seven of this
+ * desktop's items ended up failed and in no backlog at all; `fire()` only
+ * returns a hand-run row to `queued` when it has a next run to protect; and
+ * `update()` may revive a FAILED one-off, because a row whose one instant has
+ * passed is exactly the row a person still means.
+ */
+import { EventEmitter } from "node:events";
+import { TICK_MS, isTerminal } from "./contract.js";
+import { armFrom, armNew, newBasis, setArmed, skipNext } from "./clock.js";
+import { DiskSlice } from "./disk.js";
+import { WriteSlice } from "./write.js";
+import * as putback from "./requeue.js";
+import { LadderSlice } from "./ladder.js";
+import { FireSlice } from "./fire.js";
+import { WatchSlice } from "./watch.js";
+/**
+ * Origins the manager ROUTES on.
+ *
+ * `origin` is otherwise free-form provenance ("rescue", "retry:<id>", a fan-out
+ * target). These two are the schedule adapters, and they exist because "at
+ * 03:00, queue a work item in this repo" needs no session to be READY — which
+ * the ladder expresses as a `fresh` repo target — while what it actually does is
+ * add a row rather than spawn anything. Two shapes, one target: the origin is
+ * what tells them apart, and the fan-out's targets and follow-ups are routed the
+ * same way for the same reason.
+ */
+// Defined in `@waterplane/shared` (the phone asks `queuesBacklogItem` too), re-exported
+// here for the adapters that have always imported them from this file.
+export { ORIGIN_SCHEDULE_WORK, ORIGIN_SCHEDULE_SWEEP } from "@waterplane/shared";
+export class IntentManager extends EventEmitter {
+    deps;
+    rows = [];
+    timer = null;
+    /** Ids whose executor is in flight, so a tick cannot re-enter a slow spawn.
+     *  The persisted `starting` state covers restarts; this covers overlap. */
+    inflight = new Map();
+    ticking = false;
+    /**
+     * The last repo listing a pass actually took, for `wouldNotRun()`.
+     *
+     * `IntentDeps.knownDirs()` is async and a pass only spends it when a LIVE row
+     * is aimed at `repos`; the pre-flight is synchronous and runs off a wire op,
+     * so it reuses this rather than going and getting one. `null` until a pass
+     * has read one, and `null` is read as "nobody said" there — never as "none of
+     * those repos exist", which is the answer that would refuse a sweep on a
+     * listing this host has never seen.
+     */
+    lastKnownDirs = null;
+    /**
+     * The completion baseline: the target session's finished-turn count at the
+     * moment BEFORE anything was typed. The row completes on the first `Stop`
+     * past it — its own turn's end — so the pre-delivery Stop that made the
+     * session ready in the first place cannot instantly complete it.
+     *
+     * In memory, deliberately: a stop count is per-boot, and a row that was
+     * `running` when the process died is reconciled from the CLI's own log
+     * instead. This is the backlog's `fireStop`, moved here so there is one copy
+     * for every executor rather than one per manager.
+     */
+    stopBase = new Map();
+    /**
+     * A `Stop` seen while the row was still `starting`.
+     *
+     * Delivery is not instant, and on a fast turn the agent can finish before
+     * `deliverPrompt` has finished proving that it typed. The turn-end signal
+     * arrives against a row that is not yet `running`, and dropping it would
+     * leave that row waiting for ever for a Stop that already happened.
+     */
+    stopSeen = new Map();
+    /** How each `running` row is allowed to finish — see `ExecutorResult.watch`. */
+    watchMode = new Map();
+    /**
+     * Rows `reconcile()` RE-ADOPTED: delivered before a restart, into a session
+     * that came back with it (tmux), so they went back to `running` rather than
+     * being settled off the log. Only the sentence depends on it — the row still
+     * finishes on its Stop or on the silence sweep, like any other — but that
+     * sentence is the one place a person learns the ending was watched across a
+     * restart rather than seen whole. In memory, like `stopBase`: a second
+     * restart re-adopts it again.
+     */
+    readopted = new Set();
+    /** Every slice's way in — see the constructor. */
+    core;
+    /** `intents.json`, its archive and the boot conversions (`intents/disk.ts`). */
+    disk;
+    /** The write verbs — post, upsert and the edits (`intents/write.ts`). */
+    writer;
+    /** The tick's pass over the pending rows, and `block` (`intents/ladder.ts`). */
+    ladder;
+    /** Firing one row and the transitions it ends in (`intents/fire.ts`). */
+    fireSlice;
+    /** Completion and restart reconciliation; owns `reconciled` (`intents/watch.ts`). */
+    watch;
+    constructor(deps) {
+        super();
+        this.deps = deps;
+        // The ONE object every slice reaches shared state through (`IntentCore`,
+        // intents/contract.ts). Each member delegates at CALL time to the slice that
+        // owns the method, grouped below by owning slice.
+        this.core = {
+            // facade
+            deps: this.deps,
+            rows: () => this.rows,
+            setRows: (next) => { this.rows = next; },
+            inflight: this.inflight,
+            stopBase: this.stopBase,
+            stopSeen: this.stopSeen,
+            watchMode: this.watchMode,
+            readopted: this.readopted,
+            lastKnownDirs: () => this.lastKnownDirs,
+            setLastKnownDirs: (dirs) => { this.lastKnownDirs = dirs; },
+            emit: (event, ...args) => { this.emit(event, ...args); },
+            kick: () => this.kick(),
+            get: (id) => this.get(id),
+            pending: () => this.pending(),
+            // disk
+            persist: () => this.disk.persist(),
+            lastWriteError: () => this.disk.lastWriteError(),
+            readOnly: () => this.disk.readOnly(),
+            archive: (rows) => this.disk.archive(rows),
+            chainFacts: () => this.disk.chainFacts(),
+            present: (cwd, rel) => this.disk.present(cwd, rel),
+            // clock
+            armNew: (row, now) => armNew(this.core, row, now),
+            newBasis: (row) => newBasis(row),
+            armFrom: (row, basis, now) => armFrom(this.core, row, basis, now),
+            // ladder
+            pass: () => this.ladder.pass(),
+            // fire
+            fire: (row, opts) => this.fire(row, opts),
+            settle: (row, state, result, missing) => this.settle(row, state, result, missing),
+            replace: (row) => this.fireSlice.replace(row),
+            resolveSessionFor: (row) => this.fireSlice.resolveSessionFor(row),
+            unspend: (row, occurrence) => this.fireSlice.unspend(row, occurrence),
+            stampCleared: (row, occurrence) => this.fireSlice.stampCleared(row, occurrence),
+            recordMissed: (row, occurrence, detail, now) => this.fireSlice.recordMissed(row, occurrence, detail, now),
+            // watch
+            complete: (row, detail, now) => this.watch.complete(row, detail, now),
+            sweepRunning: (now) => this.watch.sweepRunning(now),
+        };
+        this.disk = new DiskSlice(this.core);
+        this.writer = new WriteSlice(this.core);
+        this.ladder = new LadderSlice(this.core);
+        this.fireSlice = new FireSlice(this.core);
+        this.watch = new WatchSlice(this.core);
+        this.disk.load();
+        this.disk.foldLegacyWorkParents();
+    }
+    // ── Reading ───────────────────────────────────────────────────────────────
+    /** Newest first — the order every list in this app is read in. */
+    list() {
+        return [...this.rows].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    get(id) {
+        return this.rows.find((r) => r.id === id);
+    }
+    /** Rows still expecting to run — what a badge counts. */
+    pending() {
+        return this.rows.filter((r) => !isTerminal(r));
+    }
+    // ── Writing — delegations (`intents/write.ts`) ─────────────────────────────
+    post(draft, now = Date.now()) { return this.writer.post(draft, now); }
+    upsert(draft, now = Date.now()) { return this.writer.upsert(draft, now); }
+    waive(id, rung, on) { return this.writer.waive(id, rung, on); }
+    update(id, patch, now = Date.now()) { return this.writer.update(id, patch, now); }
+    retarget(id, target, cwd, now = Date.now()) { return this.writer.retarget(id, target, cwd, now); }
+    edit(id, patch) { return this.writer.edit(id, patch); }
+    name(id, n, by) { return this.writer.name(id, n, by); }
+    // ── Row verbs — delegations (`intents/requeue.ts`) ─────────────────────────
+    markDone(id, detail = "marked done by hand") { return putback.markDone(this.core, id, detail); }
+    requeue(id, opts) { return putback.requeue(this.core, id, opts); }
+    requeueFailed(id, by, opts) { return putback.requeueFailed(this.core, id, by, opts); }
+    emitChanged() { putback.emitChanged(this.core); }
+    cancel(id, reason = "called off from the phone") { return putback.cancel(this.core, id, reason); }
+    dismiss(id) { return putback.dismiss(this.core, id); }
+    remove(id) { return putback.remove(this.core, id); }
+    runNow(id) { return putback.runNow(this.core, id); }
+    noteSession(id, sessionId) { putback.noteSession(this.core, id, sessionId); }
+    fileLanded(cwd) { putback.fileLanded(this.core, cwd); }
+    // ── The loop ──────────────────────────────────────────────────────────────
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.kick(), TICK_MS);
+        if (typeof this.timer.unref === "function")
+            this.timer.unref();
+        this.kick();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    kick() {
+        void this.tick();
+    }
+    async tick() {
+        // Reconciliation decides what half the rows even mean; a tick before it
+        // would re-fire work that may already have run.
+        if (!this.watch.reconciled || this.ticking)
+            return;
+        this.ticking = true;
+        try {
+            await this.pass();
+        }
+        catch { /* a verdict that threw is one missed pass, not a dead loop */ }
+        finally {
+            this.ticking = false;
+        }
+    }
+    /** `ladderpass.test.mjs` calls `store.pass()` — the body is `intents/ladder.ts`. */
+    pass() { return this.ladder.pass(); }
+    // ── Completion and restart reconciliation — delegations (`intents/watch.ts`) ──
+    onTurnEnded(sessionId, stopCount) { this.watch.onTurnEnded(sessionId, stopCount); }
+    onSessionExit(sessionId) { this.watch.onSessionExit(sessionId); }
+    /** Called once by `main.ts`, after `sessions.rediscover()`. */
+    reconcile() { return this.watch.reconcile(); }
+    // ── Firing — delegations (`intents/fire.ts`) ─────────────────────────────
+    /** `requeue.test.mjs` calls `store.fire(row, {})`, and the core's `fire` arrow forwards here — the body is `intents/fire.ts`. */
+    fire(row, opts) { return this.fireSlice.fire(row, opts); }
+    /** `backlogedit.test.mjs` calls `store.settle(…)`, and the core's `settle` arrow forwards here — the body is `intents/fire.ts`. */
+    settle(row, state, result, missing) { this.fireSlice.settle(row, state, result, missing); }
+    // ── Delegations: the clock (`intents/clock.ts`) and the disk (`intents/disk.ts`) ──
+    skipNext(id) { return skipNext(this.core, id); }
+    setArmed(id, armed) { return setArmed(this.core, id, armed); }
+    migrateLegacy(convert) { this.disk.migrateLegacy(convert); }
+    migrateFileAt(src, label, convert) { this.disk.migrateFileAt(src, label, convert); }
+    /** Write now, whatever a debounce would have said. Called on SIGTERM. */
+    flush() { this.disk.flush(); }
+    /** `intents.json`: the read-only sentence (a newer schema), why the last write failed (null once one landed), and the boot feed row `main.ts` notifies (`intents/disk.ts`). */
+    readOnly() { return this.disk.readOnly(); }
+    lastWriteError() { return this.disk.lastWriteError(); }
+    storeNotice() { return this.disk.storeNotice(); }
+}
+//# sourceMappingURL=manager.js.map

package/packages/host/dist/intents/manager.js.map

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