waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/sessioncost/costreading.d.ts

@@ -0,0 +1,174 @@
+import { type SessionCostInput, type SessionCostReading } from "./costtypes.js";
+/**
+ * How many more turns of new work before a fresh session would have been
+ * cheaper, at the measured cache multipliers.
+ *
+ * Continuing costs `n · tok · R` — every turn re-reads the whole conversation
+ * out of the cache. A fresh session pays `base · W` to write its baseline once
+ * and `base · R` for each turn after. Setting the two equal:
+ *
+ *   n · tok · R  =  base · W + (n - 1) · base · R
+ *   n            =  base · (W - R) / (R · (tok - base))
+ *
+ * The multipliers do not cancel — the write premium is the whole reason a short
+ * errand belongs in the session that is already warm. New work only: turns that
+ * would have to re-read the same files in the new session are not free there,
+ * which is why this is an answer about work that does not depend on what is
+ * already in the window.
+ *
+ * **`W` is the 1-HOUR write tier, because that is the tier the fresh session
+ * would actually write its baseline at.** Measured across all 13,397
+ * conversation logs on this desktop: 8,160 of 8,160 main-conversation cache
+ * writes were 1-hour (2×), across every CLI version from 2.1.220 to 2.1.267,
+ * every entry point and every model; the 5-minute tier appears only in the 571
+ * subagent logs, which is a harness policy per request kind and not a fact
+ * about this machine. This read `CACHE_WRITE_5M_MULT` until that was measured,
+ * which understated every break-even by about 65% — the one number in this
+ * module that was quietly wrong rather than absent. `writeMult` is overridable
+ * for a caller that has measured a different tier for its own session.
+ *
+ * **`R` is the flat 0.1× read rule, not the model's own.** Fable 5.1 publishes
+ * a 0.025× cache read (`pricing.ts`), which would make its break-even four
+ * times further away; nothing here knows which model ran, and inventing one
+ * would be worse than a stated limit. On this desktop every main conversation
+ * ran on a model that takes the flat rule.
+ */
+export declare function breakEvenTurns(tok: number, baseTok: number | null, writeMult?: number): number | null;
+/**
+ * The whole reading, sentences included.
+ *
+ * Every screen that mentions this — the launcher row, the session header, the
+ * context sheet, the one toast — renders what this returns. None of them writes
+ * its own wording, for the reason `clihealth.ts` states about verdicts: one
+ * fact worded two ways reads as two facts.
+ */
+/**
+ * The advice that matters when the AGENTS are the bill. Both doors on the cost
+ * panel (`/compact`, a fresh session) lower what the parent's next turn costs;
+ * neither touches an agent, which re-reads its OWN window on every step. On a
+ * fan-out session that is most of the money — measured: 786M of 817M on one
+ * session whose panel offered only `/compact` — so the panel says where the
+ * lever is. Null below half: then the parent's window is the bigger half and
+ * the sentences above it are the right ones.
+ */
+export declare function agentAdvice(usageTok: number | null, agentTok: number | null): string | null;
+/**
+ * A subagent's CURRENT window from which the phone says something while it
+ * runs. Measured: one agent ran 819 requests averaging 484k and peaked at 967k
+ * of a 1M window — about a quarter of a week's usage in one agent — and nothing
+ * said so until it had finished. Half a 1M window is where a run like that is
+ * already dear on every step; the ordinary agents on this desktop sit far below.
+ */
+export declare const AGENT_LARGE_TOK = 500000;
+/**
+ * How recent an agent's last record must be for it to count as RUNNING
+ * (`ContextSpark.liveAgentTok`). An agent writes one record per request, and a
+ * request on a huge window with a long tool call between can take minutes, so
+ * a tight gap would flicker a working agent off and on; ten minutes is longer
+ * than any step seen here and short enough that a finished agent stops being
+ * called live the same quarter-hour. Asked TWICE on purpose: by the host when
+ * it builds the spark, and by the phone against its own clock at render,
+ * because the spark is only rebuilt when a log moves — a finished agent's
+ * spark would otherwise say "running" for ever.
+ */
+export declare const AGENT_LIVE_MS: number;
+/**
+ * The one sentence about a large RUNNING subagent, or null.
+ *
+ * Null below `AGENT_LARGE_TOK`, for an absent reading, and — when `lastAt` is
+ * given — once the agent's last record is older than `AGENT_LIVE_MS` by the
+ * caller's clock. A readout: it names the lever and refuses nothing.
+ */
+export declare function liveAgentText(liveAgentTok: number | null | undefined, lastAt?: number | null, now?: number, 
+/** The person's own line (`agentWindowWarnSetting`); absent is `AGENT_LARGE_TOK`. */
+threshold?: number): string | null;
+/**
+ * The push when a RUNNING subagent's window passes the person's line: what it
+ * is reading, what that costs per step, and where the lever is. Words only —
+ * nothing is stopped; the phone's context sheet is where a person interrupts.
+ */
+export declare function agentPushText(a: {
+    tok: number;
+    type?: string | null;
+    title?: string | null;
+}): {
+    title: string;
+    body: string;
+};
+/**
+ * The prompt the phone queues after an Esc on a large subagent: it asks the
+ * main agent to stop that agent and re-spawn the rest narrower. Queued by the
+ * person's tap on the context sheet — never sent by the host on its own.
+ */
+export declare function replanPromptText(tok: number, type?: string | null): string;
+export declare function sessionCost(input: SessionCostInput): SessionCostReading;
+/**
+ * The two ways out of an expensive window, worded once.
+ *
+ * ── Why this is a sentence and not a button label ──────────────────────────
+ *
+ * `advice` above argues that new work would be cheaper somewhere else, and the
+ * context sheet puts two doors under it: `/compact`, which keeps this
+ * conversation and re-reads a summary of it, and a fresh session, which keeps
+ * nothing. Those are not the same offer, and an argument that names one door
+ * while the other is drawn beside it teaches a reader that the buttons and the
+ * prose are about different things.
+ *
+ * ── Why the caller decides `canCompact` ────────────────────────────────────
+ *
+ * `/compact` is Claude's vocabulary. A backend whose descriptor says
+ * `slash: "none"` reads it as English and is asked, in prose, to compact
+ * itself — the bug `headerCmds.ts` exists for. The capability is the caller's
+ * fact, not this module's, so the clause is simply ABSENT where the door is:
+ * null, never a sentence promising a control that is not on the screen.
+ */
+export declare function costDoorsText(canCompact: boolean): string | null;
+/**
+ * The three cost fields, derived from a full readings series.
+ *
+ * The ONE derivation, used by the host filling a `ContextSpark` and by the
+ * context sheet reading the whole document — two places that hold the same
+ * series at different resolutions and would otherwise each decide for
+ * themselves what a baseline is. They already disagree once by construction
+ * (the spark's `pts` is downsampled), which is precisely why the answer is
+ * computed here from the raw readings and carried, never re-derived downstream.
+ *
+ * `truncated` withholds the baseline rather than quoting the oldest reading
+ * that survived the cap: that reading is not a fresh session, it is the middle
+ * of a long one, and using it would make the longest conversations — the only
+ * ones that truncate — look the cheapest.
+ */
+export declare function seriesCostFields(samples: {
+    tok: number;
+}[], truncated: boolean, turns: number | null): {
+    baseTok?: number;
+    turns?: number;
+    spentTok: number;
+};
+/**
+ * The reading for a whole series document — the context sheet's own panel.
+ *
+ * `used` is what the HOST measured (the doc's `usageTok`/`agentTok`): the
+ * output side and the subagent logs are not in `samples` and cannot be derived
+ * from them, so they are carried or they are absent.
+ */
+export declare function sessionCostOfSeries(samples: {
+    tok: number;
+}[], truncated: boolean, turns: number | null, used?: {
+    usageTok?: number;
+    agentTok?: number;
+} | null, live?: CacheAge | null): SessionCostReading | null;
+/**
+ * What a caller knows about how long this conversation has been quiet.
+ *
+ * `lastTurnAt` is the CLI's own record of its newest turn (`SessionInfo`
+ * already carries it — nothing new is put on the wire for this), `now` is the
+ * clock of whatever is about to draw the sentence, and `turnActive` suppresses
+ * the whole question while a turn is running.
+ */
+export interface CacheAge {
+    lastTurnAt?: number | null;
+    turnActive?: boolean | null;
+    now: number;
+}
+export declare function coldFrom(live?: CacheAge | null): boolean | null;

package/node_modules/@waterplane/shared/dist/sessioncost/costreading.js

@@ -0,0 +1,302 @@
+// Cut from sessioncost.ts (move only): break-even and the one reading
+// The one door stays `./sessioncost.js`; this slice imports its siblings directly, never the barrel.
+import { CACHE_READ_MULT, CACHE_WRITE_1H_MULT } from "../pricing.js";
+import { MULT_WARM, MULT_HEAVY, MULT_STEEP, MIN_TURNS, cacheLikelyCold } from "./costtypes.js";
+import { fmtMultiple, fmtTok, usageText } from "./costwords.js";
+/**
+ * How many more turns of new work before a fresh session would have been
+ * cheaper, at the measured cache multipliers.
+ *
+ * Continuing costs `n · tok · R` — every turn re-reads the whole conversation
+ * out of the cache. A fresh session pays `base · W` to write its baseline once
+ * and `base · R` for each turn after. Setting the two equal:
+ *
+ *   n · tok · R  =  base · W + (n - 1) · base · R
+ *   n            =  base · (W - R) / (R · (tok - base))
+ *
+ * The multipliers do not cancel — the write premium is the whole reason a short
+ * errand belongs in the session that is already warm. New work only: turns that
+ * would have to re-read the same files in the new session are not free there,
+ * which is why this is an answer about work that does not depend on what is
+ * already in the window.
+ *
+ * **`W` is the 1-HOUR write tier, because that is the tier the fresh session
+ * would actually write its baseline at.** Measured across all 13,397
+ * conversation logs on this desktop: 8,160 of 8,160 main-conversation cache
+ * writes were 1-hour (2×), across every CLI version from 2.1.220 to 2.1.267,
+ * every entry point and every model; the 5-minute tier appears only in the 571
+ * subagent logs, which is a harness policy per request kind and not a fact
+ * about this machine. This read `CACHE_WRITE_5M_MULT` until that was measured,
+ * which understated every break-even by about 65% — the one number in this
+ * module that was quietly wrong rather than absent. `writeMult` is overridable
+ * for a caller that has measured a different tier for its own session.
+ *
+ * **`R` is the flat 0.1× read rule, not the model's own.** Fable 5.1 publishes
+ * a 0.025× cache read (`pricing.ts`), which would make its break-even four
+ * times further away; nothing here knows which model ran, and inventing one
+ * would be worse than a stated limit. On this desktop every main conversation
+ * ran on a model that takes the flat rule.
+ */
+export function breakEvenTurns(tok, baseTok, writeMult = CACHE_WRITE_1H_MULT) {
+    if (baseTok == null || baseTok <= 0)
+        return null;
+    const gap = tok - baseTok;
+    if (gap <= 0)
+        return null;
+    const n = (baseTok * (writeMult - CACHE_READ_MULT)) / (CACHE_READ_MULT * gap);
+    if (!Number.isFinite(n))
+        return null;
+    // A break-even beyond a couple of dozen turns is not a reminder, it is noise:
+    // at that distance the session is barely above its own baseline.
+    const rounded = Math.max(1, Math.ceil(n));
+    return rounded > 24 ? null : rounded;
+}
+function levelOf(multiple, turns) {
+    if (multiple == null)
+        return "fresh";
+    if (turns != null && turns < MIN_TURNS)
+        return "fresh";
+    if (multiple >= MULT_STEEP)
+        return "steep";
+    if (multiple >= MULT_HEAVY)
+        return "heavy";
+    if (multiple >= MULT_WARM)
+        return "warm";
+    return "fresh";
+}
+/**
+ * The whole reading, sentences included.
+ *
+ * Every screen that mentions this — the launcher row, the session header, the
+ * context sheet, the one toast — renders what this returns. None of them writes
+ * its own wording, for the reason `clihealth.ts` states about verdicts: one
+ * fact worded two ways reads as two facts.
+ */
+/**
+ * The advice that matters when the AGENTS are the bill. Both doors on the cost
+ * panel (`/compact`, a fresh session) lower what the parent's next turn costs;
+ * neither touches an agent, which re-reads its OWN window on every step. On a
+ * fan-out session that is most of the money — measured: 786M of 817M on one
+ * session whose panel offered only `/compact` — so the panel says where the
+ * lever is. Null below half: then the parent's window is the bigger half and
+ * the sentences above it are the right ones.
+ */
+export function agentAdvice(usageTok, agentTok) {
+    if (usageTok == null || agentTok == null || usageTok <= 0 || agentTok * 2 <= usageTok)
+        return null;
+    return `Most of what this session spent — ${fmtTok(agentTok)} of ${fmtTok(usageTok)} — was its subagents, and compacting or a new session lowers only what the next turn here costs. Each agent re-reads its own growing window on every step, so agents with a narrower task that finish sooner are what brings that down.`;
+}
+/**
+ * A subagent's CURRENT window from which the phone says something while it
+ * runs. Measured: one agent ran 819 requests averaging 484k and peaked at 967k
+ * of a 1M window — about a quarter of a week's usage in one agent — and nothing
+ * said so until it had finished. Half a 1M window is where a run like that is
+ * already dear on every step; the ordinary agents on this desktop sit far below.
+ */
+export const AGENT_LARGE_TOK = 500_000;
+/**
+ * How recent an agent's last record must be for it to count as RUNNING
+ * (`ContextSpark.liveAgentTok`). An agent writes one record per request, and a
+ * request on a huge window with a long tool call between can take minutes, so
+ * a tight gap would flicker a working agent off and on; ten minutes is longer
+ * than any step seen here and short enough that a finished agent stops being
+ * called live the same quarter-hour. Asked TWICE on purpose: by the host when
+ * it builds the spark, and by the phone against its own clock at render,
+ * because the spark is only rebuilt when a log moves — a finished agent's
+ * spark would otherwise say "running" for ever.
+ */
+export const AGENT_LIVE_MS = 10 * 60_000;
+/**
+ * The one sentence about a large RUNNING subagent, or null.
+ *
+ * Null below `AGENT_LARGE_TOK`, for an absent reading, and — when `lastAt` is
+ * given — once the agent's last record is older than `AGENT_LIVE_MS` by the
+ * caller's clock. A readout: it names the lever and refuses nothing.
+ */
+export function liveAgentText(liveAgentTok, lastAt, now, 
+/** The person's own line (`agentWindowWarnSetting`); absent is `AGENT_LARGE_TOK`. */
+threshold = AGENT_LARGE_TOK) {
+    if (liveAgentTok == null || !(liveAgentTok >= threshold))
+        return null;
+    if (lastAt != null && now != null && now - lastAt > AGENT_LIVE_MS)
+        return null;
+    return `A subagent is re-reading ${fmtTok(liveAgentTok)} on every step — agents with a narrower task that finish sooner cost less.`;
+}
+/**
+ * The push when a RUNNING subagent's window passes the person's line: what it
+ * is reading, what that costs per step, and where the lever is. Words only —
+ * nothing is stopped; the phone's context sheet is where a person interrupts.
+ */
+export function agentPushText(a) {
+    const who = a.type ? `a ${a.type} agent` : "an agent";
+    const head = a.title ? `${a.title}: ` : "";
+    return {
+        title: `${head}${who} passed ${fmtTok(a.tok)}`,
+        body: `It re-reads ${fmtTok(a.tok)} of context on every step. Open the context sheet to interrupt and re-plan.`,
+    };
+}
+/**
+ * The prompt the phone queues after an Esc on a large subagent: it asks the
+ * main agent to stop that agent and re-spawn the rest narrower. Queued by the
+ * person's tap on the context sheet — never sent by the host on its own.
+ */
+export function replanPromptText(tok, type) {
+    const what = type ? ` (${type})` : "";
+    return `A subagent${what} was re-reading ${fmtTok(tok)} of context on every step. If it is still running, stop it with TaskStop, keep what it already returned, and re-spawn the rest as narrower tasks: one work package per agent, model set explicitly, each briefed to return before about 200k of context. If it already finished, apply that to the next agents you spawn.`;
+}
+export function sessionCost(input) {
+    const { tok, baseTok, turns, spentTok } = input;
+    const cacheCold = input.cacheCold ?? null;
+    // Normalised, not trusted: an older caller (and every JS one) passes neither
+    // field, and `undefined` on the way out would read as "measured nothing" to
+    // anything asking `usageTok != null`.
+    const usageTok = input.usageTok ?? null;
+    const agentTok = input.agentTok ?? null;
+    const multiple = baseTok != null && baseTok > 0 && tok > 0 ? tok / baseTok : null;
+    const level = levelOf(multiple, turns);
+    const breakEven = level === "fresh" ? null : breakEvenTurns(tok, baseTok);
+    // The total wins over the carried volume where it exists: it is the same
+    // fact with the two things missing from it put back (what the turns wrote,
+    // and what the agents spent), so printing both would be one number twice.
+    const spentNote = usageTok != null && usageTok > 0
+        ? ` ${usageText(usageTok, agentTok)}`
+        : spentTok != null && spentTok > 0
+            ? ` This conversation has carried ${fmtTok(spentTok)} tokens in total.`
+            : "";
+    // ── What a COLD cache changes ─────────────────────────────────────────
+    //
+    // Not the multiple: `tok / baseTok` is the ratio of what the two sessions
+    // carry, and a cold resume re-writes both of them at the same tier, so it
+    // cancels. What it changes is the price of the FIRST turn — those tokens are
+    // written at 1.25-2× input instead of read at 0.1× — and that is the one
+    // sentence in this module that becomes false when it happens: "a quick
+    // question is still cheaper here" is advice that was true of a warm window
+    // and is wrong by an order of magnitude on a window nobody has touched for
+    // hours. So the correction goes exactly there.
+    //
+    // No dollar figure and no minutes. A figure needs the model and a rate this
+    // function has never been given, and the share of a cold resume still served
+    // from cache varies from 3% to 30% (the tools-and-system preamble stays warm
+    // from sibling sessions in the same repo, measured at 5-23k), so any amount
+    // printed here would be a plausible wrong number rather than an absent one.
+    const coldNote = cacheCold
+        ? ` Nothing has run here for hours: the cached prefix has very likely expired, so the next turn re-WRITES these ${fmtTok(tok)} rather than re-reading them, which is the expensive direction by an order of magnitude.`
+        : "";
+    // The clause a cold window makes false, and its replacement.
+    const quick = cacheCold
+        ? " Even a quick question pays that re-write first, so there is no cheap turn left here."
+        : " A quick question is still cheaper here.";
+    if (level === "fresh") {
+        const note = baseTok == null
+            ? `Each turn re-reads ${fmtTok(tok)} of context. How that compares with a fresh session here is not known — this conversation's log is longer than the host reads in one go, so there is no first reading to measure against.`
+            : `Each turn re-reads ${fmtTok(tok)} of context — about what a fresh session in this repo costs.${spentNote}`;
+        // A cold window is only worth a sentence where re-writing it is worth
+        // money. At `fresh` WITH a baseline this session carries about what a new
+        // one would, so the re-write is the price of starting anywhere and saying
+        // so would be noise on every idle session on the list. The no-baseline
+        // branch is the opposite case — the log is truncated, which only happens
+        // to the longest conversations — so it keeps the warning.
+        const coldOnly = baseTok == null ? coldNote : "";
+        return {
+            level, tok, baseTok, multiple, breakEven, spentTok, usageTok, agentTok, turns,
+            chip: null,
+            note: note + coldOnly,
+            advice: joinAdvice(coldOnly ? "New work belongs in a fresh session; this window has to be paid for again before it can answer anything." : null, agentAdvice(usageTok, agentTok)),
+        };
+    }
+    const mult = fmtMultiple(multiple);
+    const note = `Each turn re-reads ${fmtTok(tok)} of context — ${mult} what a fresh session in this repo costs (${fmtTok(baseTok)}).${spentNote}${coldNote}`;
+    const advice = breakEven != null
+        ? `More than ${breakEven} ${breakEven === 1 ? "turn" : "turns"} of work that does not need what is already in this window would be cheaper in a new session.${quick}`
+        : level === "steep"
+            ? `New work that does not need what is already in this window would be markedly cheaper in a new session.${quick}`
+            : cacheCold
+                ? `New work that does not need what is already in this window would be cheaper in a new session.${quick}`
+                : null;
+    return { level, tok, baseTok, multiple, breakEven, spentTok, usageTok, agentTok, turns, chip: mult, note, advice: joinAdvice(advice, agentAdvice(usageTok, agentTok)) };
+}
+function joinAdvice(a, b) {
+    return a && b ? `${a} ${b}` : a ?? b;
+}
+/**
+ * The two ways out of an expensive window, worded once.
+ *
+ * ── Why this is a sentence and not a button label ──────────────────────────
+ *
+ * `advice` above argues that new work would be cheaper somewhere else, and the
+ * context sheet puts two doors under it: `/compact`, which keeps this
+ * conversation and re-reads a summary of it, and a fresh session, which keeps
+ * nothing. Those are not the same offer, and an argument that names one door
+ * while the other is drawn beside it teaches a reader that the buttons and the
+ * prose are about different things.
+ *
+ * ── Why the caller decides `canCompact` ────────────────────────────────────
+ *
+ * `/compact` is Claude's vocabulary. A backend whose descriptor says
+ * `slash: "none"` reads it as English and is asked, in prose, to compact
+ * itself — the bug `headerCmds.ts` exists for. The capability is the caller's
+ * fact, not this module's, so the clause is simply ABSENT where the door is:
+ * null, never a sentence promising a control that is not on the screen.
+ */
+export function costDoorsText(canCompact) {
+    if (!canCompact)
+        return null;
+    return "Compacting is the other door: it keeps this conversation and re-reads a summary of it instead of all of it, so work that still needs what is here stays here. A new session keeps nothing.";
+}
+/**
+ * The three cost fields, derived from a full readings series.
+ *
+ * The ONE derivation, used by the host filling a `ContextSpark` and by the
+ * context sheet reading the whole document — two places that hold the same
+ * series at different resolutions and would otherwise each decide for
+ * themselves what a baseline is. They already disagree once by construction
+ * (the spark's `pts` is downsampled), which is precisely why the answer is
+ * computed here from the raw readings and carried, never re-derived downstream.
+ *
+ * `truncated` withholds the baseline rather than quoting the oldest reading
+ * that survived the cap: that reading is not a fresh session, it is the middle
+ * of a long one, and using it would make the longest conversations — the only
+ * ones that truncate — look the cheapest.
+ */
+export function seriesCostFields(samples, truncated, turns) {
+    return {
+        baseTok: truncated ? undefined : samples[0]?.tok,
+        // NOT `samples.length`. A reading is one REQUEST — a turn that ran thirteen
+        // tools wrote fourteen of them — so counting the series was counting the
+        // CLI's round trips and calling them turns: a four-turn conversation read
+        // as twenty-four. It is counted off the user records instead (host
+        // `ctxlog.ts`, one rule with the reader's own `promptOf`), and is absent
+        // when nothing counted it rather than falling back to a number that means
+        // something else.
+        ...(turns == null ? null : { turns }),
+        spentTok: samples.reduce((n, p) => n + p.tok, 0),
+    };
+}
+/**
+ * The reading for a whole series document — the context sheet's own panel.
+ *
+ * `used` is what the HOST measured (the doc's `usageTok`/`agentTok`): the
+ * output side and the subagent logs are not in `samples` and cannot be derived
+ * from them, so they are carried or they are absent.
+ */
+export function sessionCostOfSeries(samples, truncated, turns, used, live) {
+    if (!samples.length)
+        return null;
+    const tok = samples[samples.length - 1].tok;
+    if (!(tok > 0))
+        return null;
+    const f = seriesCostFields(samples, truncated, turns);
+    return sessionCost({
+        tok,
+        baseTok: f.baseTok ?? null,
+        turns: f.turns ?? null,
+        spentTok: f.spentTok,
+        usageTok: used?.usageTok ?? null,
+        agentTok: used?.agentTok ?? null,
+        cacheCold: coldFrom(live),
+    });
+}
+export function coldFrom(live) {
+    return live ? cacheLikelyCold(live.lastTurnAt, live.now, live.turnActive) : null;
+}
+//# sourceMappingURL=costreading.js.map

package/node_modules/@waterplane/shared/dist/sessioncost/costreading.js.map

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