waterplane 0.0.1 → 0.1.6

package/packages/host/dist/sidecar/sidecarclaude.d.ts

@@ -0,0 +1,120 @@
+import type { SidecarTask } from "./sidecarroute.js";
+export interface HeadlessRun {
+    readonly stdout: string;
+    readonly stderr: string;
+    /** The process failed (non-zero exit, timeout, not spawnable). */
+    readonly failed: boolean;
+    /** `execFile`'s error, kept so a caller can say what it was. */
+    readonly err: Error | null;
+}
+export interface HeadlessRequest {
+    readonly cwd: string;
+    /** argv AFTER the binary. */
+    readonly args: readonly string[];
+    /** Written to stdin, as every caller here already does. */
+    readonly prompt: string;
+    readonly timeoutMs: number;
+    readonly maxBuffer: number;
+    /**
+     * **Watch the run happen.** Called with stdout as it arrives, in whatever
+     * chunks the pipe delivers — a caller that wants lines splits them itself,
+     * because a chunk boundary falls mid-line and only the caller knows what a
+     * line means to it.
+     *
+     * Asking for this changes HOW the process is read and nothing about what it
+     * is: a streamed run is spawned rather than `execFile`d, so a `-p` printing
+     * megabytes of tool output on its way to a twenty-minute answer cannot be
+     * killed by `maxBuffer` with its work half done. What is RETAINED for
+     * `stdout` is then the tail (`keepBytes`), because the point of watching is
+     * that the caller already kept what it cared about.
+     *
+     * **Never called once the promise has answered.** A timed-out run resolves at
+     * the deadline and its corpse keeps printing while it is chased, and a
+     * watcher told about a run it has already been given the verdict for writes a
+     * reading of something that is over — see the header of `streamClaude`.
+     */
+    readonly onOut?: (chunk: string) => void;
+    /** With `onOut`, how much stdout the returned `stdout` keeps — the END of it,
+     *  which is where a `-p` envelope and a usage-limit notice are. */
+    readonly keepBytes?: number;
+}
+/**
+ * One headless `claude -p`, prompt on stdin — the shape all three callers had.
+ *
+ * Returns the raw streams rather than an interpretation: the envelope, the
+ * verdict JSON and the usage-limit read are the CALLERS' contracts and stay
+ * where they are. This function's only opinion is that a run is a process.
+ */
+export declare function runHeadlessClaude(req: HeadlessRequest): Promise<HeadlessRun>;
+/**
+ * What one headless call COST, out of its own envelope.
+ *
+ * ── The measurement this is written against (2026-09-17, this desktop) ──────
+ *
+ * `echo hi | claude -p --output-format json --model haiku --setting-sources
+ * user --tools "" --system-prompt "…"` in this repo answers a JSON object
+ * carrying, at the top level: `result`, `is_error`, `subtype` ("success"),
+ * `session_id`, `num_turns`, `duration_ms`, `total_cost_usd`; a `usage` object
+ * with `input_tokens`, `output_tokens`, `cache_read_input_tokens` and
+ * `cache_creation_input_tokens`; and a `modelUsage["<model-id>"]` object with
+ * the camel-cased same (`inputTokens`, `outputTokens`, `cacheReadInputTokens`,
+ * `cacheCreationInputTokens`, `costUSD`, `contextWindow`). The flat `usage` is
+ * what is read here — `modelUsage` is keyed by a model id this daemon does not
+ * otherwise know, and there is nothing in it the flat object does not have.
+ *
+ * Two more facts from that run, written down here because this is the seam a
+ * later phase reaches for and `docs/notes/host.md` does not describe the
+ * feature yet:
+ *
+ *  • **`claude -p` DOES write a transcript**, at
+ *    `~/.claude/projects/<cwd-slug>/<session_id>.jsonl`, keyed by the cwd it
+ *    ran in. So `tokenstats.ts` already attributes an unattended pass to the
+ *    repo it ran in, per repo, with no ledger code and no accounting of our
+ *    own.
+ *  • **Thinking is on by default and will dominate the bill.** A trivial
+ *    one-word haiku reply cost **$0.0049** and spent **548 thinking tokens**
+ *    (`usage.output_tokens_details.thinking_tokens`). For a toolless pass that
+ *    is the cost — not the 2–4k of input going in (`runTextTask` in
+ *    `sidecarname.ts` has the full table and the flag that fixes it). Whoever owns
+ *    the prompt owns that number.
+ *
+ * ── Why it degrades to ABSENT and never to a zero ──────────────────────────
+ *
+ * This is the only honest cost line an unattended call has, and it is shown to
+ * a person as tokens and dollars. A `0` where the envelope said nothing is a
+ * wrong number wearing a true number's clothes, and nothing downstream can tell
+ * the two apart afterwards. So: all four token kinds must be finite numbers or
+ * `usage` is absent altogether (a partial envelope is a shape this does not
+ * recognise, and a three-quarters-filled four-kind count is exactly the wrong
+ * number the rule forbids), and `total_cost_usd` is read on its own — a run may
+ * legitimately report tokens with no price, or a price with no breakdown.
+ *
+ * Pure, and exported for that reason: every way a `-p` envelope can be
+ * unreadable is a fixture, not a spawned process.
+ */
+export interface EnvelopeUsage {
+    readonly inTok: number;
+    readonly outTok: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+}
+export declare function envelopeUsage(stdout: string): {
+    usage?: EnvelopeUsage;
+    usd?: number;
+};
+/** What a tool-using task gets back: a run, or a refusal instead of one. */
+export type ToolTaskRun = HeadlessRun & {
+    readonly refused?: string;
+};
+/**
+ * Run a task that NEEDS tools, through its route.
+ *
+ * Today every such route is `claude-p` and this is the old call verbatim —
+ * behind one gate: a folder Claude Code does not trust is refused, because a
+ * tool task keeps project settings and `-p` would load its hooks without
+ * asking (`workspaceTrust`). A refusal produces no run at all: empty streams,
+ * `failed`, and the sentence — which the caller surfaces as the row's detail,
+ * because a person who misrouted a knob, or opened a repo nobody trusted, needs
+ * to read that, not "the assessment wrote no file".
+ */
+export declare function runToolTask(task: SidecarTask, req: HeadlessRequest): Promise<ToolTaskRun>;

package/packages/host/dist/sidecar/sidecarclaude.js

@@ -0,0 +1,213 @@
+/**
+ * The claude slice of `sidecar.ts` — see that file's header for the seam's rules.
+ */
+import { execFile, spawn } from "node:child_process";
+import { HALT_REFUSAL } from "@waterplane/shared";
+import { claudeBackend } from "../backends/index.js";
+import { isHalted, trackRun } from "../halt.js";
+import { sayOnce, sidecarPlan } from "./sidecarroute.js";
+import { trustRefusal, workspaceTrust } from "./sidecartrust.js";
+/** How much of a streamed run's stdout is kept when the caller did not say. */
+const STREAM_KEEP_BYTES = 256 * 1024;
+/**
+ * One headless `claude -p`, prompt on stdin — the shape all three callers had.
+ *
+ * Returns the raw streams rather than an interpretation: the envelope, the
+ * verdict JSON and the usage-limit read are the CALLERS' contracts and stay
+ * where they are. This function's only opinion is that a run is a process.
+ */
+export function runHeadlessClaude(req) {
+    // Halted (`halt.ts`): a run that never started, in the shape every caller
+    // already reads as a failure — no caller learns a new verdict.
+    if (isHalted())
+        return Promise.resolve({ stdout: "", stderr: HALT_REFUSAL, failed: true, err: new Error(HALT_REFUSAL) });
+    if (req.onOut)
+        return streamClaude(req, req.onOut);
+    return new Promise((resolve) => {
+        let untrack = () => { };
+        const proc = execFile(claudeBackend.bin(), [...req.args], { cwd: req.cwd, timeout: req.timeoutMs, maxBuffer: req.maxBuffer, env: { ...process.env, ...claudeBackend.spawnEnv } }, (err, stdout, stderr) => {
+            untrack();
+            resolve({
+                stdout: (stdout || "").toString(),
+                stderr: (stderr || "").toString(),
+                failed: !!err,
+                err: err ?? null,
+            });
+        });
+        untrack = trackRun((sig) => { proc.kill(sig); });
+        proc.stdin?.end(req.prompt);
+    });
+}
+/**
+ * The same run, read as it happens.
+ *
+ * `execFile` cannot do this job: it buffers the whole of stdout and kills the
+ * child the moment that passes `maxBuffer`, and a `--output-format stream-json`
+ * run prints every tool result it takes — so the one caller that wants to watch
+ * would be the one caller whose process dies half way through a twenty-minute
+ * read. So the streamed branch spawns, hands every chunk over, and keeps only
+ * the tail for the returned `stdout`.
+ *
+ * Everything else is `execFile`'s contract on purpose: a timeout kills the
+ * child and reports `failed` with an error that says so, a spawn that never
+ * happened is `failed`, and the streams come back as strings — because the
+ * callers' readers (`detectHeadlessLimit`, the envelope parse) must not have to
+ * know which branch ran them.
+ *
+ * ── The run is a process GROUP, and the answer is FINAL ─────────────────────
+ *
+ * Two rules here are invisible until they cost a day.
+ *
+ * **A kill must reach the group.** `claude -p` is a shell away from the tools
+ * it runs: the child spawns `sh`, `sh` spawns `npm test`, and a `proc.kill`
+ * with no `detached` hits only the direct child. The orphan then holds the pipe
+ * open (measured: a `sleep 30` behind a killed `sh` made the timeout case of
+ * `sidecarstream.test.mjs` take 30.5 s of every `npm run test:host`), and, far
+ * worse for `assess.ts`, an orphaned `claude` that outlives SIGTERM can write
+ * `.waterplane/assess-out.json` AFTER the NEXT run's `rmSync` — the stale output file
+ * that file's header exists to prevent, arriving from a run nobody is watching
+ * any more. So the child is its own group leader and both signals go to the
+ * group.
+ *
+ * **Nothing is handed over after the promise has answered.** A timeout resolves
+ * at the deadline and the corpse is chased separately, so chunks keep arriving
+ * for as long as the kill takes. Passing them on calls a watcher that has
+ * already been told the run is over — for `assess.ts` that is a `setLive` on a
+ * settled row, which puts memory out of step with the disk until the next
+ * `set()` on any run persists the divergence. Appending them to the retained
+ * tail is merely pointless (the string was copied into the resolve), and
+ * splitting the two guards would leave "what was returned" and "what was kept"
+ * describing different runs, so ONE guard covers both.
+ */
+function streamClaude(req, onOut) {
+    return new Promise((resolve) => {
+        const keep = Math.max(4096, req.keepBytes ?? STREAM_KEEP_BYTES);
+        let out = "";
+        let err = "";
+        let settled = false;
+        let timedOut = false;
+        // `detached` makes the child a process-group leader, which is the only way
+        // a signal can reach what it spawned. It is NOT "run in the background":
+        // the pipes are still ours and the child is never `unref`d.
+        const proc = spawn(claudeBackend.bin(), [...req.args], { cwd: req.cwd, detached: true, env: { ...process.env, ...claudeBackend.spawnEnv } });
+        /** Signal the whole group, since the tools are grandchildren. A group that
+         *  has already gone throws ESRCH — that is the good case, not an error. */
+        const killGroup = (sig) => {
+            try {
+                if (proc.pid)
+                    process.kill(-proc.pid, sig);
+                else
+                    proc.kill(sig);
+            }
+            catch { /* already gone, or never started */ }
+        };
+        const untrack = trackRun(killGroup); // the halt reaches a run mid-flight (`halt.ts`)
+        /**
+         * A timeout ANSWERS, it does not wait to be let go.
+         *
+         * `close` fires when every pipe is done, which a killed process's own
+         * children can hold open — and this promise is awaited by a durable run
+         * whose row says `running` until it resolves. So the verdict is given at
+         * the deadline, with whatever was printed by then, and the corpse is
+         * chased separately.
+         */
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killGroup("SIGTERM");
+            setTimeout(() => killGroup("SIGKILL"), 2000).unref?.();
+            done(true, new Error(`timed out after ${req.timeoutMs} ms`));
+        }, req.timeoutMs);
+        const done = (failed, error) => {
+            if (settled)
+                return;
+            settled = true;
+            untrack();
+            clearTimeout(timer);
+            resolve({ stdout: out, stderr: err, failed, err: error });
+        };
+        proc.stdout?.setEncoding("utf8");
+        proc.stdout?.on("data", (d) => {
+            // Past the answer, this chunk belongs to a run that has already been
+            // reported — see the header: handing it over is a reading of a settled
+            // run, and keeping it is bytes nobody will read.
+            if (settled)
+                return;
+            // The caller sees everything; what is KEPT is the tail, so a run that
+            // prints 80 MB of tool output still answers with the envelope at the end
+            // of it and this daemon holds a quarter of a megabyte.
+            try {
+                onOut(d);
+            }
+            catch { /* a reader that throws must not kill the run */ }
+            out = (out + d).slice(-keep);
+        });
+        proc.stderr?.setEncoding("utf8");
+        proc.stderr?.on("data", (d) => { if (!settled)
+            err = (err + d).slice(-keep); });
+        proc.on("error", (e) => done(true, e));
+        proc.on("close", (code) => {
+            // A timeout has already answered; anything arriving now is the kill.
+            if (timedOut)
+                return;
+            done(code !== 0, code === 0 ? null : new Error(`exited with code ${code}`));
+        });
+        try {
+            proc.stdin?.end(req.prompt);
+        }
+        catch { /* the error event has it */ }
+    });
+}
+export function envelopeUsage(stdout) {
+    let env;
+    try {
+        const parsed = JSON.parse(stdout);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        env = parsed;
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    const u = env.usage;
+    if (u && typeof u === "object" && !Array.isArray(u)) {
+        const r = u;
+        const fin = (v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null);
+        const inTok = fin(r.input_tokens);
+        const outTok = fin(r.output_tokens);
+        const cacheRead = fin(r.cache_read_input_tokens);
+        const cacheWrite = fin(r.cache_creation_input_tokens);
+        if (inTok != null && outTok != null && cacheRead != null && cacheWrite != null) {
+            out.usage = { inTok, outTok, cacheRead, cacheWrite };
+        }
+    }
+    const usd = env.total_cost_usd;
+    if (typeof usd === "number" && Number.isFinite(usd) && usd >= 0)
+        out.usd = usd;
+    return out;
+}
+/**
+ * Run a task that NEEDS tools, through its route.
+ *
+ * Today every such route is `claude-p` and this is the old call verbatim —
+ * behind one gate: a folder Claude Code does not trust is refused, because a
+ * tool task keeps project settings and `-p` would load its hooks without
+ * asking (`workspaceTrust`). A refusal produces no run at all: empty streams,
+ * `failed`, and the sentence — which the caller surfaces as the row's detail,
+ * because a person who misrouted a knob, or opened a repo nobody trusted, needs
+ * to read that, not "the assessment wrote no file".
+ */
+export async function runToolTask(task, req) {
+    const plan = sidecarPlan(task);
+    if (plan.engine === "refused") {
+        sayOnce(plan.reason);
+        return { stdout: "", stderr: "", failed: true, err: null, refused: plan.reason };
+    }
+    const untrusted = trustRefusal(req.cwd, await workspaceTrust(req.cwd));
+    if (untrusted) {
+        sayOnce(untrusted);
+        return { stdout: "", stderr: "", failed: true, err: null, refused: untrusted };
+    }
+    return runHeadlessClaude(req);
+}
+//# sourceMappingURL=sidecarclaude.js.map

package/packages/host/dist/sidecar/sidecarclaude.js.map

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

package/packages/host/dist/sidecar/sidecarname.d.ts

@@ -0,0 +1,99 @@
+import type { EnvelopeUsage } from "./sidecarclaude.js";
+export interface NameRequest {
+    readonly cwd: string;
+    /** The whole prompt — one batch of items, ids and words, as JSON. */
+    readonly prompt: string;
+    /** The system prompt that replaces Claude Code's own. */
+    readonly system: string;
+    /** The model the claude engine runs on (`WATERPLANE_NAME_MODEL`). */
+    readonly model: string;
+    /** The watchdog, in milliseconds. The caller's: a naming pass is bounded by
+     *  what the person who tapped it is willing to wait, and this module does
+     *  not know that number. */
+    readonly timeoutMs: number;
+    /** `false` ⇒ `--no-session-persistence`: the CLI writes no transcript of this prompt under
+     *  `~/.claude/projects/`. For a caller whose prompt should leave no copy on disk; absent = the
+     *  default, a transcript as every other headless call keeps. The claude engine only. */
+    readonly persist?: false;
+}
+export interface NameRun {
+    /** The model's answer, envelope unwrapped. "" when there is none. */
+    readonly text: string;
+    /** No usable answer came back, for any reason. */
+    readonly failed: boolean;
+    /** The ACCOUNT is out of quota — not an error, and a different sentence. */
+    readonly limited: boolean;
+    /** What went wrong, in words, when anybody knew. */
+    readonly detail?: string;
+    /** Read from the envelope when it carried one; absent otherwise. Never derived. */
+    readonly usage?: EnvelopeUsage;
+    /** `total_cost_usd`, when the envelope carried one. Never derived. */
+    readonly usd?: number;
+    /** Wall clock around the call, which is a fact this end always has. */
+    readonly durationMs: number;
+}
+/**
+ * One batch of backlog items, titled.
+ *
+ * ── The argv (`runTextTask`'s), and every flag is justified ─────────────────
+ *
+ * This argv was first written for the backlog's smart pick (removed
+ * 2026-10-16; its grooming call was `runSmartPickTask`, and this was a verbatim
+ * copy of it). It lives here now, and its measurements with it.
+ *
+ * CLAUDE.md's rule is that a new unattended `claude -p` starts from
+ * `runSummaryTask`'s flags (the tab name's) and justifies every one it DROPS. **This call drops
+ * none of them**, and adds one:
+ *
+ *  • `-p --output-format json` — the envelope is the completion signal, the
+ *    error channel and the only honest cost line (`envelopeUsage`). It is never
+ *    the content: the content is the JSON inside `result`.
+ *  • `--model <req.model>` — the cheapest model that can do the job, exactly as
+ *    the summary does. `WATERPLANE_NAME_MODEL`, defaulted by the caller.
+ *  • `--setting-sources user` — no PROJECT settings, so no repo `CLAUDE.md`.
+ *    This repo's is 12k chars of always-on context, and the question is "what
+ *    should these six sentences be called": the most expensive possible way to
+ *    answer it would be to read the repo's instructions first.
+ *  • `--tools ""` — the items' own words are IN the prompt and there is nothing
+ *    to go and read. It is also the mechanical guarantee behind the rule that
+ *    matters: a naming pass may never touch the repo, and with no tools there
+ *    is nothing to touch it with.
+ *  • `--thinking disabled` — measured (see the table at the flag below): for a
+ *    toolless JSON job over a few sentences, thinking is the whole of what a
+ *    pass costs (a trivial haiku reply measured 548 thinking tokens at
+ *    $0.0049). Titling a sentence is not a problem thinking improves. Asking
+ *    for brevity in the system prompt does not work; it was asked for and the
+ *    tokens were spent anyway — the flag is what actually stops it.
+ *  • `--system-prompt <req.system>` — its own contract, replacing Claude Code's.
+ *
+ * `maxBuffer` is 1 MiB rather than the summary's 4 MiB: the contract is one
+ * small JSON object and anything approaching a megabyte of it is a model that
+ * has lost the plot.
+ *
+ * ── What it does NOT copy from the summary ─────────────────────────────────
+ *
+ * The local branch runs no `tidy()` — the summary's whitespace-squash and
+ * 240-char clip would turn a JSON document into something `JSON.parse` refuses.
+ * No usage is reported for it either: an OpenAI-compatible body carries its
+ * own `usage` shape, `chatCompletion` does not return it, and inventing one
+ * from the prompt's length is the wrong number this seam exists to refuse. The
+ * text comes back exactly as the server wrote it and the caller parses it.
+ *
+ * ── What a failure is ──────────────────────────────────────────────────────
+ *
+ * Text "" and `failed`. Every caller treats that the way every other sidecar
+ * caller treats an empty result: nothing is written, and the rows keep whatever
+ * they were already called.
+ */
+export declare function runNameTask(req: NameRequest): Promise<NameRun>;
+/**
+ * The same call, routed by a DIFFERENT knob — `commit`, for the commit message
+ * a person asks for from the phone (`commitmsg.ts`).
+ *
+ * Deliberately the same function and not a copy: every flag above is a
+ * measurement, and a second headless call with its own hand-written argv is how
+ * one of them quietly stops being true. What differs between the two tasks is
+ * the PROMPT, the model and which variable routes it — all of which are the
+ * caller's, and the routing knob is this argument.
+ */
+export declare function runCommitTask(req: NameRequest): Promise<NameRun>;

package/packages/host/dist/sidecar/sidecarname.js

@@ -0,0 +1,163 @@
+/**
+ * The name slice of `sidecar.ts` — see that file's header for the seam's rules.
+ */
+import { detectHeadlessLimit, limitNote } from "../limit.js";
+import { sayOnce, sidecarPlan } from "./sidecarroute.js";
+import { envelopeUsage, runHeadlessClaude } from "./sidecarclaude.js";
+import { chatCompletion } from "./sidecaropenai.js";
+/**
+ * One batch of backlog items, titled.
+ *
+ * ── The argv (`runTextTask`'s), and every flag is justified ─────────────────
+ *
+ * This argv was first written for the backlog's smart pick (removed
+ * 2026-10-16; its grooming call was `runSmartPickTask`, and this was a verbatim
+ * copy of it). It lives here now, and its measurements with it.
+ *
+ * CLAUDE.md's rule is that a new unattended `claude -p` starts from
+ * `runSummaryTask`'s flags (the tab name's) and justifies every one it DROPS. **This call drops
+ * none of them**, and adds one:
+ *
+ *  • `-p --output-format json` — the envelope is the completion signal, the
+ *    error channel and the only honest cost line (`envelopeUsage`). It is never
+ *    the content: the content is the JSON inside `result`.
+ *  • `--model <req.model>` — the cheapest model that can do the job, exactly as
+ *    the summary does. `WATERPLANE_NAME_MODEL`, defaulted by the caller.
+ *  • `--setting-sources user` — no PROJECT settings, so no repo `CLAUDE.md`.
+ *    This repo's is 12k chars of always-on context, and the question is "what
+ *    should these six sentences be called": the most expensive possible way to
+ *    answer it would be to read the repo's instructions first.
+ *  • `--tools ""` — the items' own words are IN the prompt and there is nothing
+ *    to go and read. It is also the mechanical guarantee behind the rule that
+ *    matters: a naming pass may never touch the repo, and with no tools there
+ *    is nothing to touch it with.
+ *  • `--thinking disabled` — measured (see the table at the flag below): for a
+ *    toolless JSON job over a few sentences, thinking is the whole of what a
+ *    pass costs (a trivial haiku reply measured 548 thinking tokens at
+ *    $0.0049). Titling a sentence is not a problem thinking improves. Asking
+ *    for brevity in the system prompt does not work; it was asked for and the
+ *    tokens were spent anyway — the flag is what actually stops it.
+ *  • `--system-prompt <req.system>` — its own contract, replacing Claude Code's.
+ *
+ * `maxBuffer` is 1 MiB rather than the summary's 4 MiB: the contract is one
+ * small JSON object and anything approaching a megabyte of it is a model that
+ * has lost the plot.
+ *
+ * ── What it does NOT copy from the summary ─────────────────────────────────
+ *
+ * The local branch runs no `tidy()` — the summary's whitespace-squash and
+ * 240-char clip would turn a JSON document into something `JSON.parse` refuses.
+ * No usage is reported for it either: an OpenAI-compatible body carries its
+ * own `usage` shape, `chatCompletion` does not return it, and inventing one
+ * from the prompt's length is the wrong number this seam exists to refuse. The
+ * text comes back exactly as the server wrote it and the caller parses it.
+ *
+ * ── What a failure is ──────────────────────────────────────────────────────
+ *
+ * Text "" and `failed`. Every caller treats that the way every other sidecar
+ * caller treats an empty result: nothing is written, and the rows keep whatever
+ * they were already called.
+ */
+export async function runNameTask(req) {
+    return runTextTask("name", req);
+}
+/**
+ * The same call, routed by a DIFFERENT knob — `commit`, for the commit message
+ * a person asks for from the phone (`commitmsg.ts`).
+ *
+ * Deliberately the same function and not a copy: every flag above is a
+ * measurement, and a second headless call with its own hand-written argv is how
+ * one of them quietly stops being true. What differs between the two tasks is
+ * the PROMPT, the model and which variable routes it — all of which are the
+ * caller's, and the routing knob is this argument.
+ */
+export async function runCommitTask(req) {
+    return runTextTask("commit", req);
+}
+async function runTextTask(task, req) {
+    const started = Date.now();
+    const since = () => Date.now() - started;
+    const plan = sidecarPlan(task);
+    if (plan.engine === "refused") {
+        sayOnce(plan.reason);
+        return { text: "", failed: true, limited: false, detail: plan.reason, durationMs: since() };
+    }
+    if (plan.engine === "openai-compat") {
+        const text = await chatCompletion(plan, { prompt: req.prompt, system: req.system, timeoutMs: req.timeoutMs });
+        return {
+            text,
+            failed: !text,
+            limited: false,
+            detail: text ? undefined : "the local engine answered nothing",
+            durationMs: since(),
+        };
+    }
+    // ── claude engine ────────────────────────────────────────────────────────
+    const run = await runHeadlessClaude({
+        cwd: req.cwd,
+        args: [
+            "-p", "--output-format", "json",
+            "--model", req.model,
+            "--setting-sources", "user",
+            "--tools", "",
+            // ── The measurement that put this flag here ─────────────────────────
+            //
+            // `envelopeUsage`'s header warns that thinking, not input size, is what
+            // a toolless pass is billed for. Measured for the smart pick (the first
+            // caller of this argv, 2026-09) against the installed binary: the SAME
+            // three-item JSON pass, five runs —
+            //
+            //   thinking on   $0.0067 – $0.025, 13 s – 36 s, 1,044 – 3,371 thinking tokens
+            //   --effort low  $0.0155, 28 s, 2,407 thinking tokens (barely moves it)
+            //   this flag     $0.0014, 2.8 s, 0 thinking tokens, identical conclusion
+            //
+            // Twelve times the money and ten times the wall clock, for a job over
+            // six sentences — and a 30 s pass blew a 20 s watchdog on two runs in
+            // three, paying for a completion then thrown away. Asking for it in the
+            // system prompt does not work; it was asked for and 2,644 thinking tokens
+            // were spent anyway.
+            //
+            // Nothing is dropped — CLAUDE.md's rule is about the flags a new
+            // unattended call loses, and this one KEEPS all of `runSummaryTask`'s. It
+            // is added here and not there: a tab name is prose about a conversation
+            // and a review is a judgement about code, and neither is a job where the
+            // thinking is the waste. A `claude` too old to know the flag exits
+            // non-zero, which is `failed` — the same empty result as any failure.
+            "--thinking", "disabled",
+            "--system-prompt", req.system,
+            ...(req.persist === false ? ["--no-session-persistence"] : []),
+        ],
+        prompt: req.prompt,
+        timeoutMs: req.timeoutMs,
+        maxBuffer: 1024 * 1024,
+    });
+    // Asked FIRST, exactly as the summary asks it: an account
+    // block's envelope still parses and still carries a `result` string, and that
+    // string is a quota banner. Reading it as an answer would hand the banner's
+    // words to a parser expecting titles — and count the block as a real pass.
+    const limit = detectHeadlessLimit(run.stdout, run.stderr);
+    const { usage, usd } = envelopeUsage(run.stdout);
+    if (limit.blocked) {
+        // The verb is the TASK's, because this sentence is shown to a person and
+        // "nothing was titled" is not true of a commit message that was not written.
+        return { text: "", failed: false, limited: true, detail: limitNote(limit, task === "commit" ? "written" : "titled"), usage, usd, durationMs: since() };
+    }
+    let text = run.stdout;
+    try {
+        const env = JSON.parse(text);
+        if (env && typeof env.result === "string")
+            text = env.result;
+    }
+    catch { /* raw — a stdout that is not an envelope is still worth a parse attempt downstream */ }
+    text = text.trim();
+    return {
+        text,
+        failed: !text,
+        limited: false,
+        detail: text ? undefined : (run.err?.message || "the model answered nothing"),
+        usage,
+        usd,
+        durationMs: since(),
+    };
+}
+//# sourceMappingURL=sidecarname.js.map

package/packages/host/dist/sidecar/sidecarname.js.map

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

package/packages/host/dist/sidecar/sidecaropenai.d.ts

@@ -0,0 +1,24 @@
+import type { OpenAIRoute } from "./sidecarroute.js";
+/**
+ * The assistant's text out of a `/chat/completions` body — thinking removed.
+ *
+ * Exported because this is the part that a local model can break in four
+ * different ways, and the assertions belong on a pure function rather than on a
+ * live server. Anything it cannot read is "", which every caller here already
+ * treats as "no answer".
+ */
+export declare function completionText(body: unknown): string;
+export interface ChatRequest {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly timeoutMs?: number;
+    readonly maxTokens?: number;
+}
+/**
+ * One completion against an OpenAI-compatible server. No tools, ever.
+ *
+ * Every failure — transport, timeout, non-2xx, unparseable body, empty content
+ * — is "". The caller cannot tell them apart and must not need to: there is one
+ * correct response to all of them, which is to leave what is on screen alone.
+ */
+export declare function chatCompletion(route: OpenAIRoute, req: ChatRequest): Promise<string>;