waterplane 0.0.1 → 0.1.6

package/packages/host/dist/transcript/transcriptturns.d.ts

@@ -0,0 +1,139 @@
+/** Turns that are not in the log (screen commands, queued prompts), merged in; the history fallback. Moved from transcript.ts. */
+import type { HistoryEntry, TranscriptDoc, TranscriptTurn } from "@waterplane/shared";
+/**
+ * The commands the conversation log never wrote down, as turns.
+ *
+ * Measured case: `/btw`. The CLI answers it entirely in its own TUI and writes
+ * NOTHING to the conversation log — not an envelope, not a stdout record — so
+ * the reader showed a conversation in which the question and its answer had
+ * never happened, while the terminal one swipe away showed both. waterplane's own
+ * per-turn PTY capture (`HistoryEntry.output`) is the only record of it, and
+ * this is where that record gets to be part of the document.
+ *
+ * …as a ROW, not as its answer, for `/btw` itself: typed into a running turn
+ * (its whole purpose) the capture is that turn's screen with the overlay on it,
+ * and carving one out of the other kept breaking. The row stays — the reader
+ * says where the answer is and opens the CLI (`answeredOnlyInCli`); commands
+ * typed into an idle session keep their captured answer.
+ *
+ * Only COMMANDS, and only ones the log does not already carry: a prompt reaches
+ * the log by definition, and a command the log DID write is already a `"log"`
+ * turn with exact words — re-adding it from the screen would print it twice,
+ * the second time approximately. Matching is on the command word within a short
+ * window, because the two records are the same act seen from two sides and
+ * their timestamps differ by however long delivery took.
+ */
+export declare const LOCAL_MATCH_MS: number;
+export declare function screenCommandTurns(entries: HistoryEntry[], logged: TranscriptTurn[]): TranscriptTurn[];
+/**
+ * **What waterplane has typed in that the log has not taken yet.**
+ *
+ * The TUI HOLDS a prompt typed into a session that is mid-turn: it sits in the
+ * composer, accepted, and the CLI writes nothing to the conversation log until
+ * it actually starts it. Measured on this desktop — a prompt sent at 09:57
+ * landed in the log at 10:04, behind a turn that ran 131 tools — and for those
+ * seven minutes every reader built on that log was missing the newest thing the
+ * person had sent. The report was "the last thing I sent was accepted by the
+ * CLI and is worked on but it does not show in the list", and the outline was
+ * not wrong about the log; the log was simply not the whole of what is known.
+ *
+ * `HistoryEntry` is the other half, and a narrow one: `recordPrompt` writes it
+ * only for a delivery whose text was SEEN in the composer, so a row here means
+ * *these words are in that session*, never *this prompt ran*. That is exactly
+ * what the turn claims — no blocks, no tools, no summary, `queued`.
+ *
+ * Three rules keep it from becoming a second, fictional conversation:
+ *
+ *  - **Newer than everything the log has.** An entry at or before the newest
+ *    logged prompt is one the log has already taken (or one the CLI dropped and
+ *    a later turn has since overtaken), and the log is the better record of it.
+ *    This is also what makes the list self-healing: nothing has to be retired,
+ *    because the next logged turn is what ends a queued row's life.
+ *  - **Not already in the log**, matched on the squashed head rather than on
+ *    equality: the log stores the prompt with whatever the CLI appended to it
+ *    (an image note, a pasted-file expansion), so equality would redraw a turn
+ *    that is plainly there.
+ *  - **Bounded**, because a session can be typed into all day and the tail of
+ *    this list is the part anybody is waiting on.
+ *
+ * Local commands are `screenCommandTurns`'s: those never reach the log at all,
+ * which is a different fact needing a different row.
+ */
+/** How much of a prompt's head identifies it against the log's own copy. */
+export declare const QUEUED_HEAD = 40;
+/** Most queued rows a document will carry. */
+export declare const QUEUED_MAX = 5;
+/**
+ * **Which `queued_command` attachments are the log's ONLY record of a prompt**,
+ * by record uuid — the question `parseTranscript` has to answer before one of
+ * them may open a turn.
+ *
+ * The CLI writes that attachment for every prompt it took out of the composer
+ * queue, and then does one of two things. Usually it starts the prompt as a
+ * turn of its own and writes a `user` record for it, in which case the
+ * attachment is a duplicate and opening a turn on it would both double the
+ * prompt and steal the running turn's remaining blocks — measured: 134 records
+ * and four minutes sat between the two in one log. Sometimes it absorbs the
+ * prompt into the turn already running and writes no `user` record at all, and
+ * then the attachment is all there is.
+ *
+ * Which of the two happened is a fact about the whole file, not about the
+ * record, so it is asked here and not in `queuedPromptOf`. The `queue-operation`
+ * rows carry the CLI's own word for it (`reason: "absorbed_mid_turn"`), and it
+ * is deliberately NOT what this reads: 78 of 151 of those rows had no matching
+ * attachment at all and 5 of the remaining 73 were written the other way round
+ * in the file, so a correlation on them answers wrongly about half the time.
+ * The presence or absence of the prompt's own `user` record is the thing that
+ * actually decides where the blocks belong, and it is what this asks.
+ *
+ * Matched on the squashed head with `queuedTurns`' prefix rule, and for its
+ * reason: the log stores a prompt with whatever the CLI appended to it (an
+ * image note, a pasted-file expansion), so equality would miss the duplicate
+ * and draw the turn twice.
+ *
+ * Costs a second parse of the same lines, so it is gated on the file holding
+ * such an attachment at all — measured: 78 of 1,375 logs on this desktop, and
+ * the gate is a substring scan.
+ */
+export declare function absorbedOpeners(lines: string[]): Set<string>;
+/**
+ * **Words a person typed into a choice box, as the log recorded them.**
+ *
+ * An `AskUserQuestion` box with an "Other" field takes free text, and the phone
+ * types it there through the ordinary send path — so it is in our history as a
+ * prompt. The CLI never logs it as one: the words come back once, inside the
+ * box's `tool_result` (`The user answered: "question"="words", …`). Nothing in
+ * `queuedTurns` matched that, so both answers to a two-question box sat under
+ * the reply as *the CLI has not started it yet* for ever — reported as "read
+ * mode is not getting the latest output", and again it was the bookkeeping,
+ * not the output.
+ *
+ * Kept OFF the document (a `WeakMap` on the parse result): it is a fact the
+ * host needs to retire its own rows, not something the wire should carry, and
+ * a `lite` parse drops tool results, so it cannot be read back off the blocks.
+ */
+export type BoxAnswer = {
+    at: number;
+    text: string;
+};
+export declare const BOX_ANSWER_LEAD = "The user answered";
+export declare const boxAnswerTable: WeakMap<object, BoxAnswer[]>;
+/** The box answers `parseTranscript` saw in this document's log, oldest first. */
+export declare function boxAnswersOf(doc: object | null | undefined): BoxAnswer[];
+export declare function queuedTurns(entries: HistoryEntry[], logged: TranscriptTurn[], answers?: BoxAnswer[]): TranscriptTurn[];
+/**
+ * Merge screen-only turns into a parsed document, in time order.
+ *
+ * Renumbering is the point: `n` is what the outline lists and what the reader
+ * scrolls to, so a turn spliced into the middle without renumbering gives two
+ * turns the same number and the outline lands on the wrong one. Anything
+ * without a timestamp keeps its place rather than sorting to the front.
+ */
+export declare function mergeLocalTurns(turns: TranscriptTurn[], extra: TranscriptTurn[]): TranscriptTurn[];
+/**
+ * Fallback for sessions with no conversation log yet (stub binary, a session
+ * that hasn't produced output, hooks off): synthesize turns from the recorded
+ * prompt + ANSI-stripped PTY capture. Approximate by construction — one opaque
+ * text block per turn — but it keeps the reader view useful everywhere.
+ */
+export declare function transcriptFromHistory(entries: HistoryEntry[]): Omit<TranscriptDoc, "sessionId" | "source">;

package/packages/host/dist/transcript/transcriptturns.js

@@ -0,0 +1,270 @@
+import { squash } from "../echo.js";
+import { TEXT_CAP, answeredOnlyInCli, oneLine } from "@waterplane/shared";
+import { localCommandOf, promptOf, queuedPromptOf } from "./transcriptlog.js";
+import { foldRepaints, scrollHintTrimmed, sliceToCommand, trimTuiChrome } from "./transcriptscreen.js";
+/**
+ * The commands the conversation log never wrote down, as turns.
+ *
+ * Measured case: `/btw`. The CLI answers it entirely in its own TUI and writes
+ * NOTHING to the conversation log — not an envelope, not a stdout record — so
+ * the reader showed a conversation in which the question and its answer had
+ * never happened, while the terminal one swipe away showed both. waterplane's own
+ * per-turn PTY capture (`HistoryEntry.output`) is the only record of it, and
+ * this is where that record gets to be part of the document.
+ *
+ * …as a ROW, not as its answer, for `/btw` itself: typed into a running turn
+ * (its whole purpose) the capture is that turn's screen with the overlay on it,
+ * and carving one out of the other kept breaking. The row stays — the reader
+ * says where the answer is and opens the CLI (`answeredOnlyInCli`); commands
+ * typed into an idle session keep their captured answer.
+ *
+ * Only COMMANDS, and only ones the log does not already carry: a prompt reaches
+ * the log by definition, and a command the log DID write is already a `"log"`
+ * turn with exact words — re-adding it from the screen would print it twice,
+ * the second time approximately. Matching is on the command word within a short
+ * window, because the two records are the same act seen from two sides and
+ * their timestamps differ by however long delivery took.
+ */
+export const LOCAL_MATCH_MS = 3 * 60_000;
+export function screenCommandTurns(entries, logged) {
+    const out = [];
+    for (const e of entries) {
+        const text = (e.text ?? "").trim();
+        if (!text.startsWith("/"))
+            continue;
+        const head = text.split(/\s+/)[0];
+        const already = logged.some((t) => t.prompt.trim().split(/\s+/)[0] === head &&
+            Math.abs((t.sentAt ?? 0) - e.sentAt) < LOCAL_MATCH_MS);
+        if (already)
+            continue;
+        // Typed into a turn that was still running, and the capture never shows the
+        // command's echo: then the capture is that TURN's output, which the log
+        // already holds, not the command's answer. Measured: an `/effort high`
+        // typed 50 s into a turn that launched background agents came back as a
+        // frozen copy of the turn's screen, sorted after it, so the reader's tail
+        // was a 20:42 snapshot ("took 2m") while the turn above it ran to 21:08.
+        // Absent, not someone else's words: no body and no finish claimed.
+        const midTurn = logged.some((t) => !t.local && (t.sentAt ?? Infinity) <= e.sentAt && (t.endedAt ?? 0) > e.sentAt);
+        const echoed = !!e.output && e.output.split("\n").some((l) => l.trim().startsWith(head));
+        const own = !midTurn || echoed;
+        // `/btw`: a row with no body, by decision rather than by miss — the reader
+        // says the answer is in the CLI and opens it (`answeredOnlyInCli`).
+        const cut = e.output && own && !answeredOnlyInCli(text) ? sliceToCommand(e.output, text) : "";
+        const body = cut ? trimTuiChrome(foldRepaints(cut, text)) : "";
+        // Asked of the CUT capture, not of `body`: the hint is exactly what `body`
+        // has had removed, so reading it back off the trimmed text finds nothing.
+        const clipped = cut ? scrollHintTrimmed(cut) : false;
+        out.push({
+            id: `screen:${e.id}`,
+            n: 0, // renumbered by `mergeLocalTurns`
+            prompt: text.slice(0, TEXT_CAP),
+            promptLabel: oneLine(text),
+            sentAt: e.sentAt,
+            endedAt: own ? e.outputAt : undefined,
+            blocks: body
+                ? [{ kind: "screen", text: body.slice(0, TEXT_CAP), ...(clipped ? { scrollable: true } : {}) }]
+                : [],
+            toolCount: 0,
+            files: [],
+            sidechains: 0,
+            local: "screen",
+        });
+    }
+    return out;
+}
+/**
+ * **What waterplane has typed in that the log has not taken yet.**
+ *
+ * The TUI HOLDS a prompt typed into a session that is mid-turn: it sits in the
+ * composer, accepted, and the CLI writes nothing to the conversation log until
+ * it actually starts it. Measured on this desktop — a prompt sent at 09:57
+ * landed in the log at 10:04, behind a turn that ran 131 tools — and for those
+ * seven minutes every reader built on that log was missing the newest thing the
+ * person had sent. The report was "the last thing I sent was accepted by the
+ * CLI and is worked on but it does not show in the list", and the outline was
+ * not wrong about the log; the log was simply not the whole of what is known.
+ *
+ * `HistoryEntry` is the other half, and a narrow one: `recordPrompt` writes it
+ * only for a delivery whose text was SEEN in the composer, so a row here means
+ * *these words are in that session*, never *this prompt ran*. That is exactly
+ * what the turn claims — no blocks, no tools, no summary, `queued`.
+ *
+ * Three rules keep it from becoming a second, fictional conversation:
+ *
+ *  - **Newer than everything the log has.** An entry at or before the newest
+ *    logged prompt is one the log has already taken (or one the CLI dropped and
+ *    a later turn has since overtaken), and the log is the better record of it.
+ *    This is also what makes the list self-healing: nothing has to be retired,
+ *    because the next logged turn is what ends a queued row's life.
+ *  - **Not already in the log**, matched on the squashed head rather than on
+ *    equality: the log stores the prompt with whatever the CLI appended to it
+ *    (an image note, a pasted-file expansion), so equality would redraw a turn
+ *    that is plainly there.
+ *  - **Bounded**, because a session can be typed into all day and the tail of
+ *    this list is the part anybody is waiting on.
+ *
+ * Local commands are `screenCommandTurns`'s: those never reach the log at all,
+ * which is a different fact needing a different row.
+ */
+/** How much of a prompt's head identifies it against the log's own copy. */
+export const QUEUED_HEAD = 40;
+/** Most queued rows a document will carry. */
+export const QUEUED_MAX = 5;
+/**
+ * **Which `queued_command` attachments are the log's ONLY record of a prompt**,
+ * by record uuid — the question `parseTranscript` has to answer before one of
+ * them may open a turn.
+ *
+ * The CLI writes that attachment for every prompt it took out of the composer
+ * queue, and then does one of two things. Usually it starts the prompt as a
+ * turn of its own and writes a `user` record for it, in which case the
+ * attachment is a duplicate and opening a turn on it would both double the
+ * prompt and steal the running turn's remaining blocks — measured: 134 records
+ * and four minutes sat between the two in one log. Sometimes it absorbs the
+ * prompt into the turn already running and writes no `user` record at all, and
+ * then the attachment is all there is.
+ *
+ * Which of the two happened is a fact about the whole file, not about the
+ * record, so it is asked here and not in `queuedPromptOf`. The `queue-operation`
+ * rows carry the CLI's own word for it (`reason: "absorbed_mid_turn"`), and it
+ * is deliberately NOT what this reads: 78 of 151 of those rows had no matching
+ * attachment at all and 5 of the remaining 73 were written the other way round
+ * in the file, so a correlation on them answers wrongly about half the time.
+ * The presence or absence of the prompt's own `user` record is the thing that
+ * actually decides where the blocks belong, and it is what this asks.
+ *
+ * Matched on the squashed head with `queuedTurns`' prefix rule, and for its
+ * reason: the log stores a prompt with whatever the CLI appended to it (an
+ * image note, a pasted-file expansion), so equality would miss the duplicate
+ * and draw the turn twice.
+ *
+ * Costs a second parse of the same lines, so it is gated on the file holding
+ * such an attachment at all — measured: 78 of 1,375 logs on this desktop, and
+ * the gate is a substring scan.
+ */
+export function absorbedOpeners(lines) {
+    const out = new Set();
+    if (!lines.some((l) => l.includes('"queued_command"')))
+        return out;
+    const logged = [];
+    const cand = [];
+    for (const raw of lines) {
+        const ln = raw.trim();
+        if (!ln)
+            continue;
+        let rec;
+        try {
+            rec = JSON.parse(ln);
+        }
+        catch {
+            continue;
+        }
+        const q = queuedPromptOf(rec);
+        if (q != null) {
+            const head = squash(q).slice(0, QUEUED_HEAD);
+            const uuid = String(rec.uuid ?? "");
+            if (head && uuid)
+                cand.push({ uuid, head });
+            continue;
+        }
+        // Both openers `parseTranscript` has. A local command counts: `/compact`
+        // queued behind a turn reaches the log as its own envelope, and a turn
+        // opened twice for it is the same duplicate.
+        const text = promptOf(rec) ?? localCommandOf(rec);
+        if (text == null)
+            continue;
+        const head = squash(text).slice(0, QUEUED_HEAD);
+        if (head)
+            logged.push(head);
+    }
+    for (const c of cand) {
+        if (logged.some((h) => h.startsWith(c.head) || c.head.startsWith(h)))
+            continue;
+        out.add(c.uuid);
+    }
+    return out;
+}
+export const BOX_ANSWER_LEAD = "The user answered";
+export const boxAnswerTable = new WeakMap();
+/** The box answers `parseTranscript` saw in this document's log, oldest first. */
+export function boxAnswersOf(doc) {
+    return (doc && boxAnswerTable.get(doc)) || [];
+}
+export function queuedTurns(entries, logged, answers = []) {
+    const newestLogged = logged.reduce((m, t) => Math.max(m, t.sentAt ?? 0), 0);
+    const heads = logged.map((t) => squash(t.prompt).slice(0, QUEUED_HEAD)).filter(Boolean);
+    const out = [];
+    for (const e of entries) {
+        const text = (e.text ?? "").trim();
+        if (!text || text.startsWith("/"))
+            continue; // a command is the other function's
+        if (!(e.sentAt > newestLogged))
+            continue;
+        const head = squash(text).slice(0, QUEUED_HEAD);
+        if (!head || heads.some((h) => h.startsWith(head) || head.startsWith(h)))
+            continue;
+        // Typed into a box rather than the composer: the answer recorded after it
+        // carries the words. Only a LATER answer — an older one with the same
+        // words is a different send.
+        if (answers.some((a) => a.at >= e.sentAt && a.text.includes(head)))
+            continue;
+        out.push({
+            id: `queued:${e.id}`,
+            n: 0, // renumbered by `mergeLocalTurns`
+            prompt: text.slice(0, TEXT_CAP),
+            promptLabel: oneLine(text),
+            sentAt: e.sentAt,
+            blocks: [],
+            toolCount: 0,
+            files: [],
+            sidechains: 0,
+            queued: true,
+        });
+    }
+    return out.slice(-QUEUED_MAX);
+}
+/**
+ * Merge screen-only turns into a parsed document, in time order.
+ *
+ * Renumbering is the point: `n` is what the outline lists and what the reader
+ * scrolls to, so a turn spliced into the middle without renumbering gives two
+ * turns the same number and the outline lands on the wrong one. Anything
+ * without a timestamp keeps its place rather than sorting to the front.
+ */
+export function mergeLocalTurns(turns, extra) {
+    if (!extra.length)
+        return turns;
+    // Stable by construction: every turn from the log carries a timestamp, and a
+    // screen turn carries the moment waterplane typed it, so ties are the two records
+    // of one act and either order reads correctly.
+    const all = [...turns, ...extra].sort((a, b) => (a.sentAt ?? 0) - (b.sentAt ?? 0));
+    return all.map((t, i) => ({ ...t, n: i + 1 }));
+}
+/**
+ * Fallback for sessions with no conversation log yet (stub binary, a session
+ * that hasn't produced output, hooks off): synthesize turns from the recorded
+ * prompt + ANSI-stripped PTY capture. Approximate by construction — one opaque
+ * text block per turn — but it keeps the reader view useful everywhere.
+ */
+export function transcriptFromHistory(entries) {
+    const turns = entries.map((e, i) => {
+        const blocks = e.output ? [{ kind: "text", text: e.output.slice(0, TEXT_CAP) }] : [];
+        return {
+            id: e.id,
+            n: i + 1,
+            prompt: e.text,
+            promptLabel: oneLine(e.text),
+            sentAt: e.sentAt,
+            endedAt: e.outputAt,
+            blocks,
+            summary: e.output ? oneLine(e.output.trim().split("\n").filter(Boolean).slice(-1)[0] ?? "", 200) : undefined,
+            toolCount: 0,
+            files: [],
+            sidechains: 0,
+        };
+    });
+    // `full` is the honest label: there are no tool blocks here to have withheld
+    // anything from, so the reader must not offer a "load details" affordance.
+    return { turns, truncated: false, bytes: 0, updatedAt: entries.length ? entries[entries.length - 1].sentAt : 0, detail: "full" };
+}
+//# sourceMappingURL=transcriptturns.js.map

package/packages/host/dist/transcript/transcriptturns.js.map

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

package/packages/host/dist/transcript.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Structured conversation transcript — the reader view behind the CLI.
+ *
+ * The terminal is a grid of ANSI cells: fine to drive, miserable to scroll,
+ * search or tap a link in on a phone. The claude CLI already keeps a lossless
+ * structured log of every conversation at
+ * `~/.claude/projects/<slug>/<conversation-uuid>.jsonl` (one JSON record per
+ * line), so we parse THAT into turns/blocks and let the phone render normal
+ * DOM. Exact message boundaries, real tool names + inputs + results, no
+ * re-wrapping, no escape codes.
+ *
+ * Everything here is read-only and best-effort: an unparseable line is skipped,
+ * a missing file yields null, and the caller falls back to the PTY-capture
+ * history. Record shapes are the CLI's internal format — treat them as
+ * heuristics like prompt.ts/limit.ts, not a contract.
+ *
+ * The code is cut by subject into `transcript/` (this file is the barrel every
+ * importer keeps using): `transcriptlog.ts` (where the log is, record
+ * predicates), `transcriptparse.ts` (the log as turns and blocks),
+ * `transcriptscreen.ts` (TUI chrome trimming) and `transcriptturns.ts` (turns
+ * the log does not hold, merged in).
+ */
+export { MAX_TURNS, TOOL_INPUT_CAP, TOOL_RESULT_CAP, TEXT_CAP, promptLabel, summarize } from "@waterplane/shared";
+export { claudeConfigDir, claudeProjectDir } from "./claudeconfig.js";
+export { lastTurnAt, localCommandOf, localOutputOf, logMtime, opensTurn, promptOf, queuedPromptOf, transcriptPath } from "./transcript/transcriptlog.js";
+export { parseTranscript, toolDetails } from "./transcript/transcriptparse.js";
+export { foldRepaints, scrollHintTrimmed, sliceToCommand, trimTuiChrome } from "./transcript/transcriptscreen.js";
+export { absorbedOpeners, boxAnswersOf, mergeLocalTurns, queuedTurns, screenCommandTurns, transcriptFromHistory } from "./transcript/transcriptturns.js";

package/packages/host/dist/transcript.js

@@ -0,0 +1,34 @@
+/**
+ * Structured conversation transcript — the reader view behind the CLI.
+ *
+ * The terminal is a grid of ANSI cells: fine to drive, miserable to scroll,
+ * search or tap a link in on a phone. The claude CLI already keeps a lossless
+ * structured log of every conversation at
+ * `~/.claude/projects/<slug>/<conversation-uuid>.jsonl` (one JSON record per
+ * line), so we parse THAT into turns/blocks and let the phone render normal
+ * DOM. Exact message boundaries, real tool names + inputs + results, no
+ * re-wrapping, no escape codes.
+ *
+ * Everything here is read-only and best-effort: an unparseable line is skipped,
+ * a missing file yields null, and the caller falls back to the PTY-capture
+ * history. Record shapes are the CLI's internal format — treat them as
+ * heuristics like prompt.ts/limit.ts, not a contract.
+ *
+ * The code is cut by subject into `transcript/` (this file is the barrel every
+ * importer keeps using): `transcriptlog.ts` (where the log is, record
+ * predicates), `transcriptparse.ts` (the log as turns and blocks),
+ * `transcriptscreen.ts` (TUI chrome trimming) and `transcriptturns.ts` (turns
+ * the log does not hold, merged in).
+ */
+// The caps, `promptLabel` and `summarize` are shared with every store reader a
+// plugin contributes (`shared/transcriptfold.ts`), so a second backend's reader
+// view is capped by the same rule; re-exported so every caller here is unchanged.
+export { MAX_TURNS, TOOL_INPUT_CAP, TOOL_RESULT_CAP, TEXT_CAP, promptLabel, summarize } from "@waterplane/shared";
+// The CLI's private dir and the cwd -> project folder rule live in
+// `claudeconfig.ts` (one definition); re-exported for readers that import them here.
+export { claudeConfigDir, claudeProjectDir } from "./claudeconfig.js";
+export { lastTurnAt, localCommandOf, localOutputOf, logMtime, opensTurn, promptOf, queuedPromptOf, transcriptPath } from "./transcript/transcriptlog.js";
+export { parseTranscript, toolDetails } from "./transcript/transcriptparse.js";
+export { foldRepaints, scrollHintTrimmed, sliceToCommand, trimTuiChrome } from "./transcript/transcriptscreen.js";
+export { absorbedOpeners, boxAnswersOf, mergeLocalTurns, queuedTurns, screenCommandTurns, transcriptFromHistory } from "./transcript/transcriptturns.js";
+//# sourceMappingURL=transcript.js.map

package/packages/host/dist/transcript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.js","sourceRoot":"","sources":["../src/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+EAA+E;AAC/E,gFAAgF;AAChF,kFAAkF;AAClF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAElH,mEAAmE;AACnE,qFAAqF;AACrF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACzJ,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAClH,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC"}

package/packages/host/dist/transportsurvey.d.ts

@@ -0,0 +1,10 @@
+import { type TransportSurvey } from "@waterplane/shared";
+/**
+ * Every discovered worktree, ranked by what its transport directories hold.
+ *
+ * `discoverTargets` is the same enumeration the launcher uses, so a repo that
+ * can be opened is a repo that appears here — and one that cannot, does not.
+ * Its cost (a `git worktree list` per repo) is one the phone already pays on
+ * every launcher open.
+ */
+export declare function surveyTransport(root: string, now?: number): Promise<TransportSurvey>;

package/packages/host/dist/transportsurvey.js

@@ -0,0 +1,109 @@
+/**
+ * How much every repo's transport directories hold — the reading the per-repo
+ * sweep cannot give you.
+ *
+ * ── Why ─────────────────────────────────────────────────────────────────────
+ *
+ * `SweepSheet` is reached from ONE repo's gallery, so using it means already
+ * knowing which repo is fat. Measured here: 7.5 GB across fourteen repos, with
+ * 4.5 GB in one and 2.5 GB in a second and a long tail of tens of megabytes.
+ * Finding that by hand is fourteen trips through a sheet that answers one repo
+ * at a time.
+ *
+ * ── It walks nothing of its own ─────────────────────────────────────────────
+ *
+ * Every row comes from `listTransport` — the SAME function the per-repo sweep's
+ * GET serves its rows from. That is not a convenience: the survey's number and
+ * the total the sweep opens to must be one function, or the row says 38 files
+ * and the sheet it opens shows 39, and a person learns to distrust both. The
+ * only thing this module adds is the loop, the ranking (in `@waterplane/shared`, so
+ * the phone cannot re-derive it differently) and the bound below.
+ *
+ * ── The bound, and why there is one at all ──────────────────────────────────
+ *
+ * `listTransport` is synchronous `readdir` + `lstat`, and this runs on the loop
+ * that pumps every PTY in the house. The measured worst case is a 523-file
+ * inbox and fourteen repos, i.e. single-digit milliseconds — so the bound is
+ * not about today's numbers. It is about the fact that nothing stops a repo
+ * from holding a hundred thousand files, and that a phone can ask for this
+ * whenever it likes.
+ *
+ * Two things follow, and both matter:
+ *
+ *  - **Past the budget, that repo's tally is `null`, never a partial count.**
+ *    A truncated count printed as a total is exactly the wrong number CLAUDE.md
+ *    forbids — and it is worse here than usual, because the number's whole job
+ *    is to tell you which repo to go and delete things in.
+ *  - **A yield between repos.** `await setImmediate` hands the loop back so a
+ *    survey of a pathological tree cannot stall a keystroke on its way to a
+ *    session.
+ *
+ * Nothing is cached. The walk is cheaper than a stale answer would be worth,
+ * and a cached byte total on a screen about deleting is the reading most likely
+ * to be acted on and least likely to be true.
+ *
+ * **Nothing applies itself**: this measures. It deletes nothing, schedules
+ * nothing, and there is no "sweep every repo" anywhere above it — a person
+ * taps a row and lands in the per-repo sweep, where they still pick a cut and
+ * still confirm.
+ *
+ * `packages/host/test/transportsurvey.test.mjs`.
+ */
+import { setImmediate as yieldToLoop } from "node:timers/promises";
+import { summarizeSurvey, tally } from "@waterplane/shared";
+import { listTransport } from "./files.js";
+import { discoverTargets } from "./repos.js";
+/**
+ * Entries one repo's two directories may hold before the survey gives up on
+ * counting it.
+ *
+ * Not a knob (no env var, nothing in `.env.example`): a survey that counts a
+ * different amount on two desktops is a survey whose "not counted" row means
+ * something different in every bug report. 50 000 is two orders of magnitude
+ * above the worst directory measured here, and the shape of `builds.ts`'
+ * `detectArtifacts` budget.
+ */
+const ENTRY_BUDGET = 50_000;
+/** One scope of one repo, or null when it went past the budget or could not be
+ *  read. The two failures collapse deliberately — from the phone they are the
+ *  same fact ("this screen does not know"), and telling them apart would need a
+ *  sentence per row that nobody can act on differently. */
+function scopeTally(worktree, scope) {
+    try {
+        const rows = listTransport(worktree, scope);
+        if (rows.length > ENTRY_BUDGET)
+            return null;
+        return tally(rows);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Every discovered worktree, ranked by what its transport directories hold.
+ *
+ * `discoverTargets` is the same enumeration the launcher uses, so a repo that
+ * can be opened is a repo that appears here — and one that cannot, does not.
+ * Its cost (a `git worktree list` per repo) is one the phone already pays on
+ * every launcher open.
+ */
+export async function surveyTransport(root, now = Date.now()) {
+    const targets = await discoverTargets(root);
+    const rows = [];
+    for (const t of targets) {
+        rows.push({
+            repoId: t.id,
+            repoName: t.repoName,
+            branch: t.branch,
+            isPrimary: t.isPrimary,
+            outbox: scopeTally(t.worktreePath, "outbox"),
+            inbox: scopeTally(t.worktreePath, "inbox"),
+        });
+        // Between repos, not inside one: `listTransport` is synchronous and
+        // splitting it would mean a directory measured across two instants.
+        await yieldToLoop();
+    }
+    const { repos, total, partial } = summarizeSurvey(rows);
+    return { at: now, repos, total, partial };
+}
+//# sourceMappingURL=transportsurvey.js.map

package/packages/host/dist/transportsurvey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportsurvey.js","sourceRoot":"","sources":["../src/transportsurvey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,OAAO,EAAE,YAAY,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAiD,MAAM,oBAAoB,CAAC;AAC3G,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,YAAY,GAAG,MAAM,CAAC;AAE5B;;;2DAG2D;AAC3D,SAAS,UAAU,CAAC,QAAgB,EAAE,KAAyB;IAC7D,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,IAAI,CAAC,MAAM,GAAG,YAAY;YAAE,OAAO,IAAI,CAAC;QAC5C,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;IAClE,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAyB,EAAE,CAAC;IACtC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,IAAI,CAAC;YACR,MAAM,EAAE,CAAC,CAAC,EAAE;YACZ,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,MAAM,EAAE,CAAC,CAAC,MAAM;YAChB,SAAS,EAAE,CAAC,CAAC,SAAS;YACtB,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,EAAE,QAAQ,CAAC;YAC5C,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,EAAE,OAAO,CAAC;SAC3C,CAAC,CAAC;QACH,oEAAoE;QACpE,oEAAoE;QACpE,MAAM,WAAW,EAAE,CAAC;IACtB,CAAC;IACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACxD,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC5C,CAAC"}