waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/wire/messages/clientbacklog.d.ts

@@ -0,0 +1,177 @@
+import type { ItemCategory } from "../../naming.js";
+import type { SessionBudget } from "../../sessionbudget.js";
+import type { SendStamp } from "../../sendstamp.js";
+import type { LaunchOpts } from "../session.js";
+export type ClientBacklogMsg = {
+    t: "backlog.list";
+}
+/** autoFire: fire when the target session next goes idle (per-item; ignores the global auto switch) — appends to the queue bottom so items run in the order added.
+ *  `ackId` (optional): same contract as session.input — the host de-dupes a
+ *  repeat and answers `backlog.ack`, so the phone can queue an item while
+ *  offline and safely re-send it on reconnect without adding it twice.
+ *
+ *  `steps` is the WHOLE chain, `steps[0]` being `text` again — one item that
+ *  is delivered a turn at a time (`payload.steps`, which never concatenates),
+ *  rather than the N separate items the sheet used to post for a chain. Absent
+ *  means the one-turn item this message has always carried, and a host that
+ *  does not know the field reads `text` and runs the first turn: old
+ *  behaviour, not a dropped chain.
+ *
+ *  `resume` opens the new session with `claude --continue` — "a new session,
+ *  picking up the repo's last conversation". Absent = start clean, which is
+ *  the default precisely because it is the cheap side of `sessioncost.ts`.
+ *
+ *  Both are ADDITIVE: `PROTOCOL_VERSION` did not move for it. Neither adds a message,
+ *  neither changes what an existing field means, and absent is the behaviour
+ *  every bundle already shipped has.
+ *
+ *  `pastBudget` is the person's *past the budget* for THIS prompt, asked at
+ *  the moment it is queued: the host lets the new row past the usage budget
+ *  exactly as `intent.waive` would (only the budget, until the tripped
+ *  window resets). Additive too — an older desktop ignores it and the row
+ *  waits for the budget like any other.
+ *
+ *  `launch` is the model/effort/backend the item's OWN session starts with
+ *  (`Intent.launch`, the send sheet's *model* row), cleaned by
+ *  `cleanLaunchOpts` on the way in; meaningless beside `targetSessionId`.
+ *  Additive: an older desktop drops it and opens the session on its own
+ *  new-session defaults, which is what absent means. */
+ | ({
+    t: "backlog.add";
+    text: string;
+    repoDir: string;
+    label?: string;
+    fire?: boolean;
+    targetSessionId?: string;
+    autoFire?: boolean;
+    steps?: string[];
+    resume?: boolean;
+    closeWhenDone?: boolean;
+    flagWhenDone?: boolean;
+    budget?: SessionBudget;
+    launch?: LaunchOpts;
+    pastBudget?: boolean;
+    ackId?: string;
+} & SendStamp) | {
+    t: "backlog.remove";
+    id: string;
+} | {
+    t: "backlog.fire";
+    id: string;
+} | {
+    t: "backlog.done";
+    id: string;
+}
+/**
+ * targetSessionId: "" clears the target (back to the repo default session).
+ *
+ * `autoFire` is the per-item switch `backlog.add` already carries, on an item
+ * that already exists — which is what "queue this one here" is. Sent WITH a
+ * `targetSessionId`, it means the whole of that tap: aim the item at that
+ * session, exempt it from the global auto switch, and move it to the BOTTOM of
+ * the queue so tapping three items in a row runs them in that order. Absent =
+ * leave the flag alone, like every other field here.
+ *
+ * `resume` is `backlog.add`'s flag on an item that already exists — the chip
+ * being turned on or off for a row that is still waiting. Absent leaves it
+ * alone, like every other field here, which is what makes `false` meaningful:
+ * it is the only way to say "start clean after all". Additive, v1.
+ *
+ * `closeWhenDone` is the item's own *close its session when done* answer
+ * (`Intent.closeWhenDone`): `true`/`false` set it, `null` puts it back to
+ * following the global setting, absent leaves it alone. Unlike the fields
+ * above it is NOT an edit to the work — it lands through `edit()`, on a row
+ * in any state (a running item's session is exactly the one a person may
+ * decide to keep), and never re-queues anything. Additive, v1.
+ *
+ * `flagWhenDone` is the item's *flag for follow up when done* (`Intent.
+ * flagWhenDone`): `true` sets it, `false`/`null` clears it, absent leaves it
+ * alone. Lands through `edit()` like `closeWhenDone`, on a row in any state.
+ *
+ * `budget` is the cap the session this row OPENS is born with (`Intent.
+ * budget`): an object sets or changes it, `null` clears it, absent leaves it
+ * alone. The host cleans it (`cleanSessionBudget`) and applies it only to a
+ * row that has not started (`edit()` says so otherwise). Additive, v1.
+ *
+ * `headline` and `category` are the person taking a machine-written name over
+ * (`naming.ts`). A non-empty string is stamped `hand` by the host and is never
+ * written over again by an assessment or a naming pass; `""` CLEARS the value
+ * AND its author, which is "nobody has said", not "a person said nothing" — so
+ * a later pass may name it again. The client never sends an author: a claim
+ * about who wrote a name is the host's to make, exactly as `handOrdered` is.
+ * Additive, v1.
+ */
+ | {
+    t: "backlog.update";
+    id: string;
+    text?: string;
+    label?: string;
+    repoDir?: string;
+    targetSessionId?: string;
+    autoFire?: boolean;
+    resume?: boolean;
+    closeWhenDone?: boolean | null;
+    flagWhenDone?: boolean | null;
+    budget?: SessionBudget | null;
+    headline?: string;
+    category?: ItemCategory | "";
+}
+/**
+ * **Name these items** — the optional half of titles and kinds.
+ *
+ * A hand-written backlog row has no title and no kind and nothing derives one
+ * for it, because nothing here applies itself. This is the tap that asks: one
+ * toolless sidecar call that reads the items' OWN WORDS and nothing else — no
+ * repo, no git, no tools — and writes a headline and a category on the rows
+ * that have none.
+ *
+ * Durable (`ackId`), and safe to replay for a reason worth stating: a pass
+ * never overwrites a field whose author is `hand`, and writing the same title
+ * twice is the same row. `ids` is the CUT the phone was showing, never "the
+ * repo" — a count on a control is a filter, so the rows named are the rows
+ * counted. Additive, v1.
+ */
+ | ({
+    t: "backlog.name";
+    repoDir: string;
+    ids: string[];
+    ackId?: string;
+} & SendStamp) | {
+    t: "backlog.swap";
+    id: string;
+    otherId: string;
+}
+/** Apply an explicit top-to-bottom order (drag-and-drop). */
+ | {
+    t: "backlog.reorder";
+    ids: string[];
+} | {
+    t: "backlog.archive";
+    id: string;
+    archived: boolean;
+} | {
+    t: "backlog.check";
+    id: string;
+}
+/** Deep outcome validation — verdict + proposed next steps. */
+ | {
+    t: "backlog.validate";
+    id: string;
+}
+/** Feed a chosen validation next-step (by index) back into the item's session. */
+ | {
+    t: "backlog.nextStep";
+    id: string;
+    step: number;
+}
+/** Open/resume a coding session for the item, seeded with its task + check/validate verdict as context. */
+ | {
+    t: "backlog.continue";
+    id: string;
+} | {
+    t: "backlog.setAuto";
+    enabled: boolean;
+} | {
+    t: "backlog.openRepoSession";
+    repoDir: string;
+};

package/node_modules/@waterplane/shared/dist/wire/messages/clientbacklog.js

@@ -0,0 +1,3 @@
+// Client → host: the backlog. A member list of `ClientMessage` (`../messages.ts`).
+export {};
+//# sourceMappingURL=clientbacklog.js.map

package/node_modules/@waterplane/shared/dist/wire/messages/clientbacklog.js.map

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

package/node_modules/@waterplane/shared/dist/wire/messages/clienthost.d.ts

@@ -0,0 +1,344 @@
+import type { UsageBudget } from "../../budget.js";
+import type { InstallReportEntry, InstallReporter } from "../install.js";
+import type { NotifyPrefs } from "../notify.js";
+import type { StallReport } from "../../netstall.js";
+import type { PluginValue } from "../../plugin.js";
+import type { LimitResumeMode } from "../session.js";
+import type { ClientUpdatesMsg } from "./clientupdates.js";
+export type ClientHostMsg = ClientUpdatesMsg | {
+    t: "update.status";
+} | {
+    t: "update.check";
+} | {
+    t: "update.apply";
+} | {
+    t: "usage.get";
+} | {
+    t: "usage.refresh";
+}
+/** Ask for every installed plugin; answered with `plugin.list`. */
+ | {
+    t: "plugin.list";
+}
+/** Change a plugin's settings (only declared keys; a refused value is named in `plugin.error`). */
+ | {
+    t: "plugin.set";
+    id: string;
+    values: Record<string, PluginValue>;
+}
+/** Turn a plugin on or off without removing it. */
+ | {
+    t: "plugin.enable";
+    id: string;
+    enabled: boolean;
+}
+/** Tap a declared action; `sessionId` for a session-scoped one. Answered with `plugin.actionResult`. */
+ | {
+    t: "plugin.action";
+    id: string;
+    action: string;
+    sessionId?: string;
+    reqId: string;
+}
+/** Flip a plugin's per-session toggle; `value: null` goes back to the manifest default. */
+ | {
+    t: "plugin.sessionToggle";
+    id: string;
+    sessionId: string;
+    toggle: string;
+    value: boolean | null;
+}
+/** The core-owned "let <plugin> answer" switch for one session. */
+ | {
+    t: "plugin.sessionAnswer";
+    id: string;
+    sessionId: string;
+    value: boolean;
+}
+/** Ask a plugin's `handle()`d method. NOT durable, never queued offline, not in the ack ledger:
+ *  `ackId` addresses the reply and de-duplicates a repeated frame (host `plugins/pluginrpc.ts`). */
+ | {
+    t: "plugin.call";
+    plugin: string;
+    method: string;
+    args?: unknown;
+    ackId: string;
+}
+/** Open `plugin`'s stream `name` for THIS socket. Answered by `stream.opened` or
+ *  `stream.refused`, matched on `reqId` (client-minted). */
+ | {
+    t: "stream.open";
+    reqId: string;
+    plugin: string;
+    name: string;
+    params?: unknown;
+}
+/** Re-steer an open stream (quality, crop, source). Replaces the params; the plugin decides
+ *  what changes. */
+ | {
+    t: "stream.params";
+    streamId: number;
+    params: unknown;
+}
+/** One upstream event (a pointer move, a key). Fire-and-forget, at most once. */
+ | {
+    t: "stream.input";
+    streamId: number;
+    ev: unknown;
+}
+/** What the client has received so far on this stream: the newest `seq` and the payload bytes
+ *  it counted. This is the Auto controller's measure of what is in flight. */
+ | {
+    t: "stream.ack";
+    streamId: number;
+    seq: number;
+    rxBytes: number;
+}
+/** Ask the producer for a keyframe now (a decoder error, a reopened view). */
+ | {
+    t: "stream.keyframe";
+    streamId: number;
+} | {
+    t: "stream.close";
+    streamId: number;
+} | {
+    t: "decisions.get";
+    sessionId?: string;
+} | {
+    t: "decisions.archive";
+    id: string;
+    archived: boolean;
+} | {
+    t: "decisions.delete";
+    id: string;
+} | {
+    t: "decisions.archiveAll";
+}
+/** Ask for the sent-command log; `sessionId` filters to one session. */
+ | {
+    t: "sent.get";
+    sessionId?: string;
+}
+/** Wipe the log (it is a local audit trail, not accounting). */
+ | {
+    t: "sent.clear";
+}
+/** Ask for the whole synced document (also sent unprompted on hello). */
+ | {
+    t: "settings.get";
+}
+/**
+ * Store one setting. `value` is the client's RAW localStorage string and the
+ * host never parses it; `ts` is stamped by the writer and decides last-write-
+ * wins, so a client whose clock is behind loses rather than corrupts.
+ */
+ | {
+    t: "settings.set";
+    key: string;
+    value: string;
+    ts: number;
+    device?: string;
+}
+/**
+ * Ask for the whole install log. Also sent unprompted on `hello`, because the
+ * question it answers — *which version of what is on which phone* — is the
+ * one thing a single device cannot work out for itself.
+ */
+ | {
+    t: "install.get";
+}
+/**
+ * "Here is every install this phone still has a record of."
+ *
+ * A RE-STATEMENT, not an event: the install worth reporting is usually the
+ * one that happened at 3 a.m. with the tunnel down, so a phone re-sends its
+ * whole history on every connect and the host merges on each entry's key.
+ * Not durable and never queued offline for that exact reason — an ackId would
+ * protect a delivery that is already idempotent, and a queued copy would only
+ * repeat what the next `hello` says anyway.
+ */
+ | {
+    t: "install.report";
+    device: InstallReporter;
+    entries: InstallReportEntry[];
+}
+/**
+ * The phone's HTTP stalls (`shared/netstall.ts`): the evidence for WHY a
+ * request hung while this socket stayed healthy. Over the socket, never a
+ * POST, because the thing being measured is the HTTP pool being stuck. A
+ * RE-STATEMENT like `install.report` — the whole ring each time, merged on
+ * each event's key — so not durable and never queued. Additive: an older
+ * host ignores the unknown `t`.
+ */
+ | {
+    t: "net.stalls";
+    deviceId: string;
+    report: StallReport;
+}
+/** LAN password gate (managed only from the trusted loopback/Tailscale path). */
+ | {
+    t: "auth.set";
+    password: string;
+} | {
+    t: "auth.clear";
+} | {
+    t: "auth.gateTailscale";
+    enabled: boolean;
+}
+/** Re-fetch the current auth state for this socket. */
+ | {
+    t: "auth.get";
+}
+/** Global switch: automatically send "continue" once a hit usage limit resets. */
+ | {
+    t: "limit.setAuto";
+    enabled: boolean;
+}
+/** Per-session auto-continue override; null clears it (inherit the global switch). */
+ | {
+    t: "limit.session";
+    id: string;
+    override: boolean | null;
+}
+/** Push a session to the front of the resume queue (`on: false` clears it).
+ *  Several "first" sessions keep the order they were marked in. */
+ | {
+    t: "limit.first";
+    id: string;
+    on: boolean;
+}
+/** Resume NOW, without waiting for the scheduled reset time: one session when
+ *  `id` is given, otherwise every queued one. Still paced by the queue —
+ *  "now" means "stop waiting for the clock", not "ignore the release mode". */
+ | {
+    t: "limit.resume";
+    id?: string;
+}
+/** How the resume queue releases sessions once the limit lifts (host-wide). */
+ | {
+    t: "limit.setMode";
+    mode: LimitResumeMode;
+}
+/** The emergency halt: `on` stops every AI process this host started and
+ *  latches until a later `on: false` (`shared/halt.ts`). Idempotent — a
+ *  repeat of the same value is a no-op, so no ackId is needed. */
+ | {
+    t: "host.halt";
+    on: boolean;
+}
+/** Fetch the in-app notification feed. */
+ | {
+    t: "notification.get";
+}
+/** Clear all in-app notifications. */
+ | {
+    t: "notification.clear";
+}
+/**
+ * Mute or unmute notification KINDS, host-wide.
+ *
+ * Host-side and not a synced `waterplane.*` setting because the host is the one
+ * that must act on it: a muted kind has to be dropped BEFORE the OS push is
+ * sent, and `settings.ts` stores opaque strings the daemon deliberately never
+ * parses. Sparse — only the kinds this write changes are sent, the rest keep
+ * whatever the host holds.
+ */
+ | {
+    t: "notify.prefs.set";
+    prefs: NotifyPrefs;
+}
+/**
+ * The usage BUDGET — "stop starting automatic work past this much of the
+ * window, and start again when it resets" (`shared/budget.ts`).
+ *
+ * Additive and NOT in the durable-op set, like `settings.*` and `pull.*`:
+ * setting a ceiling is idempotent state, so a replay writes the same number
+ * and there is nothing an ackId would protect. The host answers both with
+ * `budget.state`.
+ */
+ | {
+    t: "budget.get";
+} | {
+    t: "budget.set";
+    budget: UsageBudget;
+}
+/**
+ * The billing profile (`shared/billing.ts`): `billing.get` asks, `billing.set`
+ * overrides it (`profile: null` clears the override back to the probe). Both
+ * are answered with `billing.status`. Additive, NOT durable - idempotent state
+ * like `budget.set`; an older host ignores both.
+ */
+ | {
+    t: "billing.get";
+} | {
+    t: "billing.set";
+    profile: "subscription" | "api" | "cloud" | null;
+}
+/**
+ * The CLI integration's own health (`shared/clihealth.ts`) — answered with
+ * `clihealth`.
+ *
+ * Additive and NOT in the durable-op set, the `budget.*`/`pull.*` class: it is
+ * a read, and asking twice costs a verdict recomputed over ten small records
+ * and nothing else, so there is nothing an ackId would protect.
+ */
+ | {
+    t: "clihealth.get";
+}
+/**
+ * A person read the board's warnings and clears them: per signal, every miss
+ * at or before the instant given — the newest miss THAT board showed
+ * (`clearSeen`). Answered with `clihealth`.
+ *
+ * Additive and NOT durable: bounded by what the reader saw, so a late or
+ * repeated delivery removes nothing they did not read — there is nothing an
+ * ackId would protect. Never queued offline either; the button refuses in
+ * words instead.
+ */
+ | {
+    t: "clihealth.clear";
+    through: Record<string, number>;
+}
+/**
+ * Watch the local model runner — a LEASE, not a subscription.
+ *
+ * The route table has no socket-close hook, so watch state must not be able
+ * to outlive its socket. A lease expires on its own; a client that stops
+ * renewing simply lapses, costing at most one lease period of extra loopback
+ * GETs, which is the cheap direction to be wrong in. The alternative — a set
+ * the host prunes on close — is a leak the day a close event is missed.
+ *
+ * Not durable and carries no ackId: it is a READ. Answered immediately with
+ * one `localrt.sample`, so a client can tell a host that ANSWERED from an
+ * older one that ignored an unknown `t`.
+ */
+ | {
+    t: "localrt.watch";
+}
+/**
+ * "Check again": re-ask the backends that said unavailable (Ollama not
+ * reachable). Not durable, no ackId — a read. The answer is a fresh `backends`
+ * frame, sent to everyone only when something changed.
+ */
+ | {
+    t: "backends.recheck";
+}
+/**
+ * Unload one resident model now, instead of waiting for the runner's own
+ * `keep_alive` schedule.
+ *
+ * Deliberately NOT durable and never queued offline, `capture.cancel`'s
+ * reason exactly: this is a decision that only means something RIGHT NOW —
+ * an eject queued behind a dead tunnel and delivered an hour later unloads
+ * whatever is resident THEN, for a reason that may no longer apply, possibly
+ * mid-turn for a session that started after the tap. No `ackId`, no
+ * at-most-once story needed: a repeated eject of an already-gone model is
+ * the runner answering "not found", not a second copy of a real effect.
+ * The result rides back as `localrt.evict`, not `op.ack`.
+ */
+ | {
+    t: "localrt.evict";
+    name: string;
+} | {
+    t: "meter.get";
+};

package/node_modules/@waterplane/shared/dist/wire/messages/clienthost.js

@@ -0,0 +1,3 @@
+// Client → host: updates, usage, plugins, decision log, sent log, settings, auth, limits, notifications, budgets, health. A member list of `ClientMessage` (`../messages.ts`).
+export {};
+//# sourceMappingURL=clienthost.js.map

package/node_modules/@waterplane/shared/dist/wire/messages/clienthost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clienthost.js","sourceRoot":"","sources":["../../../src/wire/messages/clienthost.ts"],"names":[],"mappings":"AAAA,+KAA+K"}