waterplane 0.0.1 → 0.1.6

package/packages/host/dist/assess/hassapply.d.ts

@@ -0,0 +1,127 @@
+import type { AssessChoices, Intent } from "@waterplane/shared";
+import { type AssessIntents } from "./hassexec.js";
+import { AssessStore } from "./hassstore.js";
+/**
+ * **The clock a merged row carries.** Absent `carry` = no member runs on a
+ * one-off clock, which is the untimed post every merge made before.
+ *
+ * Before this, a merge was ALWAYS posted untimed (`backlogDraft`'s `idle`), so
+ * merging a row timed for the 18:00 reset made the merged work run at the next
+ * free moment — earlier than the person asked. Now the merged row takes the
+ * LATEST one-off clock among its members (`latestClock`, with that member's
+ * whole trigger — grace included — and its `holdForHost`), so it never runs
+ * before any member asked. An untimed member is content to wait, so it does
+ * not stop the merge; a recurring member is a standing rule, not one piece of
+ * work, and its clock is never copied onto a one-off. A near-tie between two
+ * DIFFERENT clocks, or a timed member not yet armed, is refused in words —
+ * `latestClock`'s null is "cannot tell which is later", and a guess there is
+ * exactly a merged row running before one member asked.
+ */
+export declare function mergeClock(members: readonly (Intent | undefined)[]): {
+    carry?: Pick<Intent, "trigger" | "holdForHost">;
+} | {
+    refused: string;
+};
+/**
+ * **Where a slot merge is posted: its members' lowest seat** (`order ??
+ * createdAt`). The run's `rank` is a small integer — a place WITHIN the slot —
+ * and posted as an `order` it sorted the merged row ahead of the whole
+ * backlog; `reorder` then handed that seat to the first approved row. Seated
+ * among its members, the slot's rows trade only their own seats and a row
+ * outside the slot keeps its place. `fallback` when no member is left to read.
+ */
+export declare function memberSeat(members: readonly string[], fallback: number, get: (id: string) => Intent | undefined): number;
+/**
+ * **The two ids a split posts — the same every time it is applied.** A hash of
+ * (run, split) so a replayed apply (a crash between the posts and
+ * `recordApplied`) is answered by `post()` with the rows it already holds,
+ * never a second pair: at-most-once by intent id.
+ */
+export declare function splitIds(runId: string, sid: string): [string, string];
+/** What one apply did, for the row and for the sentence the phone is told. */
+export interface AssessApplyOutcome {
+    ok: boolean;
+    reason?: string;
+    /** One line naming what happened, including the part that deliberately did
+     *  not happen (pad notes). */
+    detail: string;
+    counts: {
+        dismissed: number;
+        ranked: number;
+        posted: number;
+        requeued: number;
+        named: number;
+    };
+    /**
+     * **The pad notes whose backlog row actually LANDED** (`AssessNew.fromNote`),
+     * and the one field here that is not a reading — it is a receipt somebody
+     * deletes words on.
+     *
+     * The phone clears a ticked offer's note when the apply comes back `ok`. But
+     * `intents.post` can REFUSE a row on its own (`PENDING_MAX`, a draft that
+     * could never run) and the loop simply moves on, so an apply where every post
+     * was refused still answers `ok` with `posted: 0`. Ticked three offers at a
+     * host that is full and the phone tombstoned three notes with no row anywhere
+     * — the only pad delete in this app taken on a REMOTE receipt instead of a
+     * durable local copy, which is exactly why it is the one that loses words.
+     *
+     * So the ids travel, and the phone clears `ticked ∩ filed`. **Present and
+     * empty is a claim** ("this host filed nothing"); **absent is the refusal to
+     * claim** — an older daemon, or an apply that never got as far as posting —
+     * and the phone must then clear nothing and say the notes were left on the
+     * pad. Set on every path that RAN the posts, including the ones that posted
+     * none; left absent by the guards above them.
+     */
+    filed?: string[];
+}
+/**
+ * Perform exactly the mutations `applyAssessment` returned, and nothing else.
+ *
+ * ── Order is load-bearing ──────────────────────────────────────────────────
+ *
+ * The posts go FIRST, because a merge's dismissal reason names the id of the
+ * row that replaces it and that id does not exist until the post lands. The
+ * sentence is rebuilt with `assessDismissReason("merged", evidence, postedId)`
+ * — the same function the pure layer called without it — rather than assembled
+ * here, so the row and the sheet cannot word one fact two ways.
+ *
+ * The re-queues go before the RANKS, for the mirror-image reason: a `wanted`
+ * row that had failed is on both lists, and a position is only a position once
+ * the row is back in the order it names. See the loop.
+ *
+ * ── What "dismiss" means to each store ─────────────────────────────────────
+ *
+ * An intent that has not settled is `cancel`led with the verdict as its reason
+ * — which is what puts the sentence ON the row, where the row is rendered — and
+ * then `dismiss`ed, which is the "a person has seen this" gate a terminal row
+ * must pass. Both are reversible in one tap (`requeue`), and neither deletes
+ * anything. An intent that has ALREADY settled (a `failed` row is assessable)
+ * cannot be cancelled and does not need to be: it is retired, with its own
+ * reason, so it is only dismissed.
+ *
+ * A pad note is STILL NEVER EDITED HERE, and that is a decision rather than a
+ * gap. The pad is a synced setting the daemon stores blind — one opaque string
+ * with one `ts` — and the per-note merge that makes it safe to write is the
+ * CLIENT's (`shared/pad.ts`, run on adopt). All this host could do is replace
+ * the whole string, which is last-write-wins with no diff, on the store whose
+ * entire job is to be the last copy of words with no target yet. So a retiring
+ * verdict on a note is informational: the sheet shows it, and the count says
+ * how many were judged and left on the pad rather than pretending they were
+ * retired.
+ *
+ * What HAS changed is the other verdict. A note the run says is still worth
+ * doing is now OFFERED as an ordinary post carrying the note's own words —
+ * `cleanAssessment` copies them, so the row that lands is the person's
+ * sentence and not a restatement of it — ticked and applied like every other
+ * row on the sheet. This side posts the intent and nothing else: the note's
+ * clearing is the PHONE's, on the receipt for that post, because the phone is
+ * the only half that owns the document the note lives in.
+ *
+ * **And the receipt NAMES the notes, one by one** (`AssessApplyOutcome.filed`,
+ * out on the `op.ack`). `intents.post` refuses on its own — `PENDING_MAX`, a
+ * draft that could never run — and this loop moves on, so `ok` is true of an
+ * apply where not one row landed. A phone clearing every ticked offer on that
+ * `ok` deletes the words and leaves nothing behind them. The ids are the whole
+ * fix, and `filed` being ABSENT is its own answer: clear nothing.
+ */
+export declare function applyProposal(intents: AssessIntents, store: AssessStore, runId: string, choices: AssessChoices, now?: number): AssessApplyOutcome;

package/packages/host/dist/assess/hassapply.js

@@ -0,0 +1,482 @@
+/** A slice of assess.ts — moved whole from assess.ts, see docs/notes/assess-architecture.md (host). */
+import { createHash, randomUUID } from "node:crypto";
+import { assessDismissReason, applyAssessment, itemHeadline, latestClock, ruleRecurs } from "@waterplane/shared";
+import { backlogDraft } from "../intents/adapters.js";
+import { reorder } from "../backlog/backlogedits.js";
+import { ASSESSABLE_STATES } from "./hassknobs.js";
+// ── The slot check's three host halves (2026-10-16) ──────────────────────────
+/**
+ * **The clock a merged row carries.** Absent `carry` = no member runs on a
+ * one-off clock, which is the untimed post every merge made before.
+ *
+ * Before this, a merge was ALWAYS posted untimed (`backlogDraft`'s `idle`), so
+ * merging a row timed for the 18:00 reset made the merged work run at the next
+ * free moment — earlier than the person asked. Now the merged row takes the
+ * LATEST one-off clock among its members (`latestClock`, with that member's
+ * whole trigger — grace included — and its `holdForHost`), so it never runs
+ * before any member asked. An untimed member is content to wait, so it does
+ * not stop the merge; a recurring member is a standing rule, not one piece of
+ * work, and its clock is never copied onto a one-off. A near-tie between two
+ * DIFFERENT clocks, or a timed member not yet armed, is refused in words —
+ * `latestClock`'s null is "cannot tell which is later", and a guess there is
+ * exactly a merged row running before one member asked.
+ */
+export function mergeClock(members) {
+    const timed = members.filter((r) => !!r && r.trigger?.kind === "at" && !ruleRecurs(r.trigger.rule));
+    if (!timed.length)
+        return {};
+    const pick = latestClock(timed.map((row) => ({ rule: row.trigger.rule, nextAt: row.nextAt, row })));
+    if (!pick) {
+        return { refused: "its rows run on clocks too close to tell which is later (or one is not armed yet), so the merged item could have run before one of them asked" };
+    }
+    return { carry: { trigger: pick.row.trigger, holdForHost: pick.row.holdForHost } };
+}
+/**
+ * **Where a slot merge is posted: its members' lowest seat** (`order ??
+ * createdAt`). The run's `rank` is a small integer — a place WITHIN the slot —
+ * and posted as an `order` it sorted the merged row ahead of the whole
+ * backlog; `reorder` then handed that seat to the first approved row. Seated
+ * among its members, the slot's rows trade only their own seats and a row
+ * outside the slot keeps its place. `fallback` when no member is left to read.
+ */
+export function memberSeat(members, fallback, get) {
+    const seats = members.map(get).filter((r) => !!r).map((r) => r.order ?? r.createdAt);
+    return seats.length ? Math.min(...seats) : fallback;
+}
+/**
+ * **The two ids a split posts — the same every time it is applied.** A hash of
+ * (run, split) so a replayed apply (a crash between the posts and
+ * `recordApplied`) is answered by `post()` with the rows it already holds,
+ * never a second pair: at-most-once by intent id.
+ */
+export function splitIds(runId, sid) {
+    const h = createHash("sha1").update(`${runId}\n${sid}`).digest("hex").slice(0, 10);
+    return [`sp_${h}_1`, `sp_${h}_2`];
+}
+/**
+ * One half of a split, on the ORIGINAL row's trigger and everything else that
+ * says where and how it runs — the same slot it was in. Its words are the
+ * run's (the person approved them); the original's `label` is NOT copied: a
+ * title somebody typed for the whole job is not a title for half of it.
+ */
+function splitDraft(orig, id, text, origin, order) {
+    return {
+        id, cwd: orig.cwd,
+        payload: { kind: "prompt", steps: [text] },
+        target: orig.target,
+        trigger: orig.trigger,
+        serial: orig.serial,
+        holdForHost: orig.holdForHost,
+        pastBudget: orig.pastBudget,
+        budgetPass: orig.budgetPass,
+        auto: orig.auto,
+        pinned: orig.pinned,
+        resume: orig.resume,
+        closeWhenDone: orig.closeWhenDone,
+        flagWhenDone: orig.flagWhenDone,
+        manual: orig.manual,
+        ...(orig.budget ? { budget: orig.budget } : {}),
+        ...(orig.launch ? { launch: orig.launch } : {}),
+        order,
+        origin,
+    };
+}
+/** A row's name as the backlog shows it, for a sentence. */
+function rowName(r) {
+    const text = r.payload.kind === "prompt" ? (r.payload.steps[0] ?? "") : "";
+    const name = itemHeadline({ label: r.label, text, headline: r.headline }) ?? text.trim().slice(0, 40);
+    return name || r.id;
+}
+/** States a half may be set aside in — it has not started, so archiving it
+ *  stops it ever running. A half already started is past recall here. */
+const NOT_STARTED = new Set(["queued", "blocked"]);
+/** A chained row in one of these has settled and waits on nothing. */
+const TERMINAL = new Set(["done", "failed", "canceled"]);
+/**
+ * Set aside every half of this split that exists and has not started — not
+ * only the ones THIS call posted. A replay can find half 1 from an earlier,
+ * interrupted apply; left queued beside the untouched original, that job runs
+ * twice. Returns the halves that could NOT be set aside, for the sentence.
+ */
+function setAsideHalves(intents, ids) {
+    const left = [];
+    for (const id of ids) {
+        const h = intents.get(id);
+        if (!h || h.archived)
+            continue;
+        if (!NOT_STARTED.has(h.state) || !intents.edit(id, { archived: true }).ok)
+            left.push(id);
+    }
+    return left;
+}
+/**
+ * Perform one approved split: post both halves, THEN archive the original.
+ * Archive, never cancel or remove — the original is the person's words, kept
+ * whole and one tap from coming back (CLAUDE.md: never overwrite typed words).
+ *
+ * Every way it can stop leaves ONE copy of the job runnable, never two:
+ * a post that fails sets aside every half that exists (this call's or an
+ * earlier one's), and an original whose archive is refused sets aside both
+ * halves and says so. And a split is REFUSED when a live row chains `after`
+ * the original — archiving it would leave that row waiting for ever on a row
+ * that never settles. Refusal, not re-pointing the chain at half 2: moving a
+ * person's chain onto a row they never saw is a rewrite of their trigger, and
+ * "after the whole job" is not the same promise as "after its second half".
+ */
+function applySplit(intents, s, runId) {
+    const ids = splitIds(runId, s.sid);
+    const orig = intents.get(s.id);
+    const replay = ids.every((id) => !!intents.get(id));
+    const refuse = (why) => {
+        const left = setAsideHalves(intents, ids);
+        return { ok: false, why: left.length ? `${why}; ${left.length} half already started and could not be set aside` : why };
+    };
+    if (!replay) {
+        if (!orig)
+            return refuse("that item is gone");
+        if (orig.archived)
+            return refuse("that item was archived in the meantime");
+        if (!ASSESSABLE_STATES.has(orig.state))
+            return refuse(`that item is ${orig.state} now`);
+        const waiter = intents.list().find((r) => r.id !== s.id && !r.archived && r.trigger?.kind === "after"
+            && r.trigger.id === s.id && !TERMINAL.has(r.state));
+        if (waiter)
+            return refuse(`it is waited on by “${rowName(waiter)}”, which would wait for ever behind an archived row — split refused`);
+    }
+    if (!orig)
+        return { ok: true, ids };
+    const base = orig.order ?? orig.createdAt;
+    for (let n = 0; n < ids.length; n++) {
+        const r = intents.post(splitDraft(orig, ids[n], s.texts[n], s.origin, base + n * 0.001));
+        if (!r.ok || !r.intent)
+            return refuse(r.reason || "the new item could not be written");
+    }
+    const archived = intents.edit(s.id, { archived: true });
+    if (!archived.ok) {
+        return refuse(`the original could not be set aside${archived.refused ? ` (${archived.refused})` : ""}, so both halves were set aside instead and the job runs once`);
+    }
+    return { ok: true, ids };
+}
+/**
+ * Perform exactly the mutations `applyAssessment` returned, and nothing else.
+ *
+ * ── Order is load-bearing ──────────────────────────────────────────────────
+ *
+ * The posts go FIRST, because a merge's dismissal reason names the id of the
+ * row that replaces it and that id does not exist until the post lands. The
+ * sentence is rebuilt with `assessDismissReason("merged", evidence, postedId)`
+ * — the same function the pure layer called without it — rather than assembled
+ * here, so the row and the sheet cannot word one fact two ways.
+ *
+ * The re-queues go before the RANKS, for the mirror-image reason: a `wanted`
+ * row that had failed is on both lists, and a position is only a position once
+ * the row is back in the order it names. See the loop.
+ *
+ * ── What "dismiss" means to each store ─────────────────────────────────────
+ *
+ * An intent that has not settled is `cancel`led with the verdict as its reason
+ * — which is what puts the sentence ON the row, where the row is rendered — and
+ * then `dismiss`ed, which is the "a person has seen this" gate a terminal row
+ * must pass. Both are reversible in one tap (`requeue`), and neither deletes
+ * anything. An intent that has ALREADY settled (a `failed` row is assessable)
+ * cannot be cancelled and does not need to be: it is retired, with its own
+ * reason, so it is only dismissed.
+ *
+ * A pad note is STILL NEVER EDITED HERE, and that is a decision rather than a
+ * gap. The pad is a synced setting the daemon stores blind — one opaque string
+ * with one `ts` — and the per-note merge that makes it safe to write is the
+ * CLIENT's (`shared/pad.ts`, run on adopt). All this host could do is replace
+ * the whole string, which is last-write-wins with no diff, on the store whose
+ * entire job is to be the last copy of words with no target yet. So a retiring
+ * verdict on a note is informational: the sheet shows it, and the count says
+ * how many were judged and left on the pad rather than pretending they were
+ * retired.
+ *
+ * What HAS changed is the other verdict. A note the run says is still worth
+ * doing is now OFFERED as an ordinary post carrying the note's own words —
+ * `cleanAssessment` copies them, so the row that lands is the person's
+ * sentence and not a restatement of it — ticked and applied like every other
+ * row on the sheet. This side posts the intent and nothing else: the note's
+ * clearing is the PHONE's, on the receipt for that post, because the phone is
+ * the only half that owns the document the note lives in.
+ *
+ * **And the receipt NAMES the notes, one by one** (`AssessApplyOutcome.filed`,
+ * out on the `op.ack`). `intents.post` refuses on its own — `PENDING_MAX`, a
+ * draft that could never run — and this loop moves on, so `ok` is true of an
+ * apply where not one row landed. A phone clearing every ticked offer on that
+ * `ok` deletes the words and leaves nothing behind them. The ids are the whole
+ * fix, and `filed` being ABSENT is its own answer: clear nothing.
+ */
+export function applyProposal(intents, store, runId, choices, now = Date.now()) {
+    const none = { dismissed: 0, ranked: 0, posted: 0, requeued: 0, named: 0 };
+    const run = store.get(runId);
+    if (!run)
+        return { ok: false, reason: "that assessment is gone", detail: "that assessment is gone", counts: none };
+    if (!run.proposal || !run.input) {
+        return { ok: false, reason: "that run produced no proposal", detail: "that run produced no proposal — nothing was applied", counts: none };
+    }
+    // The second guard past the ack ledger's 45 minutes, and the one that catches
+    // a REPLAY WITH A FRESH ackId: applying twice would post the merge twice.
+    if (run.status === "applied") {
+        // `requeued` is optional on the persisted row — it postdates it — so a run
+        // applied by an older build answers 0 rather than `undefined`, which is the
+        // truth about that apply and not a repair of it.
+        const before = run.applied ? { ...run.applied, requeued: run.applied.requeued ?? 0, named: run.applied.named ?? 0 } : none;
+        return { ok: false, reason: "already applied", detail: "this proposal has already been applied — run a new assessment to judge what is left now", counts: before };
+    }
+    const m = applyAssessment(run.proposal, choices, { runId, items: run.input.items });
+    // ── Posts first: a merge's dismissal names the id that replaces it ──
+    const postedFor = new Map();
+    let posted = 0;
+    /**
+     * …of which THESE are the pad notes the person asked to have filed — by id,
+     * and only once their row is on disk.
+     *
+     * A post either way (`posted` counts them too), but this list is not a
+     * statistic: it goes out on the `op.ack` and the phone deletes the note it
+     * names. So an id joins it strictly after `intents.post` said yes. The count
+     * for the sentence is `filed.length` — one fact, not two.
+     */
+    const filed = [];
+    /** What was approved and NOT done, one sentence each — said in `detail`. */
+    const refused = [];
+    /** A slot check: the ids are rows that fire together (`AssessScope`). */
+    const slotRun = !!(run.scope ?? run.input.scope);
+    /** Posted merge rows and their rank — a slot's order includes them. */
+    const postedRanks = [];
+    for (const p of m.post) {
+        // A merge carries the LATEST member clock, or is refused (`mergeClock`).
+        const members = p.gid ? (run.proposal.merges.find((g) => g.gid === p.gid)?.ids ?? p.sourceIds ?? []) : [];
+        const clock = members.length ? mergeClock(members.map((x) => intents.get(x))) : {};
+        if ("refused" in clock) {
+            refused.push(`merge “${p.gid}” was not applied: ${clock.refused} — its items were left as they were`);
+            continue;
+        }
+        const id = "ai_" + randomUUID().slice(0, 8);
+        /**
+         * **`label` is what a PERSON typed** — never machine bookkeeping. It once held
+         * `merge of 3: a1 b2 c3`; the link back lives on `AssessRun.proposal.merges[].ids`
+         * and each member's `merged into <id>`. Rows with the old label keep it (no
+         * migration: rewriting it is a "words nobody typed" write). A post made of a pad
+         * note wears NO label: those are the person's words, and `itemHeadline` lets a
+         * label beat the headline, so `from an assessment` would claim a machine wrote them.
+         */
+        const draft = {
+            ...backlogDraft({
+                id, cwd: run.repoDir, text: p.prompt,
+                label: p.fromNote ? undefined : "from an assessment",
+                order: slotRun && members.length ? memberSeat(members, p.rank ?? now, (x) => intents.get(x)) : (p.rank ?? now),
+                // Carried whatever `writeNames` said: the run wrote this prompt in the same
+                // breath, so there are no typed words for a title to stand on top of.
+                headline: p.headline, category: p.category, nameBy: "assess",
+                holdForHost: clock.carry?.holdForHost,
+            }),
+            ...(clock.carry ? { trigger: clock.carry.trigger } : {}),
+            origin: p.origin,
+        };
+        const r = intents.post(draft);
+        if (!r.ok || !r.intent)
+            continue;
+        if (p.gid && typeof p.rank === "number")
+            postedRanks.push({ id: r.intent.id, rank: p.rank });
+        posted++;
+        // Past the refusal check, so the id is on this list only when the row it
+        // came from exists. `continue` above is the whole bug this guards.
+        if (p.fromNote)
+            filed.push(p.fromNote);
+        // A posted row takes its place in the same ordering the ranks do, so it
+        // takes the same answer. `IntentDraft` has no `handOrdered` — it is the
+        // host's field — so it is a follow-up edit rather than a field on the draft.
+        if (m.pinRanks)
+            intents.edit(r.intent.id, { handOrdered: true });
+        if (p.gid)
+            postedFor.set(p.gid, r.intent.id);
+    }
+    // ── Splits: post both halves, then archive the original (`applySplit`) ──
+    // Conflicts have no branch here and never will: they are words, and no
+    // choice field can approve one (`AssessChoices`).
+    let splits = 0;
+    for (const s of m.split) {
+        const r = applySplit(intents, s, runId);
+        if (r.ok) {
+            splits++;
+            continue;
+        }
+        refused.push(`split “${s.sid}” was not applied: ${r.why} — the original item was left as it was`);
+    }
+    // ── Then the retirements ──
+    let dismissed = 0;
+    let notes = 0;
+    for (const d of m.dismiss) {
+        if (d.source === "note") {
+            notes++;
+            continue;
+        }
+        const row = intents.get(d.id);
+        if (!row)
+            continue;
+        const into = d.gid ? postedFor.get(d.gid) : undefined;
+        // A merge whose post did not land must not retire the words it was going to
+        // replace: that is the one ordering mistake here that loses work.
+        if (d.verdict === "merged" && !into)
+            continue;
+        const reason = d.verdict === "merged" ? assessDismissReason("merged", d.evidence, into) : d.reason;
+        intents.cancel(d.id, reason);
+        intents.dismiss(d.id);
+        dismissed++;
+    }
+    /**
+     * **The order, and whether it is marked as the person's.**
+     *
+     * `handOrdered` is the mark a drag leaves ("placed by you"). Pinned, the
+     * ranks an apply writes carry it too; free, they are written unmarked.
+     *
+     * Neither answer is right in general, so it is not a default: `pinRanks` is
+     * the question `AssessSheet` asks at apply time, and this is the whole of
+     * what it does. False leaves the rows exactly as this code has always left
+     * them.
+     */
+    /**
+     * **Then the rows that were still wanted and had stopped.**
+     *
+     * BEFORE the rank loop, and that order is the whole of why the two are not
+     * exclusive: `applyAssessment` puts a `wanted` failed row on BOTH lists, so a
+     * row put back here is ranked in the same pass and lands in the queue at the
+     * position the assessment gave it. The other order would write a sort position
+     * onto a terminal row and then move it — the same "a place in a queue it is
+     * not in" this whole path exists to stop, for one statement of the list.
+     *
+     * **A refusal is not a failure of the apply.** `m.requeue` is read off the
+     * run's START snapshot — a row may have been fired, finished or called off in
+     * the twenty minutes since — and the manager re-asks the live state, so
+     * "it already ran" is the correct, expected answer for some of these ids. It
+     * is not counted (nothing was put back) and it does not stop the rest: an
+     * apply that refused everything else because one row had run in the meantime
+     * would be an apply nobody could use on a list that is being worked on.
+     *
+     * **And "still failed" is not the same row's failure.** `state` is a state,
+     * not an event: a row can be failed at the snapshot, be put back by a hand
+     * tap, run, and fail again on something else entirely — and the live-state
+     * guard waves that through, because the answer to "is it failed?" is still
+     * yes. So the INSTANT is compared: `AssessItem.failedAt` is the failure this
+     * run was looking at (`buildAssessInput` stamps it), `settledAt` is what is on
+     * disk now, and a row that has settled again since is SKIPPED exactly as a
+     * refusal is — uncounted, and not a failure of the apply — so somebody reads
+     * the new failure before the work is started over on the strength of an old
+     * one. A snapshot with no stamp is applied on the state alone, which is all a
+     * document written before the field can honestly support.
+     *
+     * ── One kick, at the end ──────────────────────────────────────────────────
+     *
+     * Every call here passes `kick: false`, and `intents.kick()` is called ONCE
+     * after the ranks. See `AssessIntents.kick` for the failure it closes: the
+     * first revived row was fired by the kick its own re-queue sent, while the
+     * other eighteen revives and the entire rank loop had still to happen — so it
+     * ran before the approved order was written.
+     */
+    const failureSeen = new Map();
+    for (const it of run.input.items)
+        if (it.failedAt != null)
+            failureSeen.set(it.id, it.failedAt);
+    let requeued = 0;
+    for (const id of m.requeue) {
+        const saw = failureSeen.get(id);
+        const live = intents.get(id);
+        if (saw != null && live?.settledAt != null && live.settledAt !== saw)
+            continue;
+        if (intents.requeueFailed(id, { kind: "assess", runId }, { kick: false }).ok)
+            requeued++;
+    }
+    let ranked = 0;
+    if (slotRun) {
+        /**
+         * **A slot's order is the drag's own verb** (`backlogedits.reorder`): the
+         * listed rows trade their own seats, so a row outside the slot keeps its
+         * place, and each is stamped `handOrdered` — the person approved this
+         * order, which is what a drag means. `pinRanks` is not asked about here.
+         */
+        const order = [...m.rank, ...postedRanks]
+            .filter((r) => !!intents.get(r.id))
+            .sort((a, b) => a.rank - b.rank)
+            .map((r) => r.id);
+        if (order.length) {
+            reorder({ intents }, order);
+            ranked = order.length;
+        }
+    }
+    else {
+        for (const r of m.rank) {
+            if (!intents.get(r.id))
+                continue;
+            if (intents.edit(r.id, { order: r.rank, ...(m.pinRanks ? { handOrdered: true } : {}) }).ok)
+                ranked++;
+        }
+    }
+    /**
+     * **The titles, which are one answer about the whole run.**
+     *
+     * `m.name` is empty unless `writeNames` was explicitly true, so an apply from
+     * a client that has never heard of the question writes nothing here — which
+     * is the behaviour every apply had before it existed.
+     *
+     * A row counts as `named` when EITHER half was actually written, and the
+     * manager's return value is what says so: a row whose title a person typed
+     * refuses the headline and may still take the kind, and a row a person named
+     * both halves of takes nothing at all. Counting the suggestions instead would
+     * report "14 titled" over a list where thirteen were refused, which is a
+     * reading degrading to a wrong number about the one thing this question was
+     * asked to protect.
+     *
+     * Last of the four loops and still BEFORE the one kick, which is the only
+     * ordering rule it has: nothing here changes whether a row runs or where it
+     * sits, so it cannot be the thing the ladder is waiting for — and the kick
+     * stays the last statement of the apply, so the pass it starts reads a store
+     * where every one of these writes has already landed.
+     */
+    let named = 0;
+    for (const n of m.name) {
+        const wrote = intents.name(n.id, { headline: n.headline, category: n.category }, "assess");
+        if (wrote.headline || wrote.category)
+            named++;
+    }
+    // Now — with every re-queue written and every approved rank on the rows the
+    // next pass is about to sort by.
+    intents.kick();
+    const counts = { dismissed, ranked, posted, requeued, named };
+    const parts = [
+        `${dismissed} retired`,
+        `${ranked} ranked`,
+        `${posted} posted`,
+    ];
+    // Only when it happened: the three above are the shape of every apply and a
+    // `0 put back` on a repo with nothing failed is noise in a line a person reads
+    // once. Worded as the verb rather than as a state ("2 put back in the queue",
+    // not "2 requeued") because that is the sentence the sheet promised.
+    if (requeued)
+        parts.push(`${requeued} put back in the queue`);
+    // `requeued`'s rule for `requeued`'s reason: the three above are the shape of
+    // every apply and this one is not. A `0 titled` on an apply where the naming
+    // question was answered *leave the rows as they are* would be the line
+    // reporting the absence of something the person deliberately declined.
+    if (named)
+        parts.push(`${named} titled`);
+    // `requeued`'s rule again. The two pad clauses are opposite halves of one
+    // fact — what came OFF the pad into the backlog, and what was read and left
+    // there — so the filing is said first and neither is said as a zero.
+    if (filed.length)
+        parts.push(`${filed.length} filed from the pad`);
+    if (notes)
+        parts.push(`${notes} pad note${notes === 1 ? "" : "s"} judged and left on the pad`);
+    // The slot check's: a split is said as the verb, and what was approved but
+    // NOT done is said in full — an apply is never silent about a refusal.
+    if (splits)
+        parts.push(`${splits} split in two`);
+    parts.push(...refused);
+    store.recordApplied(runId, counts, now);
+    // `filed` even when empty: this host RAN the posts, so it can say what landed,
+    // and "nothing did" is an answer the phone is allowed to act on. Only the
+    // guards above — a missing run, a missing proposal, an already-applied one —
+    // leave it absent, because they cannot say.
+    return { ok: true, detail: parts.join(" · "), counts, filed };
+}
+//# sourceMappingURL=hassapply.js.map

package/packages/host/dist/assess/hassapply.js.map

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