waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/backendsources.d.ts

@@ -0,0 +1,399 @@
+/**
+ * The sources seam — what a backend may hand over BESIDE its screen readers.
+ * Pure types (`docs/analysis/backends-design.md` §1.1); no behaviour lives here.
+ *
+ * The ladder per fact is source → screen reader → absent. A source is a reader:
+ * the descriptor's `facts` (`plugin.ts`, 2.0) list the providers per fact in
+ * order — `{source:true}` means "ask the slot here" — and a source that cannot
+ * answer returns `null`/absent so the next provider is asked. **Nothing a source reports becomes a number it did not
+ * state.** The types live in `shared` so an in-repo extension and an external
+ * plugin can implement them under the `extension-boundary` lint.
+ */
+import type { DetectedPrompt, PermissionMode } from "./wire/session.js";
+import type { TranscriptDoc } from "./wire/transcript.js";
+import type { BackendTokensDoc } from "./wire/backendtokens.js";
+import type { UsageSourceId, UsageWindow } from "./wire/telemetry.js";
+/** One live PTY session as a source sees it — never the Session record. */
+export interface SourceSession {
+    readonly id: string;
+    readonly cwd: string;
+    readonly backendSessionId?: string;
+    readonly spawnedAt: number;
+}
+/**
+ * What an edge may say beyond itself — each field only when the CLI stated it.
+ * claude's hooks are the one source that fills these today (design §10).
+ */
+export interface TurnFacts {
+    /** The words the CLI says it accepted with this turn (claude: `UserPromptSubmit.prompt`). Recorded so a delivery can claim them. */
+    readonly prompt?: string;
+    /** Re-read the session's model off its log at this edge (claude: `SessionStart`, `Stop` — a mid-turn `/model`). `logPath` = where the CLI says the log is. */
+    readonly reread?: {
+        readonly logPath?: string;
+    };
+}
+/** Exact turn boundaries. Replaces silence for the backend that supplies it. */
+export interface TurnSource {
+    /** Subscribe for one session; returns the unsubscribe. `ready` = at its prompt, no turn. */
+    watch(s: SourceSession, on: {
+        started(at: number, facts?: TurnFacts): void;
+        ended(at: number, facts?: TurnFacts): void;
+        ready(facts?: TurnFacts): void;
+        /** The CLI named its own conversation id after attach (claude: `SessionStart.session_id`). */
+        identified?(backendSessionId: string): void;
+    }): () => void;
+    /**
+     * `ended` is the CLI ASKING to end the turn, and the CLI also works without announcing a turn
+     * (claude: a `Stop` a hook may refuse; `/compact`). The host then holds each `ended` against the
+     * screen's working line before believing it, owes the end whether or not a turn was believed,
+     * and keeps its screen turn watch armed while the channel is up. Only for a TUI that
+     * working-line reader was written for. Absent ⇒ `ended` is believed outright.
+     */
+    readonly verifyEnds?: boolean;
+}
+/** A dialog as the CLI itself posed it. `DetectedPrompt` is the WIRE shape; this is the source's. */
+export interface SourceDialog {
+    readonly id: string;
+    readonly kind: DetectedPrompt["kind"];
+    readonly question: string;
+    /** `takesText` (2.0): this row takes a typed reason ("No, and tell the agent why"). */
+    readonly options: {
+        index: number;
+        label: string;
+        desc?: string;
+        remember?: SourceRemember;
+        takesText?: boolean;
+    }[];
+    /**
+     * Answer by the CLI's own channel. `{ok:false, reason}` when it cannot (expired, channel down).
+     *
+     * `{ keys }` = "this dialog is now in my TUI and is answered by these keystrokes": the
+     * source does not type them — it has no keystroke API, and gets none. The host's one
+     * answer dispatcher (`sessions/boxes.ts`'s `answerBox`) types them into THIS session
+     * through the same raw-input path a phone's digit tap uses, once, and only as the result
+     * of that call. Bounded (`SourceKeys`); anything else is refused in words, nothing typed.
+     *
+     * `{ keys, typed, then? }` (2.1, `HostPluginApi.supports.dialogKeysThenTyped`) = "this row's
+     * keys open a reason field; type the person's reason into it": only for a `takesText` row
+     * answered with `extra.text`, and `typed` must BE that text. The host types the keys, waits
+     * `TYPED_AFTER_KEYS_MS` (500 ms) for the field, then the words and, as a separate write, the
+     * Return — each half bounded as `SourceKeys` / `SourceTyped`. Any other `typed` from a dialog
+     * is refused in words, nothing typed.
+     */
+    answer(choice: number, extra?: {
+        text?: string;
+    }): Promise<{
+        ok: boolean;
+        reason?: string;
+    } | SourceKeys | (SourceKeys & SourceTyped)>;
+}
+/**
+ * An option that, when a PERSON's tap chooses it, makes the HOST keep a standing rule for this
+ * session (`answergate.ts`): "don't ask again" for exactly `key`. The source never creates the
+ * rule; it may later ask `HostPluginApi.ruleAllows(sessionId, key, why)`, which the gate answers
+ * and audits. `label` is what the person approved, in words (shown in the decision log). Never
+ * on the wire.
+ */
+export interface SourceRemember {
+    key: string;
+    label: string;
+}
+/**
+ * The keystrokes a `SourceDialog.answer` (or `ModeSource.set`, 2.2) may hand back for the host
+ * to type. `keys` is at most `SOURCE_KEYS_MAX` (8) KEYS, each a printable character (no control
+ * characters, no DEL) or one of the control keys a box walk or a mode cycle already presses:
+ * Return `"\r"`, Escape `"\x1b"`, the arrows `"\x1b[A"`…`"\x1b[D"`, and (2.2) Tab `"\t"` and
+ * Shift+Tab `"\x1b[Z"` — each of those counts as ONE key. E.g. Copilot past its hook hold:
+ * `{keys:"1"}` (the digit, NO Return). Only ever the result of the source's own answer; never a
+ * paste, never a prompt: words go through `deliver.ts`.
+ */
+export interface SourceKeys {
+    keys: string;
+}
+export declare const SOURCE_KEYS_MAX = 8;
+export interface DialogSource {
+    watch(s: SourceSession, on: {
+        asked(d: SourceDialog): void;
+        resolved(id: string): void;
+        /**
+         * How many dialogs the CLI has open that this source can SEE but cannot pose — a kind
+         * it does not map, because nobody measured how it is answered (opencode's `question`
+         * tool). While this is above 0 the host's screen reader keeps its duty for them;
+         * absent / never called = 0. Reported on every change, and once on `watch` when above 0.
+         */
+        unposed?(count: number): void;
+    }): () => void;
+    /** Reconcile after a gap: what is pending NOW. Null = cannot say (channel down). */
+    pending(s: SourceSession): Promise<SourceDialog[] | null>;
+}
+/** Proof that typed words became a user turn. */
+export interface DeliverySource {
+    /** Resolve true when a user message whose text equals `text` lands after `sinceMs`; false at timeout. */
+    landed(s: SourceSession, text: string, sinceMs: number, timeoutMs: number): Promise<boolean>;
+    /** Every user message since `sinceMs`; null = cannot say. */
+    userTurns(s: SourceSession, sinceMs: number): Promise<{
+        id: string;
+        text: string;
+        at: number;
+    }[] | null>;
+}
+/** The conversation as a reader document. */
+export interface TranscriptSource {
+    /** The CLI's own change stamp; drives the 204 poll. Null = unknown (read anyway). */
+    updatedAt(s: SourceSession): number | null;
+    read(s: SourceSession, detail: "lite" | "full"): Omit<TranscriptDoc, "sessionId" | "source"> | null;
+}
+/** Named `Source…` because wire/session.ts already exports a `ContextSample`. */
+export interface SourceContextSample {
+    /**
+     * When the CLI's count was TAKEN (the reading's own time), never when it was asked: the host
+     * keeps a new graph point per newer `at`, so a plugin stamping `Date.now()` on each call would
+     * cost a disk write per poll. A sample equal in figures to the last one is not a new point.
+     */
+    at: number;
+    usedTok: number;
+    model?: string;
+    /**
+     * (2.2) The window, in tokens, the CLI STATES for the model this session is using right now.
+     * Absent = unknown — never a guess, never a table keyed on the id, never the window of a
+     * neighbouring model or another session's.
+     */
+    window?: number;
+}
+/** (2.2) One compaction of THIS session, as the CLI recorded it. */
+export interface SourceCompaction {
+    /** When it happened (ms). */
+    at: number;
+    /** The fill just before, from the CLI's own count; absent = not stated. */
+    preTok?: number;
+    /** The fill just after; absent = not stated. */
+    postTok?: number;
+    /** True = the CLI compacted on its own, false = asked for (`/compact`); absent = not stated. */
+    auto?: boolean;
+}
+export interface ContextSource {
+    /**
+     * Current fill, from the CLI's own count. The window rides only as `window`, and only when
+     * the CLI states it for the model in use (absent = unknown, never a guess).
+     */
+    sample(s: SourceSession): SourceContextSample | null;
+    watch?(s: SourceSession, on: (c: SourceContextSample) => void): () => void;
+    /** (2.2) This session's compactions, oldest first. Null = cannot say; `[]` = none happened. */
+    compactions?(s: SourceSession): SourceCompaction[] | null;
+}
+/**
+ * (2.2) What THIS session has spent so far, in the backend's own figures — each field only
+ * where the CLI states it, absent otherwise (never derived from a price table, never zero for
+ * unknown). `tok`/`usd` are the session's own turns, `agentTok`/`agentUsd` its subagents'.
+ * `usd` only where the CLI states dollars. A unit that is not dollars (Copilot's AI credits)
+ * rides as `native` — never converted, never summed with dollars or with another unit.
+ */
+export interface SourceSessionSpend {
+    /** When this reading was taken (ms). */
+    at: number;
+    tok?: number;
+    agentTok?: number;
+    usd?: number;
+    agentUsd?: number;
+    native?: {
+        amount: number;
+        unit: string;
+        agentAmount?: number;
+    };
+}
+/** A ledger in the backend's OWN unit, served at GET /api/tokenstats/<backendId>. */
+export interface TokenSource {
+    ledger(maxAgeMs: number): Promise<BackendTokensDoc>;
+    /** (2.2) THIS session's spend so far. Null = cannot say. */
+    session?(s: SourceSession): SourceSessionSpend | null;
+}
+/** What a side channel is doing. Published as `SessionInfo.sideChannel`. */
+export interface ChannelHealth {
+    state: "up" | "down";
+    since: number;
+    note?: string;
+}
+export interface SourceHandle {
+    /** The session ended: tear the channel down, and any child the CLI depends on with it. */
+    close(): Promise<void>;
+    health(): ChannelHealth;
+    /**
+     * The CLI's own conversation id this channel is bound to, when the attach KNOWS it
+     * (opencode: the daemon created the conversation on the backend's server). Adopted as
+     * `SessionInfo.backendSessionId`; absent = discover it the old way.
+     */
+    readonly backendSessionId?: string;
+    /**
+     * The PTY detached but the CLI keeps running (a tmux pane): drop the stream, KEEP any
+     * child the CLI depends on, so a re-attach finds it. Absent ⇒ `close()`.
+     */
+    suspend?(): Promise<void>;
+    /**
+     * This session has NO channel and never will (opencode: a pane started before the daemon
+     * ran its server, so there is no record of one): the sentence says so, in words, and is
+     * published as the down note. Sends are NOT held — the screen readers keep every rung, as
+     * for a backend without sources. Absent = a real channel, held while it is down.
+     */
+    readonly screenOnly?: string;
+}
+/** A question with NO choice box: Copilot `ask_user`, codex `requestUserInput`, opencode `question`. */
+export interface SourceQuestion {
+    /** The CLI's own id — becomes `DetectedPrompt.askId`. */
+    readonly id: string;
+    readonly question: string;
+    /** Absent = free text only. */
+    readonly options?: {
+        index: number;
+        label: string;
+        desc?: string;
+    }[];
+    /** A typed answer is accepted. */
+    readonly freeText: boolean;
+    /** Answer by the CLI's own channel. `{keys}`/`{typed}` = the host types it (`boxes.ts` `answerBox`). */
+    answer(a: {
+        choice?: number;
+        text?: string;
+    }): Promise<{
+        ok: boolean;
+        reason?: string;
+    } | SourceKeys | SourceTyped>;
+}
+/** The host types `typed` into the CLI's OWN FORM (never the composer), then `then`. At most `SOURCE_TYPED_MAX` chars. */
+export interface SourceTyped {
+    typed: string;
+    then?: "\r";
+}
+export declare const SOURCE_TYPED_MAX = 1000;
+export interface QuestionSource {
+    watch(s: SourceSession, on: {
+        asked(q: SourceQuestion): void;
+        closed(id: string): void;
+    }): () => void;
+    pending?(s: SourceSession): Promise<SourceQuestion[] | null>;
+}
+/** Plan mode as the CLI states it: the plan text and the two verbs. Absent ⇒ no plan box. */
+export interface SourcePlan {
+    readonly id: string;
+    readonly text: string;
+    approve(): Promise<{
+        ok: boolean;
+        reason?: string;
+    } | SourceKeys>;
+    keepPlanning(): Promise<{
+        ok: boolean;
+        reason?: string;
+    } | SourceKeys>;
+}
+export interface PlanSource {
+    watch(s: SourceSession, on: {
+        posed(p: SourcePlan): void;
+        closed(id: string): void;
+    }): () => void;
+}
+/** One ACCOUNT's windows, in the wire's own shape, plus the wall. */
+export interface UsageSource {
+    /** Never `"claude"` from a plugin. */
+    readonly source: UsageSourceId;
+    readonly label: string;
+    /** Null = absent; an empty list = send nothing. */
+    windows(): Promise<UsageWindow[] | null>;
+    /** Is THIS session blocked by the account right now? `resetAt` only when the CLI stated it. */
+    wall?(s: SourceSession): {
+        blocked: boolean;
+        resetAt?: number;
+        why: string;
+    } | null;
+    everyMs?: number;
+}
+export interface SourceAgent {
+    id: string;
+    name?: string;
+    startedAt: number;
+    endedAt?: number;
+    lastWriteAt?: number;
+}
+/** Polled on `agents.ts`'s cadence. */
+export interface AgentSource {
+    list(s: SourceSession): SourceAgent[] | null;
+}
+export interface SourceConversation {
+    id: string;
+    title?: string;
+    updatedAt: number;
+    firstPrompt?: string;
+}
+export interface ConversationSource {
+    list(cwd: string): Promise<SourceConversation[] | null>;
+    fork?(id: string, atTurn?: string): Promise<{
+        id: string;
+    } | null>;
+    remove?(cwd: string, id: string): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+}
+/** The mode the CLI is in, as one of the descriptor's `caps.permissionModes`. Fact name "mode". */
+export interface ModeSource {
+    /** The mode now. Null = unknown, never a guess; a mode not in `caps.permissionModes` is unknown. */
+    current(s: SourceSession): PermissionMode | null;
+    watch?(s: SourceSession, on: (m: PermissionMode) => void): () => void;
+    /**
+     * Switch to `target`. The backend switches itself (a server call) ⇒ `{ok, reason?}`; or it
+     * answers ONE press (`SourceKeys`, e.g. Shift+Tab) the core types, after which the core re-reads
+     * `current()` until it changes — `livemode.ts`'s ladder (stop on the target / a repeat /
+     * 6 presses), never counting positions.
+     */
+    set(s: SourceSession, target: PermissionMode): Promise<{
+        ok: boolean;
+        reason?: string;
+    } | SourceKeys>;
+}
+/** One of the CLI's slash commands, as the CLI lists it. */
+export interface SourceCommand {
+    /** With the slash: `"/compact"`. */
+    name: string;
+    description?: string;
+    /** The arguments as the CLI's help writes them; absent = none or unknown. */
+    args?: string;
+    /** Runs in the TUI and starts no agent turn (the delivery's proof is the screen moving). */
+    local?: boolean;
+}
+/** The CLI's slash commands. Fact name "commands". At most `SOURCE_COMMANDS_MAX` rows. */
+export interface CommandSource {
+    /** The commands for a session in `cwd`. Null = cannot say. */
+    list(cwd: string): Promise<SourceCommand[] | null>;
+}
+export interface BackendSources {
+    /**
+     * The channel rides the CLI process itself (claude: hooks the CLI runs as curls to the host):
+     * nothing to connect, so the subscriptions are live the moment `attach` is called; its health
+     * is `SessionInfo.hooked` and is never published as `sideChannel`; it never reports `down`,
+     * and no send is held for it. Absent ⇒ a channel of its own (a server, an event stream).
+     */
+    readonly inBand?: boolean;
+    turns?: TurnSource;
+    dialogs?: DialogSource;
+    delivery?: DeliverySource;
+    transcript?: TranscriptSource;
+    context?: ContextSource;
+    tokens?: TokenSource;
+    /** 2.0 slots — typed, consumed by later packages (see above). */
+    questions?: QuestionSource;
+    plan?: PlanSource;
+    usage?: UsageSource;
+    agents?: AgentSource;
+    conversations?: ConversationSource;
+    /** 2.2 slots — typed, consumed by later packages (see above). */
+    mode?: ModeSource;
+    commands?: CommandSource;
+    /** Per session: bring the channel up (spawn a child, open SSE); the returned handle tears it down. */
+    attach(s: SourceSession, onHealth: (h: ChannelHealth) => void): Promise<SourceHandle>;
+    /**
+     * Reap what a session that no longer exists left behind (opencode: a seat's server and its
+     * record, after its pane died while detached or while the daemon was down). `alive(id)`
+     * is the host's answer for a waterplane session id — a live session, or a tmux pane still
+     * running under that name. Called after the plugins settle and then periodically; must
+     * touch nothing whose id `alive` vouches for, and nothing it did not start itself.
+     */
+    sweep?(alive: (hostSessionId: string) => boolean): void;
+}

package/node_modules/@waterplane/shared/dist/backendsources.js

@@ -0,0 +1,3 @@
+export const SOURCE_KEYS_MAX = 8;
+export const SOURCE_TYPED_MAX = 1000;
+//# sourceMappingURL=backendsources.js.map

package/node_modules/@waterplane/shared/dist/backendsources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backendsources.js","sourceRoot":"","sources":["../src/backendsources.ts"],"names":[],"mappings":"AAoGA,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC;AA0IjC,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC"}

package/node_modules/@waterplane/shared/dist/billing.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The BILLING PROFILE - which kind of account this desktop's `claude` bills to.
+ *
+ * Everything usage-shaped here began as a subscription: two rolling windows
+ * scraped off `/usage`. An API-key or cloud account has neither, and showing it
+ * `?` chips and an empty weekly card is a lie by omission. The profile says which
+ * model of "budget" applies.
+ *
+ * The probe itself (env, `~/.claude/settings.json`, `claude auth status`) is the
+ * HOST's; this module is the pure classification both ends can test. **Ambiguous
+ * or silent input is `unknown`, never a guess** - and `unknown` shows nothing.
+ * Local / endpoint backends are not the account profile and are not asked here.
+ */
+export type BillingProfile = "subscription" | "api" | "cloud" | "unknown";
+export type BillingSource = "probe" | "setting";
+export interface BillingStatus {
+    profile: BillingProfile;
+    /** `setting`: the person said so and it wins. `probe`: detected. */
+    source: BillingSource;
+}
+/** What the host managed to read. Every field optional; absent = "could not tell". */
+export interface BillingProbe {
+    /** `ANTHROPIC_API_KEY` (or auth token) is set in the claude process env. */
+    apiKeyEnv?: boolean;
+    /** claude settings carry an `apiKeyHelper`. */
+    apiKeyHelper?: boolean;
+    /** `CLAUDE_CODE_USE_BEDROCK` / `_VERTEX` / `_FOUNDRY` truthy. */
+    cloudEnv?: boolean;
+    /** Raw output of `claude auth status`, if it ran. */
+    authStatus?: string | null;
+}
+/** What an auth-status text names: `subscription`, `api`, both (`conflict`) or nothing. */
+export declare function authStatusKind(text: string | null | undefined): "subscription" | "api" | "conflict" | null;
+/**
+ * Classify one probe. Cloud env wins over a key (the CLI routes to the cloud
+ * whatever else is set) but not over a claude.ai login (a conflict: unknown).
+ * A key/helper alongside a claude.ai login is also unknown - which one the CLI
+ * bills depends on state we did not read.
+ */
+export declare function classifyBilling(p: BillingProbe | null | undefined): BillingProfile;
+export declare function isBillingProfile(v: unknown): v is BillingProfile;
+/** A stored override, read strictly: a real profile other than `unknown`, else null. */
+export declare function cleanBillingSetting(v: unknown): Exclude<BillingProfile, "unknown"> | null;
+/** The status the host reports: a setting wins; otherwise the probe. */
+export declare function resolveBilling(setting: unknown, probe: BillingProbe | null | undefined): BillingStatus;
+/** Does this profile have the scraped session/weekly windows? `unknown` is
+ *  treated as yes: today's behaviour is the fallback, never a new guess. */
+export declare const hasScrapedWindows: (p: BillingProfile | null | undefined) => boolean;

package/node_modules/@waterplane/shared/dist/billing.js

@@ -0,0 +1,64 @@
+/**
+ * The BILLING PROFILE - which kind of account this desktop's `claude` bills to.
+ *
+ * Everything usage-shaped here began as a subscription: two rolling windows
+ * scraped off `/usage`. An API-key or cloud account has neither, and showing it
+ * `?` chips and an empty weekly card is a lie by omission. The profile says which
+ * model of "budget" applies.
+ *
+ * The probe itself (env, `~/.claude/settings.json`, `claude auth status`) is the
+ * HOST's; this module is the pure classification both ends can test. **Ambiguous
+ * or silent input is `unknown`, never a guess** - and `unknown` shows nothing.
+ * Local / endpoint backends are not the account profile and are not asked here.
+ */
+const SUB = /claude\.ai|claude\s+(?:pro|max|team|enterprise)\b|\b(?:pro|max)\s+(?:plan|account|subscription)\b|\bsubscription\b/i;
+const API = /\bapi[\s_-]?key\b|anthropic\s+console|\bconsole\b/i;
+/** What an auth-status text names: `subscription`, `api`, both (`conflict`) or nothing. */
+export function authStatusKind(text) {
+    if (!text)
+        return null;
+    const s = SUB.test(text);
+    const a = API.test(text);
+    return s && a ? "conflict" : s ? "subscription" : a ? "api" : null;
+}
+/**
+ * Classify one probe. Cloud env wins over a key (the CLI routes to the cloud
+ * whatever else is set) but not over a claude.ai login (a conflict: unknown).
+ * A key/helper alongside a claude.ai login is also unknown - which one the CLI
+ * bills depends on state we did not read.
+ */
+export function classifyBilling(p) {
+    if (!p)
+        return "unknown";
+    const auth = authStatusKind(p.authStatus);
+    if (auth === "conflict")
+        return "unknown";
+    const key = p.apiKeyEnv === true || p.apiKeyHelper === true;
+    if (p.cloudEnv === true)
+        return auth === "subscription" ? "unknown" : "cloud";
+    // A key beside a probe that RAN and said nothing (`authStatus: null`: timed out, spawn failed) could be
+    // sitting next to a claude.ai login - which one is billed was not read, so it is not guessed.
+    if (key)
+        return auth === "subscription" || p.authStatus === null ? "unknown" : "api";
+    if (auth === "subscription")
+        return "subscription";
+    if (auth === "api")
+        return "api";
+    return "unknown";
+}
+export function isBillingProfile(v) {
+    return v === "subscription" || v === "api" || v === "cloud" || v === "unknown";
+}
+/** A stored override, read strictly: a real profile other than `unknown`, else null. */
+export function cleanBillingSetting(v) {
+    return v === "subscription" || v === "api" || v === "cloud" ? v : null;
+}
+/** The status the host reports: a setting wins; otherwise the probe. */
+export function resolveBilling(setting, probe) {
+    const s = cleanBillingSetting(setting);
+    return s ? { profile: s, source: "setting" } : { profile: classifyBilling(probe), source: "probe" };
+}
+/** Does this profile have the scraped session/weekly windows? `unknown` is
+ *  treated as yes: today's behaviour is the fallback, never a new guess. */
+export const hasScrapedWindows = (p) => p == null || p === "subscription" || p === "unknown";
+//# sourceMappingURL=billing.js.map

package/node_modules/@waterplane/shared/dist/billing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing.js","sourceRoot":"","sources":["../src/billing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAuBH,MAAM,GAAG,GAAG,qHAAqH,CAAC;AAClI,MAAM,GAAG,GAAG,oDAAoD,CAAC;AAEjE,2FAA2F;AAC3F,MAAM,UAAU,cAAc,CAAC,IAA+B;IAC5D,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,CAAkC;IAChE,IAAI,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IACzB,MAAM,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAC1C,IAAI,IAAI,KAAK,UAAU;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,GAAG,GAAG,CAAC,CAAC,SAAS,KAAK,IAAI,IAAI,CAAC,CAAC,YAAY,KAAK,IAAI,CAAC;IAC5D,IAAI,CAAC,CAAC,QAAQ,KAAK,IAAI;QAAE,OAAO,IAAI,KAAK,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;IAC9E,wGAAwG;IACxG,8FAA8F;IAC9F,IAAI,GAAG;QAAE,OAAO,IAAI,KAAK,cAAc,IAAI,CAAC,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;IACrF,IAAI,IAAI,KAAK,cAAc;QAAE,OAAO,cAAc,CAAC;IACnD,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IACjC,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,CAAU;IACzC,OAAO,CAAC,KAAK,cAAc,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,SAAS,CAAC;AACjF,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,mBAAmB,CAAC,CAAU;IAC5C,OAAO,CAAC,KAAK,cAAc,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACzE,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,cAAc,CAAC,OAAgB,EAAE,KAAsC;IACrF,MAAM,CAAC,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AACtG,CAAC;AAED;4EAC4E;AAC5E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAoC,EAAW,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,cAAc,IAAI,CAAC,KAAK,SAAS,CAAC"}

package/node_modules/@waterplane/shared/dist/bindconv.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Which of the backend's conversations is THIS session's — the pure ladder behind
+ * `HostPluginApi.bindConversation` (plugin contract 2.0). Lifted verbatim from opencode's
+ * `ocIdVerdict`/`pickOcSession` (`ownRow` is `createsRecord` here) so every backend that keeps its
+ * own conversation store decides the same way. The plugin keeps the queries; this is the decision.
+ *
+ * It lives in shared because an in-repo extension reaches core only through `@waterplane/shared`.
+ */
+/** A rung-2 match seen on an EARLIER pass, and when it was seen. */
+export interface BindSighting {
+    readonly id: string;
+    readonly at: number;
+}
+/** What one discovery pass was handed, and what it remembered from the last. */
+export interface BindLook {
+    /**
+     * Is this session's launch ENTITLED to the structural rung at all? True only where our own spawn
+     * wrote a conversation record (`LaunchPlan.createsRecord`: a fresh launch or a fork). False for a
+     * bare `--continue` and a re-attach, where "the one fresh conversation in this directory" is by
+     * construction somebody ELSE'S.
+     */
+    readonly createsRecord: boolean;
+    /** Rung-1 candidates: fresh top-level conversations in this directory. */
+    readonly fresh: readonly string[];
+    /** Rung-2 candidates: conversations holding this delivery's prompt, whole-string. */
+    readonly prompt: readonly string[];
+    /** Ids other live sessions have already adopted. */
+    readonly adopted: ReadonlySet<string>;
+    /** What rung 2 saw last time, if it saw anything. */
+    readonly seen?: BindSighting | null;
+    readonly now: number;
+}
+/** The id to adopt (or null), and the sighting to carry into the next pass. */
+export interface BindVerdict {
+    readonly id: string | null;
+    readonly seen: BindSighting | null;
+}
+/**
+ * How long a rung-2 match must have STOOD before it may be adopted: at the instant a delivery is
+ * confirmed on screen the backend has not yet written OUR record, so a sole match can be a
+ * stranger's. A hit is remembered and adopted only if a LATER pass still finds it alone.
+ */
+export declare const BIND_CONFIRM_MS = 2000;
+/** Exactly one survivor, or nothing. Never "the newest", never "the first". */
+export declare function pickBound(candidates: readonly string[], adopted: ReadonlySet<string>): string | null;
+/** One pass of the id discovery, as a fold over what the store answered. */
+export declare function bindConversation(look: BindLook): BindVerdict;

package/node_modules/@waterplane/shared/dist/bindconv.js

@@ -0,0 +1,35 @@
+/**
+ * Which of the backend's conversations is THIS session's — the pure ladder behind
+ * `HostPluginApi.bindConversation` (plugin contract 2.0). Lifted verbatim from opencode's
+ * `ocIdVerdict`/`pickOcSession` (`ownRow` is `createsRecord` here) so every backend that keeps its
+ * own conversation store decides the same way. The plugin keeps the queries; this is the decision.
+ *
+ * It lives in shared because an in-repo extension reaches core only through `@waterplane/shared`.
+ */
+/**
+ * How long a rung-2 match must have STOOD before it may be adopted: at the instant a delivery is
+ * confirmed on screen the backend has not yet written OUR record, so a sole match can be a
+ * stranger's. A hit is remembered and adopted only if a LATER pass still finds it alone.
+ */
+export const BIND_CONFIRM_MS = 2_000;
+/** Exactly one survivor, or nothing. Never "the newest", never "the first". */
+export function pickBound(candidates, adopted) {
+    const left = [...new Set(candidates)].filter((id) => id && !adopted.has(id));
+    return left.length === 1 ? left[0] : null;
+}
+/** One pass of the id discovery, as a fold over what the store answered. */
+export function bindConversation(look) {
+    if (look.createsRecord) {
+        const fresh = pickBound(look.fresh, look.adopted);
+        if (fresh)
+            return { id: fresh, seen: null };
+    }
+    const hit = pickBound(look.prompt, look.adopted);
+    if (!hit)
+        return { id: null, seen: null };
+    const seen = look.seen && look.seen.id === hit ? look.seen : { id: hit, at: look.now };
+    if (look.now - seen.at >= BIND_CONFIRM_MS)
+        return { id: hit, seen: null };
+    return { id: null, seen };
+}
+//# sourceMappingURL=bindconv.js.map

package/node_modules/@waterplane/shared/dist/bindconv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindconv.js","sourceRoot":"","sources":["../src/bindconv.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkCH;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAC;AAErC,+EAA+E;AAC/E,MAAM,UAAU,SAAS,CAAC,UAA6B,EAAE,OAA4B;IACnF,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7E,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7C,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,gBAAgB,CAAC,IAAc;IAC7C,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,KAAK;YAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC9C,CAAC;IACD,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACjD,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;IACvF,IAAI,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,IAAI,eAAe;QAAE,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC1E,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC"}

package/node_modules/@waterplane/shared/dist/bookmark.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Bookmarks on conversations (R-conversations-007) — what a bookmark may say.
+ * The host keeps them per repo directory, keyed by conversation id, and stamps
+ * them onto archive rows, `SessionInfo.bookmark` and `ClosedSession.bookmark`;
+ * both ends read one through `cleanBookmark`, so a note is clipped by one rule.
+ *
+ * A bookmark changes nothing about the session: it is a way BACK to a
+ * conversation among thousands, not a reason to keep the session open.
+ */
+import type { Bookmark } from "./wire/session.js";
+/** A note, and a remembered tab name, are one line of at most this. */
+export declare const BOOKMARK_NOTE_CAP = 160;
+/** One line, collapsed whitespace, clipped with an ellipsis; empty ⇒ undefined. */
+export declare function clipBookmarkText(v: unknown, cap?: number): string | undefined;
+/**
+ * A bookmark read off disk or the wire. A missing or non-positive `at` drops
+ * the WHOLE bookmark (`null`) — a row that cannot say when it was set is not
+ * one somebody set; `note`/`name` are clipped to one line and dropped empty.
+ */
+export declare function cleanBookmark(raw: unknown): Bookmark | null;
+/**
+ * Is `id` a bare conversation id — the jsonl basename the CLI writes, and the
+ * only shape the host will turn into a path (`transcriptPath`)? The same rule
+ * the archive's delete has always applied: no separators, no dots, ≤128 chars.
+ */
+export declare function isConversationId(id: unknown): id is string;