waterplane 0.0.1 → 0.1.6

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

@@ -0,0 +1,39 @@
+import type { AssessInput, AssessNote, AssessProgress, AssessProposal, AssessScope, Intent } from "@waterplane/shared";
+/** What one run produced. `ok` means a proposal was READ, never that anybody
+ *  has approved it. */
+export interface AssessRunOutcome {
+    ok: boolean;
+    /** One line for the row: what came back, or which half of the contract failed. */
+    detail: string;
+    proposal?: AssessProposal;
+    /** The CLI's own words, kept when the FILE was the problem. */
+    envelope?: string;
+    input: AssessInput;
+    /** The human document exists — the artifact worth having in a week. */
+    planWritten: boolean;
+    /** Which VERSION of that document this run wrote — see `AssessRun.planMtime`.
+     *  Absent when there is no plan, or when the stat failed. */
+    planMtime?: number;
+    /** What the run was seen doing, as of its last event — kept with the settled
+     *  run because the stream is gone by the time the proposal is read. */
+    progress?: AssessProgress;
+}
+/**
+ * Write the input, run one headless `claude -p` in the repo, read the output
+ * file back, and clean it.
+ *
+ * Deliberately NOT `--continue`: see the header. Deliberately no retry either —
+ * a second full read of a repo because the first one wrote malformed JSON is
+ * real money spent on a guess, and the failed row says exactly what went wrong
+ * so the tap can be repeated by a person who has read it.
+ */
+export declare function runAssessment(cwd: string, intents: readonly Intent[], notes: readonly AssessNote[], now?: number, 
+/** The cut this run was asked about; absent is the whole repo. Comes off the
+ *  intent's own payload, so a run reconciled after a restart is scoped to
+ *  exactly what the tap asked for and never quietly widens. */
+ids?: readonly string[], 
+/** Told, at most every `ASSESS_PROGRESS_MS`, what the run is doing. Absent is
+ *  a run nobody is watching, which is exactly the old call. */
+onProgress?: (p: AssessProgress) => void, 
+/** What `ids` ARE when they are one slot — off the payload, like `ids`. */
+scope?: AssessScope): Promise<AssessRunOutcome>;

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

@@ -0,0 +1,269 @@
+/** A slice of assess.ts — moved whole from assess.ts, see docs/notes/assess-architecture.md (host). */
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ASSESS_IN_FILE, ASSESS_OUT_FILE, ASSESS_PLAN_FILE, assessCounts, cleanAssessment } from "@waterplane/shared";
+import { detectHeadlessLimit, limitNote } from "../limit.js";
+import { runToolTask } from "../sidecar.js";
+import { assessPrompt, buildAssessInput } from "./hassinput.js";
+import { parseLoose, resultText, writeAtomic } from "./hassutil.js";
+import { assessProgressMs, assessProgressInit, foldAssessEvent } from "./hassprogress.js";
+import { ASSESS_KEEP_BYTES, ASSESS_MAX_BUFFER, ASSESS_TIMEOUT_MS } from "./hassknobs.js";
+/**
+ * Write the input, run one headless `claude -p` in the repo, read the output
+ * file back, and clean it.
+ *
+ * Deliberately NOT `--continue`: see the header. Deliberately no retry either —
+ * a second full read of a repo because the first one wrote malformed JSON is
+ * real money spent on a guess, and the failed row says exactly what went wrong
+ * so the tap can be repeated by a person who has read it.
+ */
+export async function runAssessment(cwd, intents, notes, now = Date.now(), 
+/** The cut this run was asked about; absent is the whole repo. Comes off the
+ *  intent's own payload, so a run reconciled after a restart is scoped to
+ *  exactly what the tap asked for and never quietly widens. */
+ids, 
+/** Told, at most every `ASSESS_PROGRESS_MS`, what the run is doing. Absent is
+ *  a run nobody is watching, which is exactly the old call. */
+onProgress, 
+/** What `ids` ARE when they are one slot — off the payload, like `ids`. */
+scope) {
+    const input = buildAssessInput(cwd, intents, notes, now, ids, scope);
+    const inPath = join(cwd, ASSESS_IN_FILE);
+    const outPath = join(cwd, ASSESS_OUT_FILE);
+    const planPath = join(cwd, ASSESS_PLAN_FILE);
+    try {
+        mkdirSync(dirname(inPath), { recursive: true });
+        writeAtomic(inPath, JSON.stringify(input, null, 2));
+    }
+    catch (err) {
+        return { ok: false, detail: `could not write ${ASSESS_IN_FILE}: ${String(err).slice(0, 160)}`, input, planWritten: false };
+    }
+    // The previous run's answer is not this run's answer. A run that writes
+    // nothing at all must fail, not quietly apply verdicts formed against a repo
+    // two days older.
+    try {
+        rmSync(outPath, { force: true });
+    }
+    catch { /* it was not there */ }
+    const env = await runClaude(cwd, assessPrompt(input), onProgress);
+    const planWritten = existsSync(planPath);
+    // Asked in the same breath as "is it there", because both are facts about
+    // the moment this run finished and the file is about to be rewritten at the
+    // same path by the next one. See `AssessRun.planMtime` for why a run's plan
+    // needs a version at all; a stat that throws leaves it ABSENT, never 0 —
+    // a 0 is a version that says "unversioned", and every reader keyed on it
+    // would file two different documents under one key.
+    const planMtime = planWritten ? planFileMtime(planPath) : undefined;
+    const progress = env.progress;
+    let raw;
+    try {
+        raw = readFileSync(outPath, "utf8");
+    }
+    catch {
+        return {
+            ok: false,
+            detail: env.refused ?? env.limitNote ?? `the assessment wrote no ${ASSESS_OUT_FILE}${env.failed ? " and the run did not finish cleanly" : ""}`,
+            envelope: env.text || undefined,
+            input,
+            planWritten,
+            planMtime,
+            progress,
+        };
+    }
+    const parsed = parseLoose(raw);
+    if (parsed === undefined) {
+        return {
+            ok: false,
+            detail: `${ASSESS_OUT_FILE} is not valid JSON — nothing was applied`,
+            envelope: (env.text || raw).slice(0, 8000),
+            input,
+            planWritten,
+            planMtime,
+            progress,
+        };
+    }
+    // The FILE is the content: a complete, parseable document is the answer even
+    // if the process was killed on its way out. The envelope only ever said
+    // whether it finished.
+    const proposal = cleanAssessment(parsed, input.items);
+    return { ok: true, detail: outcomeDetail(proposal, planWritten), proposal, envelope: env.text || undefined, input, planWritten, planMtime, progress };
+}
+/** The plan document's mtime, in whole milliseconds, or ABSENT. Rounded because
+ *  the number travels to a phone and is compared for equality there: a
+ *  sub-millisecond fraction is a difference no two readers agree on. */
+function planFileMtime(path) {
+    try {
+        return Math.round(statSync(path).mtimeMs);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One line for the row, from the proposal's own counts — so the row and the
+ *  sheet cannot disagree about what came back. */
+function outcomeDetail(p, planWritten) {
+    const c = assessCounts(p);
+    const parts = [
+        `${c.done} already done`,
+        `${c.obsolete} no longer apply`,
+        `${c.superseded} covered elsewhere`,
+        `${c.wanted} still wanted`,
+        `${c.unclear} undecided`,
+    ];
+    if (p.merges.length)
+        parts.push(`${p.merges.length} merge${p.merges.length === 1 ? "" : "s"}`);
+    if (p.news.length)
+        parts.push(`${p.news.length} new`);
+    // The slot check's two kinds, only when there is one (`requeued`'s rule in
+    // the apply sentence: a zero here is noise on every repo-wide run).
+    if (p.splits?.length)
+        parts.push(`${p.splits.length} split${p.splits.length === 1 ? "" : "s"}`);
+    if (p.conflicts?.length)
+        parts.push(`${p.conflicts.length} conflict${p.conflicts.length === 1 ? "" : "s"}`);
+    return `${p.rows.length} item(s) assessed: ${parts.join(", ")}${planWritten ? `; ${ASSESS_PLAN_FILE} written` : ""}`;
+}
+/**
+ * The headless run. `review.ts`'s shape — prompt on stdin, an envelope out —
+ * minus `--continue`, plus permission to write the two files it is being asked
+ * for, plus the one thing this run needs that the others do not: it can be
+ * WATCHED.
+ *
+ * `--output-format stream-json --verbose` prints one JSON event per line as the
+ * run makes it, and the final event is the same envelope `json` would have
+ * printed — so the completion signal and the error channel are unchanged, and
+ * `resultText` reads both shapes. The difference is that a run taking twenty
+ * minutes is now visible while it takes them, which is all this buys: the FILE
+ * is still the content, and nothing on the stream is ever treated as an answer.
+ *
+ * The stream is also why the run is spawned rather than `execFile`d
+ * (`sidecar.ts`'s `onOut`): a stream-json run prints every tool result it takes,
+ * and `maxBuffer` would kill the process for succeeding loudly.
+ */
+async function runClaude(cwd, prompt, onProgress) {
+    const args = ["-p", "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"];
+    let progress = assessProgressInit();
+    /** The reading nothing has happened in yet, kept so "did anything arrive?"
+     *  is one identity comparison rather than a rule about which field counts. */
+    const empty = progress;
+    // The reading last handed over, compared by IDENTITY: `foldAssessEvent`
+    // returns the very object it was given for a line it cannot use, so a stream
+    // of noise pushes nothing and the comparison never has to look inside.
+    let sent = progress;
+    let sentAt = 0;
+    let pending = "";
+    let flush;
+    let over = false;
+    const unarm = () => { if (flush) {
+        clearTimeout(flush);
+        flush = undefined;
+    } };
+    const push = () => {
+        unarm();
+        if (over || !onProgress || progress === sent)
+            return;
+        sent = progress;
+        sentAt = Date.now();
+        onProgress(progress);
+    };
+    const onOut = (chunk) => {
+        // Past the answer there is no run left to be a reading OF. `sidecar.ts`
+        // already refuses to hand a chunk over after it has resolved; this is the
+        // same rule stated on this side of it, because the cost of being wrong is
+        // a `setLive` on a row the executor has already settled.
+        if (over)
+            return;
+        // A chunk boundary falls mid-line; only whole lines are events.
+        pending += chunk;
+        const lines = pending.split("\n");
+        pending = lines.pop() ?? "";
+        for (const line of lines)
+            progress = foldAssessEvent(progress, line, cwd, Date.now());
+        if (progress === sent)
+            return;
+        /**
+         * The THROTTLE HAS A TRAILING EDGE, and that is the whole point of it.
+         *
+         * Pushing only when a chunk arrives late enough withholds every step folded
+         * inside the window until the NEXT chunk — and the step most worth watching
+         * is exactly the one with no next chunk behind it: at t=0.4 s the run folds
+         * `Bash npm test`, the command runs for four minutes printing nothing, and
+         * the phone shows the PREVIOUS step as what it is doing while
+         * `assessWatch`'s quiet-age counts "nothing new for 4m" from that older
+         * step's `at`. Both halves of the reading are then false about the run.
+         *
+         * So a throttled reading arms one timer for the rest of the window instead
+         * of being dropped. One, because a second would only push the same object;
+         * cleared on every push and on the way out, because this daemon outlives
+         * every run and a timer holding a closure over a finished one is a leak
+         * with a `setLive` on the end of it.
+         *
+         * There is no `steps` gate: the `system/init` event carries the MODEL and
+         * no step, and a reading that says which model is about to spend twenty
+         * minutes is worth arriving before the first tool call rather than never.
+         */
+        const wait = assessProgressMs() - (Date.now() - sentAt);
+        if (wait <= 0)
+            push();
+        else if (!flush) {
+            flush = setTimeout(push, wait);
+            flush.unref?.();
+        }
+    };
+    // Through `sidecar.ts`, which owns the engine axis for every unattended call.
+    // For this task that axis has exactly one position: an assessment reads a
+    // repo and writes two files, so a toolless local completion cannot do it and
+    // is refused in words rather than run — see `sidecar.ts`'s header.
+    //
+    // `onOut` unconditionally, not `onProgress ? onOut : undefined`: watching is
+    // what the READINGS are for, but streaming is what stops `maxBuffer` killing
+    // a run that prints a lot on its way to a good answer — see
+    // `ASSESS_MAX_BUFFER`. A run nobody is watching costs one folded object per
+    // chunk and pushes nothing.
+    const run = await runToolTask("assess", {
+        cwd, args, prompt,
+        timeoutMs: ASSESS_TIMEOUT_MS,
+        maxBuffer: ASSESS_MAX_BUFFER,
+        onOut,
+        keepBytes: ASSESS_KEEP_BYTES,
+    });
+    // The process has answered: no later chunk is a reading of it, and no timer
+    // may outlive it. Both are said here as well as in `sidecar.ts` because the
+    // reading is this file's and a settled row must not move again.
+    over = true;
+    unarm();
+    if (run.refused)
+        return { text: "", failed: true, limited: false, refused: run.refused };
+    const res = resultText(run.stdout);
+    // A found result is the CLI's own last words and reads from the front; a
+    // stream nobody could find a result in is a TAIL, and its useful end is the
+    // last thing printed before it stopped.
+    const text = res.found
+        ? res.text.trim().slice(0, 8000)
+        : (res.text || run.stderr || (run.err ? String(run.err) : "")).trim().slice(-8000);
+    // A run the account refused wrote no files and judged nothing. Said as
+    // "wrote no assess-out.json" it reads as a model that ignored the
+    // contract, which is the one conclusion that is certainly wrong.
+    //
+    // The PARSED result text goes in first, because the detector's own envelope
+    // reader (`limit.ts`'s `envelopeResult`) is a whole-document `JSON.parse` of
+    // stdout — written for `--output-format json`, and on NDJSON it throws by
+    // construction and contributes "". Detection then rests entirely on the raw
+    // regex backstop, i.e. on the banner happening to sit inside the result line
+    // where the escaping leaves it readable. That is luck, not a contract, and
+    // `limit.ts` is the heuristics layer with its own rules — so the fix is to
+    // hand the detector the text it was written to read, here. The raw tail
+    // follows it so nothing that is detectable today stops being detectable: the
+    // notice can also arrive on a line that is not the envelope.
+    const limit = detectHeadlessLimit(res.found ? `${res.text}\n${run.stdout}` : run.stdout, run.stderr);
+    return {
+        text,
+        failed: run.failed,
+        limited: limit.blocked,
+        limitNote: limit.blocked ? limitNote(limit, "assessed") : undefined,
+        // Anything that was folded, not just steps: a run that got as far as
+        // naming its model and no further published that live, and settling with
+        // `undefined` here would take it off the screen the reader is looking at.
+        progress: progress === empty ? undefined : progress,
+    };
+}
+//# sourceMappingURL=hassrun.js.map

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

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

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

@@ -0,0 +1,77 @@
+import type { AssessRun } from "@waterplane/shared";
+/**
+ * The proposals, keyed by run (intent) id.
+ *
+ * `ReviewStore`'s shape exactly, and for `ReviewStore`'s reason: the intent
+ * store is the LIFECYCLE — state, trigger, target, result — and a proposal is
+ * none of those. It outlives the run that produced it, one sheet reads it, and
+ * putting it on `Intent` would mean every consumer of every row carrying a
+ * field it will never look at.
+ *
+ * tmp+rename, because half a JSON document is worse than none.
+ */
+export declare class AssessStore {
+    private onChange;
+    private rows;
+    private path;
+    constructor(root: string, onChange: (repoDir: string) => void);
+    get(runId: string): AssessRun | undefined;
+    /** Every run for one worktree, newest first — what the sheet lists. */
+    forRepo(repoDir: string): AssessRun[];
+    /** The run a repo's button opens: its newest, whatever state it is in. */
+    latestFor(repoDir: string): AssessRun | undefined;
+    /** Every worktree this store holds a run for — what a client asking without
+     *  naming a repo is answered with, one frame each. */
+    repos(): string[];
+    /** Is a run for this repo still going? One at a time per repo — two
+     *  assessments proposing conflicting verdicts on one list is a merge nobody
+     *  can do on a phone. */
+    running(repoDir: string): AssessRun | undefined;
+    set(runId: string, patch: Partial<AssessRun>): AssessRun;
+    /**
+     * A reading that is only true while the run is ALIVE: memory and the socket,
+     * never the disk.
+     *
+     * Progress arrives every second or two for twenty minutes. Through `set()`
+     * that is several hundred whole-file rewrites of a store that carries every
+     * run's input snapshot — and for nothing, because a `running` row does not
+     * survive a restart by design (the constructor fails every one of them, since
+     * the run was a child process of the daemon that died). The last reading is
+     * persisted by the `set()` that settles the run, where it becomes the record
+     * of what the run did.
+     *
+     * Silently ignores an unknown id: the run is gone, so there is nothing this
+     * could be a reading of.
+     */
+    setLive(runId: string, patch: Partial<AssessRun>): void;
+    drop(runId: string): void;
+    /** What applying decided, recorded on the run — so the row answers "have I
+     *  dealt with this?" without re-reading the proposal it came from. */
+    recordApplied(runId: string, counts: {
+        dismissed: number;
+        ranked: number;
+        posted: number;
+        requeued: number;
+        named: number;
+    }, at: number): void;
+    /**
+     * Drop the assessed SNAPSHOT from runs that no longer need it.
+     *
+     * A run carries the whole `AssessInput` — every open prompt and pad note for
+     * that repo, un-clipped, because the proposal names ids and the sheet has to
+     * show the words those ids meant AT THE TIME. That is the right thing to keep
+     * while the proposal is still a decision waiting to be made, and dead weight
+     * afterwards: forty retained runs over a repo with eighty-odd long prompts is
+     * a multi-megabyte file rewritten whole (tmp+rename) three times per run.
+     *
+     * So the snapshot is kept exactly where it can still be read: the newest run
+     * of each repo (what the sheet opens), and any run that has not been settled
+     * yet. An `applied` or `discarded` older run keeps its counts, its verdicts
+     * and its status — what it decided — and loses only the copy of words that
+     * are still in the intent store and on the pad. Nothing here is the last copy
+     * of anything.
+     */
+    private shedInputs;
+    private evict;
+    private persist;
+}

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

@@ -0,0 +1,187 @@
+/** A slice of assess.ts — moved whole from assess.ts, see docs/notes/assess-architecture.md (host). */
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { hostStateDir } from "../branddirs.js";
+import { ASSESS_MAX_RUNS } from "./hassknobs.js";
+import { readJsonGuarded, writeJsonAtomic } from "../jsonstore.js";
+// ── The sidecar ──────────────────────────────────────────────────────────────
+/**
+ * The proposals, keyed by run (intent) id.
+ *
+ * `ReviewStore`'s shape exactly, and for `ReviewStore`'s reason: the intent
+ * store is the LIFECYCLE — state, trigger, target, result — and a proposal is
+ * none of those. It outlives the run that produced it, one sheet reads it, and
+ * putting it on `Intent` would mean every consumer of every row carrying a
+ * field it will never look at.
+ *
+ * tmp+rename, because half a JSON document is worse than none.
+ */
+export class AssessStore {
+    onChange;
+    rows = new Map();
+    path;
+    constructor(root, onChange) {
+        this.onChange = onChange;
+        this.path = join(hostStateDir(root), "assess.json");
+        try {
+            const raw = readJsonGuarded(this.path, null);
+            if (raw && typeof raw === "object") {
+                for (const [k, v] of Object.entries(raw))
+                    if (v && typeof v === "object")
+                        this.rows.set(k, v);
+            }
+        }
+        catch { /* fresh host, or a file we could not read — the map still works */ }
+        // ── Restart reconciliation ─────────────────────────────────────────────
+        //
+        // A `running` row on disk is, by construction, a lie: the run is a CHILD
+        // PROCESS of this daemon and died with the last one. Believing it costs
+        // more than a wrong status — `running()` is what refuses a second run for a
+        // repo, so one crash mid-assessment would leave that repo unable to start
+        // another one, for ever, with no way back from the phone. The intent store
+        // says the same sentence about the same row (`intents/watch.ts`'s reconcile); this
+        // is the sidecar's half, and it runs before anything can read it.
+        let stale = false;
+        for (const [id, r] of this.rows) {
+            if (r.status !== "running")
+                continue;
+            this.rows.set(id, {
+                ...r,
+                status: "failed",
+                finishedAt: Date.now(),
+                detail: "the host restarted while this assessment was running — nothing was applied, run it again if you still want it",
+            });
+            stale = true;
+        }
+        if (stale)
+            this.persist();
+    }
+    get(runId) { return this.rows.get(runId); }
+    /** Every run for one worktree, newest first — what the sheet lists. */
+    forRepo(repoDir) {
+        return [...this.rows.values()].filter((r) => r.repoDir === repoDir).sort((a, b) => b.startedAt - a.startedAt);
+    }
+    /** The run a repo's button opens: its newest, whatever state it is in. */
+    latestFor(repoDir) { return this.forRepo(repoDir)[0]; }
+    /** Every worktree this store holds a run for — what a client asking without
+     *  naming a repo is answered with, one frame each. */
+    repos() {
+        return [...new Set([...this.rows.values()].map((r) => r.repoDir))];
+    }
+    /** Is a run for this repo still going? One at a time per repo — two
+     *  assessments proposing conflicting verdicts on one list is a merge nobody
+     *  can do on a phone. */
+    running(repoDir) {
+        return this.forRepo(repoDir).find((r) => r.status === "running");
+    }
+    set(runId, patch) {
+        const next = { ...this.rows.get(runId), ...patch };
+        this.rows.set(runId, next);
+        this.evict();
+        this.shedInputs();
+        this.persist();
+        // The repo, not the run: `drop` can leave a DIFFERENT run as this repo's
+        // newest, and the snapshot is "what is this repo's latest" either way. One
+        // shape for both callers means the broadcast cannot be right for a change
+        // and wrong for a discard.
+        this.onChange(next.repoDir);
+        return next;
+    }
+    /**
+     * A reading that is only true while the run is ALIVE: memory and the socket,
+     * never the disk.
+     *
+     * Progress arrives every second or two for twenty minutes. Through `set()`
+     * that is several hundred whole-file rewrites of a store that carries every
+     * run's input snapshot — and for nothing, because a `running` row does not
+     * survive a restart by design (the constructor fails every one of them, since
+     * the run was a child process of the daemon that died). The last reading is
+     * persisted by the `set()` that settles the run, where it becomes the record
+     * of what the run did.
+     *
+     * Silently ignores an unknown id: the run is gone, so there is nothing this
+     * could be a reading of.
+     */
+    setLive(runId, patch) {
+        const cur = this.rows.get(runId);
+        if (!cur)
+            return;
+        const next = { ...cur, ...patch };
+        this.rows.set(runId, next);
+        this.onChange(next.repoDir);
+    }
+    drop(runId) {
+        const gone = this.rows.get(runId);
+        if (!gone || !this.rows.delete(runId))
+            return;
+        this.persist();
+        this.onChange(gone.repoDir);
+    }
+    /** What applying decided, recorded on the run — so the row answers "have I
+     *  dealt with this?" without re-reading the proposal it came from. */
+    recordApplied(runId, counts, at) {
+        if (!this.rows.get(runId))
+            return;
+        this.set(runId, { status: "applied", appliedAt: at, applied: counts });
+    }
+    /**
+     * Drop the assessed SNAPSHOT from runs that no longer need it.
+     *
+     * A run carries the whole `AssessInput` — every open prompt and pad note for
+     * that repo, un-clipped, because the proposal names ids and the sheet has to
+     * show the words those ids meant AT THE TIME. That is the right thing to keep
+     * while the proposal is still a decision waiting to be made, and dead weight
+     * afterwards: forty retained runs over a repo with eighty-odd long prompts is
+     * a multi-megabyte file rewritten whole (tmp+rename) three times per run.
+     *
+     * So the snapshot is kept exactly where it can still be read: the newest run
+     * of each repo (what the sheet opens), and any run that has not been settled
+     * yet. An `applied` or `discarded` older run keeps its counts, its verdicts
+     * and its status — what it decided — and loses only the copy of words that
+     * are still in the intent store and on the pad. Nothing here is the last copy
+     * of anything.
+     */
+    shedInputs() {
+        const newest = new Set();
+        for (const r of this.rows.values()) {
+            const cur = this.latestFor(r.repoDir);
+            if (cur)
+                newest.add(cur.runId);
+        }
+        for (const r of this.rows.values()) {
+            if (!r.input)
+                continue;
+            if (newest.has(r.runId))
+                continue;
+            if (r.status === "running" || r.status === "done")
+                continue;
+            delete r.input;
+        }
+    }
+    evict() {
+        if (this.rows.size <= ASSESS_MAX_RUNS)
+            return;
+        const keepNewestPerRepo = new Set();
+        for (const r of this.rows.values()) {
+            const cur = this.latestFor(r.repoDir);
+            if (cur)
+                keepNewestPerRepo.add(cur.runId);
+        }
+        const evictable = [...this.rows.values()]
+            .filter((r) => r.status !== "running" && !keepNewestPerRepo.has(r.runId))
+            .sort((a, b) => a.startedAt - b.startedAt);
+        for (const r of evictable) {
+            if (this.rows.size <= ASSESS_MAX_RUNS)
+                break;
+            this.rows.delete(r.runId);
+        }
+    }
+    persist() {
+        try {
+            mkdirSync(dirname(this.path), { recursive: true });
+            writeJsonAtomic(this.path, Object.fromEntries(this.rows), { space: 2 });
+        }
+        catch { /* best-effort — the in-memory map still works for this boot */ }
+    }
+}
+//# sourceMappingURL=hassstore.js.map

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * Pull the assistant text out of the envelope, in either shape.
+ *
+ * `--output-format json` prints one object; `stream-json` prints one object per
+ * line and the LAST one carrying a `result` is that same envelope. Searched
+ * from the end, because that is where it is and because a retained TAIL starts
+ * mid-line — the unparseable first line is simply not an event.
+ *
+ * `found` travels with the text so the caller can tell "the CLI said this" from
+ * "here is what was on stdout", which is the difference between clipping the
+ * head and clipping the tail.
+ */
+export declare function resultText(stdout: string): {
+    text: string;
+    found: boolean;
+};
+/**
+ * JSON, with the one deviation worth tolerating: a document wrapped in a
+ * markdown fence.
+ *
+ * The prompt asks for JSON only, and asking again after a failed run costs a
+ * whole repo read — so a fence, which is the single most common way a model
+ * complies-but-not-quite, is unwrapped rather than refused. Anything else is a
+ * failed run: `undefined` here means "not readable", which is a verdict, and is
+ * distinct from a document that legitimately parses to `null`.
+ */
+export declare function parseLoose(raw: string): unknown | undefined;
+export declare function writeAtomic(path: string, body: string): void;