waterplane 0.0.1 → 0.1.6

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

@@ -0,0 +1,160 @@
+import type { AssessNote, Intent, IntentDraft, ItemName } from "@waterplane/shared";
+import type { ExecutorResult } from "../intents/manager.js";
+import { AssessStore } from "./hassstore.js";
+/**
+ * Everything the executor needs from the rest of the host, as functions.
+ *
+ * `IntentDeps`' posture: asking is cheaper than being told, and it removes any
+ * chance of a run acting on a snapshot somebody forgot to refresh — which for
+ * this run would mean assessing a list of items that has moved on.
+ */
+export interface AssessDeps {
+    store: AssessStore;
+    /** Every intent the host holds (the builder filters by `cwd`). */
+    intents(): readonly Intent[];
+    /** The pad notes carrying this `cwd` — the other store "everything left" means. */
+    notes(cwd: string): readonly AssessNote[];
+}
+/**
+ * The intent executor, ready to plug in.
+ *
+ * The run is an Intent with `target: {kind:"shell"}`, which is `builds.ts`'
+ * shape and gets, for free, the four properties that matter: it is on disk
+ * before the tap returns, it is visible in Activity while it works, it is
+ * budget-gated like every other unattended run, and it is at-most-once by
+ * intent id across a restart.
+ *
+ * It resolves when the process does, so it sets no `watch`: unlike a delivery
+ * into a session, there is no turn afterwards to wait for. A failed run is
+ * `ok: false` and never `retry` — a second full read of a repo is real money,
+ * and nothing here was half-typed into anything.
+ */
+export declare function makeAssessExecutor(deps: AssessDeps): (i: Intent) => Promise<ExecutorResult>;
+/**
+ * The slice of `IntentManager` this file needs, as an interface.
+ *
+ * `builds.ts` holds the manager itself; this holds seven methods, because that
+ * is all starting a run and applying a proposal are allowed to do, and a narrow
+ * type is the place that says so. Nothing here can delete a row: `remove()` is
+ * deliberately not in it, and the one rule this whole feature rests on is that
+ * an assessment retires words and never loses them. The seventh is `kick()`,
+ * which mutates nothing at all — see its own note for why an apply has to be
+ * able to say "now" exactly once.
+ */
+export interface AssessIntents {
+    get(id: string): Intent | undefined;
+    /** Every row — read-only, and read only to re-derive a SLOT from the live
+     *  rows (`startAssessment` with a slot scope; a merge's member clocks). */
+    list(): readonly Intent[];
+    post(draft: IntentDraft): {
+        ok: boolean;
+        intent?: Intent;
+        reason?: string;
+    };
+    cancel(id: string, reason?: string): boolean;
+    dismiss(id: string): boolean;
+    /** `handOrdered` is the host's own field (a client cannot set it) and marks a
+     *  position a PERSON decided — a drag, or an assessment ranking they approved. */
+    edit(id: string, patch: {
+        order?: number;
+        archived?: boolean;
+        label?: string;
+        handOrdered?: boolean;
+    }): {
+        ok: boolean;
+        refused?: string;
+    };
+    /**
+     * Put a FAILED row back in the queue — the `still wanted` half a rank cannot
+     * express, and the one mutation this slice gained after it was written.
+     *
+     * ── What widening it to six methods does, and what it deliberately does not ─
+     *
+     * It makes a row that had STOPPED runnable again. That is a real change: until
+     * now every verb here either retired work (`cancel`/`dismiss`) or moved it in
+     * a list (`edit`), and nothing an assessment approved could put an agent back
+     * on a task. It is the change the feature is, though — applying *still wanted*
+     * to a failed row wrote a sort position into a queue the row was not in, and
+     * on the desktop this was written on that was 19 of 19 rows.
+     *
+     * What it does NOT make reachable, which is the half worth naming: `remove`
+     * is still absent, so nothing here can lose words; `markDone` is absent, so an
+     * assessment cannot claim work happened; `runNow` is absent, so nothing here
+     * spawns an agent — a re-queued row waits its turn like every other queued row
+     * and the ladder decides; `update`/`retarget` are absent, so it cannot rewrite
+     * what a row says or where it runs; and there is no un-archive.
+     *
+     * And it cannot revive a `done` or `canceled` row: that refusal lives in the
+     * manager, but the NAME is the type saying so — this is `requeueFailed`, not
+     * `requeue`, and the bare verb (which `backlog.ts` reaches with `allowDone`)
+     * is not in this interface at all.
+     */
+    requeueFailed(id: string, by: {
+        kind: "assess";
+        runId: string;
+    }, opts?: {
+        kick?: false;
+    }): {
+        ok: boolean;
+        reason?: string;
+    };
+    /**
+     * Put the run's title and kind on a row — the eighth method, and the only one
+     * that writes something a person READS rather than something the ladder acts
+     * on.
+     *
+     * It widens the slice by nothing dangerous, which is the whole argument for
+     * admitting it: `name()` cannot move a row, cannot run one, cannot retire one
+     * and cannot overwrite a `hand` field. The worst thing an assessment can do
+     * through it is put a wrong title on a row, which costs one tap to clear —
+     * and the author it stamps (`assess`) is what makes that tap possible, since
+     * a row that could not say who named it could not say whether the name may
+     * be replaced.
+     *
+     * Handed `"assess"` at every call site here. The author is not on the wire
+     * (`AssessName`'s note says why) and must not become an argument a caller
+     * chooses.
+     */
+    name(id: string, n: ItemName, by: "assess"): {
+        headline: boolean;
+        category: boolean;
+    };
+    /**
+     * Ask the ladder to look at the list — ONCE, when the whole apply is written.
+     *
+     * It is in this slice for a reason that is nothing to do with what an
+     * assessment may decide: every `requeueFailed` used to kick on its way out, a
+     * kick runs a pass synchronously as far as its first `await`, and so applying
+     * nineteen verdicts fired the FIRST revived row while eighteen re-queues and
+     * the entire rank loop had still to happen, so the row went without the
+     * approved order applied to it. The person's ranking was written a moment after the only fire it was
+     * supposed to govern.
+     *
+     * So the loop passes `kick: false` and this is called after the ranks. It
+     * decides nothing and cannot: it is "look now", and what the ladder then does
+     * is the ladder's.
+     */
+    kick(): void;
+}
+/**
+ * Write the run down. One tap, one durable row, and no second scheduler.
+ *
+ * The refusal is here rather than in the route for the reason `builds.run()`
+ * answers "unknown build" synchronously: every reason a run cannot start is
+ * known now, while there is still a socket to be told on, and a run that got as
+ * far as an executor before discovering it was the second one for this repo
+ * would already have spent the agent.
+ *
+ * One at a time per repo is the rule that matters. Two assessments over one
+ * list come back with different verdicts about the same rows, and reconciling
+ * that is a merge nobody can do on a phone.
+ */
+export declare function startAssessment(intents: AssessIntents, store: AssessStore, repoDir: string, 
+/** The cut the caller is asking about; absent is the whole repo. */
+ids?: readonly string[], 
+/** A slot check (`AssessScope`): `ids` must then all still sit in that slot. */
+slotScope?: unknown): {
+    runId: string;
+} | {
+    error: string;
+};

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

@@ -0,0 +1,178 @@
+/** A slice of assess.ts — moved whole from assess.ts, see docs/notes/assess-architecture.md (host). */
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { ASSESS_PLAN_FILE, cleanAssessScope, findSlot, slotRowOfIntent } from "@waterplane/shared";
+import { runAssessment } from "./hassrun.js";
+import { ASSESSABLE_STATES } from "./hassknobs.js";
+/**
+ * The intent executor, ready to plug in.
+ *
+ * The run is an Intent with `target: {kind:"shell"}`, which is `builds.ts`'
+ * shape and gets, for free, the four properties that matter: it is on disk
+ * before the tap returns, it is visible in Activity while it works, it is
+ * budget-gated like every other unattended run, and it is at-most-once by
+ * intent id across a restart.
+ *
+ * It resolves when the process does, so it sets no `watch`: unlike a delivery
+ * into a session, there is no turn afterwards to wait for. A failed run is
+ * `ok: false` and never `retry` — a second full read of a repo is real money,
+ * and nothing here was half-typed into anything.
+ */
+export function makeAssessExecutor(deps) {
+    return async (i) => {
+        const startedAt = Date.now();
+        // The scope is recorded on the run at START, not derived from `input` when
+        // it ends: `input` does not exist for the twenty minutes the run takes, and
+        // that is exactly the window somebody is watching it in to see whether it
+        // is doing what they asked.
+        const scopedIds = i.payload.kind === "assess" && i.payload.ids?.length ? i.payload.ids : undefined;
+        // A slot scope only ever rides beside ids (`cleanIntentPayload`).
+        const scope = i.payload.kind === "assess" && scopedIds ? i.payload.scope : undefined;
+        deps.store.set(i.id, { runId: i.id, repoDir: i.cwd, status: "running", startedAt, scopedIds, ...(scope ? { scope } : {}) });
+        try {
+            // Watched: what it is doing goes to memory and the socket as it happens
+            // (`setLive`), and the last reading is persisted below with the settled
+            // run. Nothing on it is read by anything that decides.
+            const res = await runAssessment(i.cwd, deps.intents(), deps.notes(i.cwd), startedAt, scopedIds, (p) => deps.store.setLive(i.id, { progress: p }), scope);
+            const assessable = res.input.items.filter((x) => !x.context).length;
+            deps.store.set(i.id, {
+                status: res.ok ? "done" : "failed",
+                finishedAt: Date.now(),
+                detail: res.detail,
+                envelope: res.envelope,
+                itemCount: res.input.items.length,
+                assessableCount: assessable,
+                // The words the verdicts were formed against, kept ON the run. See
+                // `AssessRun.input`: the proposal carries ids and no prose, and
+                // re-deriving the prose from current state renders today's words under
+                // yesterday's verdict.
+                input: res.input,
+                proposal: res.proposal,
+                planPath: res.planWritten ? ASSESS_PLAN_FILE : undefined,
+                // The plan's VERSION, beside its path: every run rewrites the same
+                // path, and the reader's document cache is keyed on (repo, path,
+                // mtime) — without this every run's plan files under one key and a
+                // later run can show an earlier run's plan under this run's verdicts.
+                planMtime: res.planMtime,
+                // What it was seen doing, kept: the stream is gone by the time anybody
+                // reads a surprising proposal and asks what it actually looked at.
+                progress: res.progress,
+            });
+            return { ok: res.ok, detail: res.detail };
+        }
+        catch (err) {
+            const detail = `the assessment could not run: ${String(err).slice(0, 200)}`;
+            deps.store.set(i.id, { status: "failed", finishedAt: Date.now(), detail });
+            return { ok: false, detail };
+        }
+    };
+}
+/**
+ * Write the run down. One tap, one durable row, and no second scheduler.
+ *
+ * The refusal is here rather than in the route for the reason `builds.run()`
+ * answers "unknown build" synchronously: every reason a run cannot start is
+ * known now, while there is still a socket to be told on, and a run that got as
+ * far as an executor before discovering it was the second one for this repo
+ * would already have spent the agent.
+ *
+ * One at a time per repo is the rule that matters. Two assessments over one
+ * list come back with different verdicts about the same rows, and reconciling
+ * that is a merge nobody can do on a phone.
+ */
+export function startAssessment(intents, store, repoDir, 
+/** The cut the caller is asking about; absent is the whole repo. */
+ids, 
+/** A slot check (`AssessScope`): `ids` must then all still sit in that slot. */
+slotScope) {
+    const busy = store.running(repoDir);
+    if (busy)
+        return { error: "an assessment is already running for this repo — two of them would propose different verdicts on one list" };
+    /**
+     * **A slot check judges exactly the rows the person was shown — or nothing.**
+     *
+     * The phone's `ids` are what the person saw when they tapped; the host's rows
+     * are what will fire. The key is matched back against the live rows
+     * (`findSlot`, tolerant — the two ends read one reset a minute apart) only to
+     * CONFIRM the caller's list, never to replace it: `slotsOf` clusters greedily
+     * from the earliest row, so one row posted since (an agent's `new` two
+     * minutes before `a`) moves the cut, and a run over the host's slot judged a
+     * row nobody saw and dropped one they did. So every id sent must still be
+     * waiting and still sit in the host's slot, and at least two must — else the
+     * check is REFUSED in a sentence, with no model call. A key that names
+     * nothing any more, or a slot down to one row, is refused the same way:
+     * a check of one row against itself buys nothing, and widening to the repo is
+     * the most expensive wrong answer available. Rows in the slot that were not
+     * sent are never judged.
+     */
+    const slot = cleanAssessScope(slotScope);
+    if (slotScope !== undefined && !slot)
+        return { error: "that slot check names no slot — nothing was run" };
+    if (slot) {
+        const rows = intents.list()
+            .filter((i) => i.cwd === repoDir && i.payload.kind === "prompt" && ASSESSABLE_STATES.has(i.state))
+            .map(slotRowOfIntent)
+            .filter((r) => !!r);
+        const found = findSlot(rows, slot.key);
+        if (!found) {
+            return { error: "those rows no longer fire together — they ran, were moved, or the reset they waited for has changed; nothing was run" };
+        }
+        if (found.ids.length < 2) {
+            return { error: "only one row fires at that time now, so there is nothing to check together; nothing was run" };
+        }
+        const sent = [...new Set((ids ?? []).filter((x) => typeof x === "string"))];
+        const inSlot = new Set(found.ids);
+        if (sent.length < 2 || !sent.every((x) => inSlot.has(x))) {
+            return { error: `the slot changed since you looked — it now holds ${found.ids.length}; open the check again. Nothing was run` };
+        }
+        return postRun(intents, repoDir, { kind: "assess", ids: sent, scope: slot });
+    }
+    /**
+     * **A scope is checked HERE, while there is still a socket to refuse on.**
+     *
+     * `buildAssessInput` would simply find nothing and the run would spend a
+     * whole agent reading a repo to answer a question about zero rows — and
+     * `startAssessment`'s own doc says why every knowable refusal belongs at the
+     * tap. The two ways a scope can be empty are worth telling apart on the
+     * phone, but not here: both mean the same thing to this function, which is
+     * that there is nothing to judge.
+     *
+     * It also does the containment: an id belonging to ANOTHER repo's row simply
+     * is not in this repo's assessable set, so a scope made of them refuses
+     * rather than quietly assessing the whole of a repo the caller never named a
+     * row in. `buildAssessInput` filters on `cwd` too — this is the half that
+     * turns that filter into a sentence instead of a surprise.
+     */
+    const scope = ids && ids.length
+        ? ids.filter((id) => {
+            const i = intents.get(id);
+            return !!i && i.cwd === repoDir && i.payload.kind === "prompt" && ASSESSABLE_STATES.has(i.state);
+        })
+        : null;
+    if (scope && !scope.length) {
+        return {
+            error: "nothing in that cut can be assessed — an assessment judges work that is still open, "
+                + "and these rows are finished, running, or not this repo's",
+        };
+    }
+    return postRun(intents, repoDir, scope ? { kind: "assess", ids: scope } : { kind: "assess" });
+}
+/** The run row itself — one tap, one durable row. */
+function postRun(intents, repoDir, payload) {
+    const runId = "as_" + randomUUID().slice(0, 8);
+    const posted = intents.post({
+        id: runId,
+        cwd: repoDir,
+        payload,
+        // `builds.ts`' shape, and for its four properties: on disk before the tap
+        // returns, visible while it works, budget-gated, at-most-once by intent id
+        // across a restart.
+        target: { kind: "shell" },
+        trigger: { kind: "now" },
+        title: `assess ${basename(repoDir)}`,
+    });
+    if (!posted.ok || !posted.intent)
+        return { error: posted.reason || "could not be written down" };
+    return { runId };
+}
+//# sourceMappingURL=hassexec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hassexec.js","sourceRoot":"","sources":["../../src/assess/hassexec.ts"],"names":[],"mappings":"AAAA,uGAAuG;AACvG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGnG,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAmBnD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAgB;IACjD,OAAO,KAAK,EAAE,CAAS,EAA2B,EAAE;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,2EAA2E;QAC3E,4EAA4E;QAC5E,0EAA0E;QAC1E,4BAA4B;QAC5B,MAAM,SAAS,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;QACnG,kEAAkE;QAClE,MAAM,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;QACrF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5H,IAAI,CAAC;YACH,wEAAwE;YACxE,wEAAwE;YACxE,uDAAuD;YACvD,MAAM,GAAG,GAAG,MAAM,aAAa,CAC7B,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,SAAS,EAC9D,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAChD,KAAK,CACN,CAAC;YACF,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;YACpE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACnB,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ;gBAClC,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE;gBACtB,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM;gBACjC,eAAe,EAAE,UAAU;gBAC3B,mEAAmE;gBACnE,gEAAgE;gBAChE,uEAAuE;gBACvE,uBAAuB;gBACvB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,QAAQ,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS;gBACxD,mEAAmE;gBACnE,iEAAiE;gBACjE,mEAAmE;gBACnE,sEAAsE;gBACtE,SAAS,EAAE,GAAG,CAAC,SAAS;gBACxB,uEAAuE;gBACvE,mEAAmE;gBACnE,QAAQ,EAAE,GAAG,CAAC,QAAQ;aACvB,CAAC,CAAC;YACH,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;QAC5C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,MAAM,GAAG,iCAAiC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YAC5E,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAC3E,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAwFD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAsB,EACtB,KAAkB,EAClB,OAAe;AACf,oEAAoE;AACpE,GAAuB;AACvB,gFAAgF;AAChF,SAAmB;IAEnB,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACpC,IAAI,IAAI;QAAE,OAAO,EAAE,KAAK,EAAE,2GAA2G,EAAE,CAAC;IACxI;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACzC,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,KAAK,EAAE,iDAAiD,EAAE,CAAC;IAC1G,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE;aACxB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;aACjG,GAAG,CAAC,eAAe,CAAC;aACpB,MAAM,CAAC,CAAC,CAAC,EAAgB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,EAAE,KAAK,EAAE,sHAAsH,EAAE,CAAC;QAC3I,CAAC;QACD,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,KAAK,EAAE,6FAA6F,EAAE,CAAC;QAClH,CAAC;QACD,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACzD,OAAO,EAAE,KAAK,EAAE,oDAAoD,KAAK,CAAC,GAAG,CAAC,MAAM,yCAAyC,EAAE,CAAC;QAClI,CAAC;QACD,OAAO,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/E,CAAC;IACD;;;;;;;;;;;;;;;OAeG;IACH,MAAM,KAAK,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM;QAC7B,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;YAClB,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC1B,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACnG,CAAC,CAAC;QACF,CAAC,CAAC,IAAI,CAAC;IACT,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QAC3B,OAAO;YACL,KAAK,EAAE,sFAAsF;kBACzF,0DAA0D;SAC/D,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AAChG,CAAC;AAED,qDAAqD;AACrD,SAAS,OAAO,CAAC,OAAsB,EAAE,OAAe,EAAE,OAAsB;IAC9E,MAAM,KAAK,GAAG,KAAK,GAAG,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;QAC1B,EAAE,EAAE,KAAK;QACT,GAAG,EAAE,OAAO;QACZ,OAAO;QACP,0EAA0E;QAC1E,2EAA2E;QAC3E,oBAAoB;QACpB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QACzB,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE;QACxB,KAAK,EAAE,UAAU,QAAQ,CAAC,OAAO,CAAC,EAAE;KACrC,CAAC,CAAC;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,IAAI,2BAA2B,EAAE,CAAC;IACjG,OAAO,EAAE,KAAK,EAAE,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,80 @@
+/** A slice of assess.ts — moved whole from assess.ts, see docs/notes/assess-architecture.md (host). */
+import type { AssessInput, AssessNote, AssessScope, Intent } from "@waterplane/shared";
+/**
+ * The `<state dir>/assess-in.json` document: everything addressable by this `cwd`.
+ *
+ * Two stores, because since the give-ups ledger was folded into Activity there
+ * are two: the intents the host holds for this repo, and the pad notes carrying
+ * this `cwd`. A note is not a send that gave up — `retireToPad` is gone and a
+ * failed row keeps its own words — it is a thought written with no target that
+ * named a repo anyway, and skipping those re-asks the question the whole rework
+ * was about.
+ *
+ * The split between `assessable` and `context` is the load-bearing part.
+ * Finished, running and cancelled rows go in so the CLI can see what already
+ * ran — that is how it tells that the item next to them was quietly
+ * implemented — but `cleanAssessment` drops any verdict naming one. A row that
+ * is mid-flight is not a candidate for retirement either: it is being worked on
+ * right now.
+ *
+ * A chain's steps are joined rather than dropped: `steps[0]` is what everything
+ * that reads an intent as one prompt uses, and a triage that judged an item by
+ * its first turn alone would judge half of it.
+ */
+export declare function buildAssessInput(cwd: string, intents: readonly Intent[], notes: readonly AssessNote[], now: number, 
+/**
+ * **The cut this run was asked about.** Absent (or empty) is the whole repo —
+ * every run before this parameter, and every run an older client starts.
+ *
+ * It narrows what may be JUDGED and deliberately nothing else. The finished
+ * rows still go in as context, because they are the evidence a verdict rests
+ * on rather than candidates for one — `cleanAssessment` already drops any
+ * verdict naming one, so widening the context cannot widen the answer, while
+ * narrowing it would make the scoped run a WORSE judge of the very rows it
+ * was pointed at. "Assess these seven" is a question about seven rows, not an
+ * instruction to forget what the repo has already done.
+ *
+ * Pad notes drop out of a scoped run for the opposite reason: they are
+ * candidates, they carry no id the caller could have named on that screen,
+ * and a count on a control has to equal the set the tap acts on. A scoped run
+ * that also judged three notes nobody could see would be a button saying 7
+ * and a proposal about 10.
+ */
+ids?: readonly string[], 
+/** What those ids ARE, when they are one slot (`AssessScope`). Only ever
+ *  beside `ids`: a slot with no ids scopes nothing. */
+slot?: AssessScope): AssessInput;
+/**
+ * **The judging guidance** — the verdict vocabulary, the evidence rule and the
+ * pad-note rule: the part of the kickoff a fork may reword, as
+ * `<config dir>/prompts/assess-guidance.md` (`prompts.ts`). Everything else in
+ * `assessPrompt` is contract — the file names, the interpolated caps, the JSON
+ * shape `cleanAssessment` reads — and stays in code. An override must keep the
+ * five verdict words and the evidence rule: the parser enforces both.
+ *
+ * On the pad-note paragraph:
+ * **Said out loud, because the answer now has somewhere to GO.**
+ * A `wanted` verdict on a note is offered back to the person as a backlog
+ * item carrying the note's own words — copied by `cleanAssessment`, never
+ * by the CLI — so a run that also writes the note out under "new" produces
+ * the same sentence twice on one sheet. The pure layer drops the copy; the
+ * prompt is where it stops being written in the first place.
+ */
+export declare const ASSESS_GUIDANCE: string;
+/**
+ * **When the slot fires, in words** — read off the key, the only place a run
+ * row carries it. ISO in UTC: the model reads it, and a local time with no
+ * zone is a number two readers disagree about.
+ */
+export declare function slotWhenText(scope: AssessScope): string;
+/**
+ * The kickoff prompt. Four paragraphs, and deliberately no items.
+ *
+ * It states the vocabulary, that evidence is REQUIRED and that a claim without
+ * one is rejected rather than quietly softened, the merge rules and the caps —
+ * so a group the pure layer would drop is one the CLI knew not to propose. The
+ * caps are interpolated from the shared constants for the obvious reason: a
+ * prompt that teaches a limit the parser does not enforce is worse than no
+ * prompt at all.
+ */
+export declare function assessPrompt(input: AssessInput): string;