waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/wire/session/archive.d.ts

@@ -0,0 +1,286 @@
+import type { LaunchOpts } from "./launch.js";
+import type { FollowUp } from "./info.js";
+import type { ContextSpark } from "./contextspark.js";
+/** A file a session's turn left in its worktree: an image or video that
+ *  appeared, or a markdown file that appeared or was rewritten. */
+export interface NewImage {
+    name: string;
+    /** Worktree-relative path (forward slashes). */
+    relPath: string;
+    mtime: number;
+    /** Markdown only: the file existed before and this turn rewrote it. */
+    changed?: true;
+}
+/** A session descriptor persisted across host restarts (for resume). One entry
+ *  PER CONVERSATION (keyed by claudeSessionId), not per directory — several
+ *  sessions in the same repo each stay individually resumable after a restart. */
+export interface RecentSession {
+    cwd: string;
+    title: string;
+    lastActive: number;
+    /** Claude conversation UUID → resume THIS conversation (`--resume <id>`).
+     *  Absent on legacy entries; those fall back to per-directory `--continue`. */
+    claudeSessionId?: string;
+    /**
+     * The BACKEND'S OWN conversation id, for a row that is not claude's
+     * (opencode's `ses_…`) — so reopening this row carries on THIS conversation
+     * (`--session <id>`) instead of whichever one the directory's `--continue`
+     * happens to land on.
+     *
+     * A second field rather than a second meaning for `claudeSessionId`: every
+     * log reader in the daemon turns that one into a path under
+     * `~/.claude/projects`, and an opencode id there is a reader pointed at a file
+     * that will never exist. Absent whenever the host never discovered an id, in
+     * which case the reopen degrades to `--continue` exactly as it did before.
+     */
+    backendSessionId?: string;
+    /** Launch flags the session ran with, so a resume restores model/effort/etc. */
+    launch?: LaunchOpts;
+}
+/**
+ * A bookmark on one conversation (R-conversations-007): "I will want to look
+ * at this again". Kept by the host per repo directory, keyed by conversation
+ * id, so it survives the session closing, a restart and the conversation
+ * leaving every shortlist. Not a star (waiting on it), not a follow-up flag
+ * (a reading list), not "keep" (do not close) — closing a bookmarked session
+ * is fine; the archive finds it again. Read through `cleanBookmark`.
+ */
+export interface Bookmark {
+    /** When it was set (host clock, ms). */
+    at: number;
+    /** The person's one-line note, clipped (`BOOKMARK_NOTE_CAP`). */
+    note?: string;
+    /** The tab's name at bookmark time, when the phone knew one — so the row
+     *  still has a name after the closed-row shortlist has forgotten it. */
+    name?: string;
+}
+/** A session that was closed (killed/exited) — kept in a short stack so a
+ *  mis-tap on the close button can be undone, newest-first. */
+/**
+ * One conversation the `claude` CLI wrote for a directory — the ARCHIVE row.
+ *
+ * Not a session: there is no PTY, no boot id and no live state. The only thing
+ * it needs to be resumable is `id`, which is the conversation uuid the log file
+ * is named after (`--resume <id>`).
+ */
+export interface ArchivedConversation {
+    /** Claude conversation uuid = the jsonl basename. */
+    id: string;
+    cwd: string;
+    /** First user prompt, one line. Empty when the conversation holds no prompt —
+     *  a session opened and closed without being typed into. */
+    title: string;
+    /** Log mtime = when the conversation was last active. */
+    mtime: number;
+    size: number;
+    /** The session's tab name, when the host still knows it for this
+     *  conversation (a live session or a closed row), else the bookmark's
+     *  remembered one. Absent = no name known; never derived here. */
+    name?: string;
+    /** The conversation's bookmark, stamped by the host at list time. */
+    bookmark?: Bookmark;
+}
+export interface ArchiveListing {
+    cwd: string;
+    /** Rows matching the query (or all of them), across every page. */
+    total: number;
+    offset: number;
+    rows: ArchivedConversation[];
+    /** Conversations on disk for this directory, before any query. */
+    scanned: number;
+    /** True when the listing was cut to bookmarked conversations (`bookmarked=1`);
+     *  `total` then counts those. Absent on an older host — which ignored the
+     *  filter, so a phone must not call its rows "bookmarks". */
+    bookmarked?: boolean;
+}
+export interface ClosedSession {
+    id: string;
+    cwd: string;
+    title: string;
+    closedAt: number;
+    /** Launch flags the session ran with, so a reopen restores model/effort/etc. */
+    launch?: LaunchOpts;
+    /** Claude conversation UUID → reopen resumes THIS conversation (`--resume <id>`),
+     *  not just the directory's most recent (`--continue`). */
+    claudeSessionId?: string;
+    /**
+     * The BACKEND'S OWN conversation id, for a row that is not claude's
+     * (opencode's `ses_…`) — so reopening this row carries on THIS conversation
+     * (`--session <id>`) instead of whichever one the directory's `--continue`
+     * happens to land on.
+     *
+     * A second field rather than a second meaning for `claudeSessionId`: every
+     * log reader in the daemon turns that one into a path under
+     * `~/.claude/projects`, and an opencode id there is a reader pointed at a file
+     * that will never exist. Absent whenever the host never discovered an id, in
+     * which case the reopen degrades to `--continue` exactly as it did before.
+     */
+    backendSessionId?: string;
+    /** True when the session is only BACKGROUNDED — still running live in tmux, so a
+     *  reopen re-attaches the same process (in-flight turn intact) instead of a fresh
+     *  `--continue`. False/absent ⇒ genuinely ended. */
+    alive?: boolean;
+    /**
+     * With `alive`: why this host did not take the still-running session back
+     * after a restart — its backend comes from a plugin that is not running
+     * ("…runs on "stubcli", which the plugin Stub CLI registers; switch it on…").
+     * The session is adopted as soon as that backend registers. Absent otherwise.
+     */
+    unadopted?: string;
+    /** Why the session ended. See `ClosedBy`. */
+    closedBy?: ClosedBy;
+    /** `SessionInfo.contextSpark` as it stood at close, so a closed row draws the
+     *  same context/spend miniature as an open one. Absent when the session had
+     *  none, or on an older row. */
+    contextSpark?: ContextSpark;
+    /** The conversation's follow-up flag, stamped by the host when it lists the
+     *  closed stack (never persisted on the row — the flag store owns it). */
+    followUp?: FollowUp;
+    /** The conversation's bookmark, stamped the same way (the bookmark store
+     *  owns it; never persisted on the row). */
+    bookmark?: Bookmark;
+    /** `closedBy` "exited"/"limit": the process's own exit code, when node-pty
+     *  reported one. */
+    exitCode?: number;
+    /** `closedBy` "exited"/"limit": the signal number it died of, when it did. */
+    exitSignal?: number;
+    /** `closedBy` "limit": the session the host reopened this conversation as
+     *  (`doResurrect`) — written onto the row when that reopen happens. */
+    resumedAs?: string;
+    /** How the session was OPENED. See `SessionOriginKind`. */
+    kind?: SessionOriginKind;
+    /** The intent/backlog row that opened it (`kind` backlog/schedule/agent/fanout,
+     *  or a `resurrect` of one of those). */
+    itemId?: string;
+    /** That row's display name at open time (`itemHeadline`, else its first step). */
+    itemLabel?: string;
+    /** That row's lifecycle at close time — ONLY a settled one (done/failed/
+     *  canceled); a row still running when its session ended says nothing here. */
+    itemState?: "done" | "failed" | "canceled";
+    /** With `itemState`: the row's own `result.ok` / one-line `result.detail`. */
+    itemOk?: boolean;
+    itemDetail?: string;
+    /** `kind` resurrect/fork: the session id this one continued. */
+    fromSession?: string;
+    /** `SessionInfo.createdAt` — so a duration is `closedAt - openedAt`. */
+    openedAt?: number;
+    /** The last turn this session is known to have taken: the CLI log's last
+     *  turn (`lastTurnAt`), else the last recorded prompt's capture. */
+    lastActiveAt?: number;
+    /** Prompts this host recorded into it (`HistoryEntry`s — phone, queue,
+     *  automation). A FLOOR: words typed at the desktop keyboard are not counted,
+     *  and the history keeps at most 200. Absent when none were recorded. */
+    turns?: number;
+    /** First / last recorded prompt, one line, clipped. */
+    firstPrompt?: string;
+    lastPrompt?: string;
+    /** The ≤4-word tab name, when one was derived. */
+    tabTitle?: string;
+    /** The model it was running (`SessionInfo.model` — the running one once a
+     *  turn named it, else the launch flag). */
+    model?: string;
+}
+/**
+ * Why a session ended, as far as the host can tell them apart:
+ *
+ * - `you`       — a person closed it (× / close / kill / background-detach).
+ * - `replaced`  — a person's relaunch (`replaceSessionId`) closed it to open
+ *                 its replacement.
+ * - `auto-done` — the backlog's linger sweep: its item said close-when-done
+ *                 and it sat idle past the linger after the work finished.
+ * - `auto-slot` — reaped early to free an automatic-session slot for a waiting
+ *                 item (also only close-when-done sessions). No longer written:
+ *                 an idle session holds no slot (R-automation-042); older
+ *                 closed rows still carry it.
+ * - `exited`    — the CLI process ended on its own (/exit, crash, signal);
+ *                 `exitCode`/`exitSignal` say how when known.
+ * - `limit`     — it exited at a usage limit; the host reopens it at the reset
+ *                 when auto-continue is on (`resumedAs` once it has).
+ *
+ * There is no "host shutdown" value: a daemon restart leaves tmux sessions
+ * running (re-attached on boot).
+ */
+export type ClosedBy = "you" | "replaced" | "auto-done" | "auto-slot" | "exited" | "limit";
+/**
+ * How a session was opened:
+ * `hand` (a person's create on the wire), `fork` (a person's fork of another
+ * session), `backlog` (a backlog item's own session, or the repo's backlog
+ * session), `schedule` (a scheduled/timed row), `agent` (a prompt an agent
+ * posted for later), `fanout` (one repo of a fan-out), `resurrect` (the host
+ * reopening a session that exited at a usage limit).
+ */
+export type SessionOriginKind = "hand" | "fork" | "backlog" | "schedule" | "agent" | "fanout" | "resurrect";
+/** What the HOST remembers about how one live session was opened — carried
+ *  onto its closed row. Host-side (and in the tmux `live/` record), not on
+ *  `SessionInfo`. */
+export interface SessionOrigin {
+    kind: SessionOriginKind;
+    itemId?: string;
+    itemLabel?: string;
+    fromSession?: string;
+    /** A temporary companion shell: the session this one belongs to. Closing
+     *  that session closes this one too (host `drive.remove`); a relaunch or a
+     *  limit resurrect of it re-points the link to the new id. */
+    companionOf?: string;
+}
+/**
+ * One recorded prompt sent to a session, plus the (ANSI-stripped) terminal
+ * output captured for that turn. Built by the host as prompts are submitted and
+ * the turn goes idle; surfaced in the per-session History view.
+ */
+export interface HistoryEntry {
+    /** Stable id for this entry. */
+    id: string;
+    /** prompt = compose-bar message, command = slash command, backlog = auto-fed item. */
+    kind: "prompt" | "command" | "backlog";
+    /** The text sent (composer body / slash command / backlog instruction). */
+    text: string;
+    /** ms epoch when the prompt was sent. */
+    sentAt: number;
+    /** ANSI-stripped output captured between submit and turn-idle (set once idle). */
+    output?: string;
+    /** ms epoch when output capture finalized. */
+    outputAt?: number;
+}
+/**
+ * Which store a session search reads.
+ *
+ * Three, because "what did I ask for" is a different question from "what came
+ * back", and only one of the three answers it. `history` scans the prompt AND
+ * the output of every turn, so a common word matches the CLI's own reply
+ * hundreds of times and buries the handful of lines a person actually typed.
+ *
+ *   recent  = the current rendered terminal text (what is on screen now).
+ *   history = the persisted prompt + output of every recorded turn.
+ *   prompts = the persisted prompts ALONE — what was sent INTO the session
+ *             (composer message, slash command, filed backlog item), never the
+ *             CLI's output.
+ */
+export type SessionSearchScope = "recent" | "history" | "prompts";
+/** One matched line plus a couple of context lines each side, for the search sheet. */
+export interface SessionSearchMatch {
+    /** Context lines immediately above the hit (oldest first). */
+    before: string[];
+    /** The line containing the match. */
+    hit: string;
+    /** Context lines immediately below the hit. */
+    after: string[];
+    /** For a "history"/"prompts"-scope hit: the turn it came from (label + when). */
+    turn?: {
+        kind: HistoryEntry["kind"];
+        text: string;
+        sentAt: number;
+    };
+}
+/** Per-session search results: which session matched, plus its (capped) hits. */
+export interface SessionSearchResult {
+    id: string;
+    title: string;
+    /** Repo/worktree the session runs in (basename of cwd) — a grouping label. */
+    repoLabel: string;
+    cwd: string;
+    running: boolean;
+    matches: SessionSearchMatch[];
+    /** Total hits found before per-session truncation (matches.length may be smaller). */
+    total: number;
+}

package/node_modules/@waterplane/shared/dist/wire/session/archive.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=archive.js.map

package/node_modules/@waterplane/shared/dist/wire/session/archive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive.js","sourceRoot":"","sources":["../../../src/wire/session/archive.ts"],"names":[],"mappings":""}

package/node_modules/@waterplane/shared/dist/wire/session/context.d.ts

@@ -0,0 +1,298 @@
+/**
+ * One reading of how full the context window was, at an instant.
+ *
+ * `tok` is what the request carried in: prompt tokens plus everything read
+ * back out of the cache plus everything written into it. That sum is the
+ * context the model actually saw, which is the number the TUI's own meter is a
+ * percentage of — output tokens are deliberately NOT in it, since they are not
+ * context until the turn after.
+ */
+export interface ContextSample {
+    /** Epoch ms, from the log record's own timestamp. */
+    t: number;
+    tok: number;
+    /**
+     * Everything this conversation had SPENT by the time of this request —
+     * cumulative, monotonic, in tokens.
+     *
+     * `tok` is a level and this is its integral-so-far: what the window carried
+     * at that instant, against what the whole conversation had cost to get
+     * there. They are drawn as two charts and never as two lines on one, because
+     * they share a unit and nothing else — a compaction drops `tok` to a third
+     * and cannot move this at all.
+     *
+     * Counted the way `ContextSpark.usageTok` is counted (every request's input,
+     * cache reads and cache writes PLUS its output) and by the same running
+     * counter, so the last sample's `used` is `usageTok` minus the subagent
+     * share. The gap between the two is `agentTok`: the agents' own logs are
+     * dated too, and their running total over time is `ContextSeriesDoc.agentCum`,
+     * which the spend chart stacks on top of this curve.
+     *
+     * A FLOOR, like every figure derived from a log that may be truncated: a
+     * series whose oldest records fell off the cap starts part-way up, which is
+     * correct and is said next to the chart. Absent on a backend that does not
+     * record output tokens per request, and then there is no spend chart at all
+     * — never a curve of `tok` cumulated, which is a different quantity wearing
+     * the same units.
+     */
+    used?: number;
+    /**
+     * What this ONE request was made of — the four kinds, in `TOKEN_KINDS` order.
+     *
+     * The composition strip at the foot of the sheet already says 96% of
+     * everything was a cache read. That is the right headline and it cannot
+     * answer the question underneath it: WHEN did the mix change. A session that
+     * re-read a 300k window eighty times and one that wrote a fresh 300k cache
+     * eighty times print an identical strip and were two completely different
+     * afternoons. Per sample, a stacked chart can tell them apart.
+     *
+     * A TUPLE rather than a `TokenTotals`, deliberately: there are up to 1,200 of
+     * these in one document and the key names would be most of the bytes.
+     *
+     * `input + cacheRead + cacheWrite` is `tok` exactly, and `output` is the
+     * fourth — NOT in `tok`, because output is not context until the turn after.
+     * Absent on an older host, and then the chart draws the single series it
+     * always drew rather than a stack of zeros.
+     */
+    kinds?: SampleKinds;
+    /**
+     * The same four kinds, CUMULATIVE — what the conversation had spent of each
+     * by this request. `cum` sums to `used` exactly.
+     *
+     * A second tuple rather than a running sum computed on the phone, and the
+     * reason is the downsampler. `samples` is capped at 1,200 and thinned by
+     * keeping each bucket's min and max, so a client-side cumsum over what
+     * survived would leave out every dropped request and the stacked spend chart
+     * would end a long way below the total printed above it — the "two totals
+     * that nearly agree" failure this file's header calls the worst one
+     * available. A recorded running counter survives thinning; a derived one does
+     * not, which is exactly why `used` is recorded too.
+     *
+     * Absent on an older host, and then the spend chart is the single series it
+     * always was.
+     */
+    cum?: SampleKinds;
+    /**
+     * Which model ran this request — an INDEX into `ContextSeriesDoc.models`.
+     *
+     * An index rather than the id, for the reason `kinds` is a tuple: the id is
+     * ~18 characters and it would repeat on every one of 1,200 samples. Absent
+     * when the record named no model.
+     */
+    model?: number;
+}
+/**
+ * One request's four kinds, in `TOKEN_KINDS` order: input, output, cache read,
+ * cache write.
+ *
+ * The order is load-bearing — it is the palette SLOT order on every screen that
+ * paints these, so a tuple written in another order is a chart with the right
+ * numbers in the wrong colours. `sampleTotals()` is the one reader, and there
+ * must not be a second.
+ */
+export type SampleKinds = [input: number, output: number, cacheRead: number, cacheWrite: number];
+/**
+ * One subagent a session ran, as a dated event with a size and a model.
+ *
+ * `agentTok` says the Task tool spent 355M of one session's 368M and stops
+ * there. The three questions it cannot answer are the ones somebody actually
+ * has — how many, WHEN, and on what — and all three are already on disk: the
+ * CLI writes one `subagents/agent-<id>.jsonl` per agent, whose records are
+ * dated and carry `message.model`, beside a `.meta.json` naming the task type.
+ *
+ * A FLOOR like everything read off those logs: an agent log that has been
+ * cleaned up is one nothing here can list, and the count is worded accordingly.
+ */
+export interface AgentRun {
+    /** The CLI's own agent id — the file name IS the id (`agents.ts`). */
+    id: string;
+    /** Its first record: when the agent started. The x of the bar it draws. */
+    at: number;
+    /** Its last record. Equal to `at` for an agent that wrote once. For a
+     *  `running` agent this is only how far its log has got, not an end. */
+    endAt: number;
+    /** Still running when the document was read: the host's own running-agent
+     *  list (`agents.ts`, the parent's task-notifications) still holds it. Only
+     *  a LIVE session can say so; absent means not running OR nobody asked — a
+     *  closed session's agents are all over, and an older host never says. */
+    running?: true;
+    /** Which model ran it — an index into `ContextSeriesDoc.models`, the same
+     *  table the samples index. Absent when no record named one. */
+    model?: number;
+    /** `agentType` from its `.meta.json` — `Explore`, `general-purpose`, a
+     *  project's own agent. Absent when that file was missing or unreadable,
+     *  which costs a label and never the row. */
+    type?: string;
+    /** Everything that log spent: input, cache reads and writes, and output. */
+    tok: number;
+    /** At list prices, USD. Absent when its model has no published rate — never
+     *  0, which reads as free. */
+    costUsd?: number;
+    /** The most context any one of its requests carried (input + cache read +
+     *  cache write) — the agent's OWN window, which the parent's curve never
+     *  shows: one session read 31% in its window while an agent under it ran at
+     *  97%. Absent from an older host. */
+    peakTok?: number;
+    /** How many REQUESTS the agent made (its log's assistant records, deduped by
+     *  message id) — not prompts. Absent when 0 or unknown, and from an older host. */
+    turns?: number;
+    /** That window over time, `[t, tok]`, thinned to at most `AGENT_CTX_POINTS`
+     *  with every bucket's MAXIMUM kept, so the peak survives thinning. Absent
+     *  from an older host. */
+    ctx?: [t: number, tok: number][];
+    /** Every skill this agent loaded, oldest first — see `SkillLoad`. Absent
+     *  when it loaded none, and from an older host. */
+    skills?: SkillLoad[];
+}
+/**
+ * One skill body entering a context window: the CLI's `Skill` tool ran and
+ * wrote the skill's text into the log as a meta user record
+ * (`sourceToolUseID`, text opening "Base directory for this skill: …").
+ *
+ * Dated by that record, so it sits on the same time axis as every reading.
+ * `chars` is the body's length in characters — what the log holds. Tokens are
+ * NOT measured per skill (the request that carried it reports one total), so
+ * any token figure drawn from this is an estimate and must say so.
+ */
+export interface SkillLoad {
+    t: number;
+    /** The skill directory's name — what was asked for (`host`, `web-numbers`). */
+    name: string;
+    chars: number;
+}
+/** Points per agent context series on the wire. */
+export declare const AGENT_CTX_POINTS = 60;
+/** Points in `ContextSeriesDoc.agentCum` on the wire. */
+export declare const AGENT_CUM_POINTS = 120;
+/**
+ * Something that happened TO the window, as opposed to a reading of it.
+ *
+ * Both kinds are dated by the CLI itself, which is the whole reason this is
+ * read off the conversation log rather than accumulated from the screen: a
+ * scraped meter carries no clock, so a series built from it could never say
+ * WHEN the drop happened, and a drop with no time on it is not a graph.
+ */
+export interface ContextEvent {
+    t: number;
+    kind: 
+    /** The conversation was summarised and the window reset. */
+    "compact"
+    /** The account refused the request — the usage wall. */
+     | "limit"
+    /**
+     * The conversation came back to an expired cache and re-WROTE its window
+     * instead of re-reading it — see `isColdRebuild`.
+     *
+     * An event rather than a flag on the sample, because the samples are
+     * DOWNSAMPLED for the spark and a flag would survive or not depending on
+     * which bucket the request landed in. This is also the one thing on the
+     * graph that is invisible in the curve: the window does not move, so
+     * nothing about the shape says the turn cost twenty times the one before.
+     */
+     | "rebuild";
+    /** compact: whether the CLI did it on its own or the user typed `/compact`. */
+    trigger?: "auto" | "manual";
+    /** compact: the window immediately before and after. */
+    preTok?: number;
+    postTok?: number;
+    /** rebuild: what it wrote, what it had been carrying, and how long the
+     *  conversation had been quiet when it came back. */
+    wroteTok?: number;
+    prevTok?: number;
+    gapMs?: number;
+    /** limit: the instant the account said it would serve again, when it said. */
+    resetAt?: number;
+    /** limit: anything other than the five-hour session window. */
+    weekly?: boolean;
+}
+/**
+ * What the compactions in one conversation shed, saved and cost.
+ *
+ * One row per trigger — see `CompactionLedger`. Every figure is a FLOOR, and
+ * each is a floor for its own reason, which is why they are not summed here
+ * into a single "net": see the fields.
+ */
+export interface CompactionCost {
+    /** How many compactions this row folds. */
+    count: number;
+    /**
+     * `Σ preTok − postTok`: what the window would still be carrying had none of
+     * them run.
+     *
+     * Exact, and the one figure here that is not a counterfactual — the CLI
+     * writes both numbers down at the boundary. It chains correctly across
+     * several compactions: after two, the uncompacted window is the real one
+     * plus both sheds, because each drop is measured against what the previous
+     * one left behind.
+     */
+    shedTok: number;
+    /**
+     * Tokens no later request had to re-send, because these compactions ran.
+     *
+     * Accumulated per REQUEST, not per compaction: every request after a
+     * boundary carried `shedTok` fewer tokens than the same request in a
+     * conversation that never compacted, so this is that difference summed over
+     * every request since. It is what makes the saving grow the longer you keep
+     * working — a compaction with no turn after it has saved nothing yet, and
+     * says so rather than printing a zero.
+     */
+    savedTok: number;
+    /**
+     * `savedTok` at list prices, USD — priced as CACHE READS on the model that
+     * actually ran each request, on the day it ran.
+     *
+     * Cache reads because that is the cheapest thing those tokens could have
+     * been, which makes this a floor in the one direction that matters: a
+     * conversation resumed after the cache expired re-WRITES its prefix, at
+     * 12.5× to 20× the read rate, and pricing every shed token at the write tier
+     * would let this figure flatter the feature it is reporting on.
+     *
+     * Absent when no request could be priced, and absent when nothing has been
+     * saved yet — never 0, which reads as "compacting was pointless".
+     */
+    savedUsd?: number;
+    /**
+     * What the first request after each of these boundaries wrote into the cache
+     * — the window being built again from nothing.
+     *
+     * The measured cost of compacting, and an OVERSTATEMENT on purpose: some of
+     * that write is the turn's own growth, which an uncompacted conversation
+     * would have paid too. Erring high here and low on `savedUsd` is the same
+     * decision twice — neither number may make compaction look better than it is.
+     *
+     * These tokens are real and are already inside the session's own
+     * `usageTok`/`cost`. `savedTok` is the opposite: money never spent, in no
+     * total anywhere. Any surface printing both says which is which.
+     */
+    rebuildTok: number;
+    /** `rebuildTok` at list prices, on the model and day of that request.
+     *  Absent rather than 0, for `savedUsd`'s reason. */
+    rebuildUsd?: number;
+}
+/**
+ * The compaction ledger for one conversation, split by who asked for it.
+ *
+ * Split because they are two different decisions: an auto-compaction is the
+ * CLI hitting the wall, a manual one is somebody typing `/compact`, and "was
+ * it worth doing by hand" is only answerable if the two are counted apart.
+ * Both rows are always present — a zeroed row is the claim that none of that
+ * kind ran, which is a fact, unlike an absent ledger.
+ *
+ * **The summarisation request itself is not in these figures.** The CLI does
+ * not write it to the conversation log — measured: no assistant record carries
+ * its usage, between the boundary and the next prompt there is nothing — so
+ * the one part of the cost nothing here can see is the model reading the whole
+ * window in order to summarise it. Every surface that prints `rebuildUsd`
+ * says so; that is also why the two sides are never subtracted into a net
+ * here, where the wording cannot follow.
+ */
+export interface CompactionLedger {
+    auto: CompactionCost;
+    manual: CompactionCost;
+    /**
+     * Compactions whose `preTokens`/`postTokens` the log did not record, and so
+     * are in NONE of the figures above — counted rather than silently dropped,
+     * exactly as `unpricedTok` counts what no rate covered.
+     */
+    unmeasured: number;
+}

package/node_modules/@waterplane/shared/dist/wire/session/context.js

@@ -0,0 +1,6 @@
+// ── Context-window history ────────────────────────────────────────────────
+/** Points per agent context series on the wire. */
+export const AGENT_CTX_POINTS = 60;
+/** Points in `ContextSeriesDoc.agentCum` on the wire. */
+export const AGENT_CUM_POINTS = 120;
+//# sourceMappingURL=context.js.map

package/node_modules/@waterplane/shared/dist/wire/session/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/wire/session/context.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAwK7E,mDAAmD;AACnD,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC,yDAAyD;AACzD,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC"}