tumwater 0.4.0 → 0.4.2

package/dist/src/agent/image-input.js

@@ -1,17 +1,14 @@
 /** The seam's answer to "who in this team can read images" (plans/image-input.md
- * "Capability"). One resolver, `seamImageInput`, is the only place that rule lives; the doctor
- * (src/doctor/doctor-model-checks.ts) and the later reroute parts both read it, so the answer
- * is never reached two ways. It lives at runtime level because it needs the backend registry:
- * a claude seam is always capable through the AgentBackend.imageInput hook, a pi seam reads the
- * model's `input` in models.json, and any other backend answers null unless it declares a hook. */
-import { configForRole, roleSeamTier, withModelOverrides } from "../config/config-views.js";
-import { BORROW_ORDER, resolveTierFallbacks } from "../config/config-fallbacks.js";
+ * "Capability"). One resolver, `seamImageInput`, is the only place that rule lives, so the
+ * answer is never reached two ways. It lives at runtime level because it needs the backend
+ * registry: a claude seam is always capable through the AgentBackend.imageInput hook, a pi
+ * seam reads the model's `input` in models.json, and any other backend answers null unless it
+ * declares a hook. */
+import { configForRole } from "../config/config-views.js";
 import { seamAgent } from "../config/model-selector.js";
-import { modelLabel } from "./backend-traits.js";
-import { piModelImageInput, piPairFree, piModelsPath, readPiProviders } from "../pi/pi-models.js";
+import { piModelImageInput, piModelsPath, readPiProviders } from "../pi/pi-models.js";
 import { piListedImageInput } from "../pi/pi-listed-models.js";
 import { backendById } from "./agent-backend.js";
-import { imageProbeEntryFresh, imageProbeKey } from "../doctor/image-probe.js";
 /** One seam's image-input capability (plans/image-input.md "Capability"): `true` when the
  * seam's backend declares image support, `false` when it is text-only, `null` when it cannot
  * be answered from what the team knows (a pair neither models.json nor the pi listing names, a
@@ -21,11 +18,10 @@ import { imageProbeEntryFresh, imageProbeKey } from "../doctor/image-probe.js";
  * the default pi backend leaves it to models.json's `input` field, where absent means text-only
  * (pi's own default for a custom model); a pair absent from models.json answers what
  * `pi --list-models` last said (src/pi/pi-listed-models.ts), else null.
- * `probes` is the doctor's live-probe cache (part 2/5): a claimed pi seam whose probe FAILED
- * reads false — a claim is only as good as the verified
- * answer — while a cached pass (or an unprobed claim) stands on the catalog. claude seams are
- * never probed, so the hook answer is never overridden. */
-export function seamImageInput(seam, providers, probes, listed = null) {
+ * A claim in models.json is trusted without a live probe (the doctor's live probe was
+ * subtracted): a claimed pi seam reads true on the catalog. claude seams are answered by the
+ * hook. */
+export function seamImageInput(seam, providers, listed = null) {
     const backendId = seamAgent(seam);
     const backend = backendById(backendId);
     // A backend with an imageInput hook owns the answer outright (claude: true for every model).
@@ -34,79 +30,14 @@ export function seamImageInput(seam, providers, probes, listed = null) {
     // An unknown backend without a hook has no catalog to consult — unknown, never assume.
     if (backendId !== "pi")
         return null;
-    const base = piModelImageInput(providers, seam.provider, seam.model) ?? piListedImageInput(listed, seam.provider, seam.model);
-    if (base !== true)
-        return base;
-    // A claimed pi seam whose live probe failed (fresh, claim unchanged) reads false. Only pi is
-    // probed, so the probe key carries the pi backend.
-    const entry = probes?.[imageProbeKey(backendId, seam.provider, seam.model)];
-    if (entry?.verdict === "fail" && imageProbeEntryFresh(entry))
-        return false;
-    return true;
+    return piModelImageInput(providers, seam.provider, seam.model) ?? piListedImageInput(listed, seam.provider, seam.model);
 }
-/** The image-capable reroute target for `role`, or null when no peer tier can read images
- * (plans/image-input.md "Reroute target"). Walks the role's seam tier through BORROW_ORDER,
- * skipping the tier itself — small → default → strong, default → strong → small, strong →
- * default (a strong-tier seam never drops to small, the same rule as the budget fallback) —
- * and takes the first tier whose model reads images. `regime` picks the pair set (see
- * RerouteRegime); `modelsPath` and `account` are injectable so tests need no real pi install
- * or account. */
-export function imageReroute(config, role, regime = "primary", modelsPath = piModelsPath(), account = null, probes, providers = null, listed = null) {
-    const tier = roleSeamTier(config, role);
-    const candidates = BORROW_ORDER[tier].filter((t) => t !== tier);
-    if (candidates.length === 0)
-        return null;
-    const providerMap = providers ?? readPiProviders(modelsPath);
-    const capable = (rc) => seamImageInput(rc, providerMap, probes, listed) === true;
-    if (regime === "primary") {
-        for (const t of candidates) {
-            const rc = withModelOverrides(config, t, {});
-            if (capable(rc))
-                return { tier: t, config: rc };
-        }
-        return null;
-    }
-    // Fallback regime: only the tiers' free fallback pairs qualify (resolveTierFallbacks over the
-    // price check), never a priced primary model — a reroute must not spend past the cap.
-    const resolved = resolveTierFallbacks(config, (p) => 
-    // The free-ness lookup reads the one claude account held here (part 2a/9).
-    piPairFree(providerMap, p, (b) => (b === "claude" ? account : null)));
-    for (const t of candidates) {
-        const pair = resolved[t].pair;
-        if (!pair)
-            continue;
-        const rc = withModelOverrides(config, t, {
-            provider: pair.provider,
-            model: pair.model,
-            thinking: pair.thinking,
-        });
-        if (capable(rc))
-            return { tier: t, config: rc };
-    }
-    return null;
-}
-/** The config of imageReroute, for callers that want only the target model. */
-export function imageRerouteTarget(config, role, regime = "primary", modelsPath = piModelsPath(), account = null, probes, providers = null, listed = null) {
-    return imageReroute(config, role, regime, modelsPath, account, probes, providers, listed)?.config ?? null;
-}
-/** A seam's model as one readable token, the same label the doctor's `image input` check uses
- * (`claude/<id>` for a claude seam, `provider/model` for pi). The one home of the label, so
- * the surface strings (the images alert, the role page, the status rows) and the doctor report
- * cannot drift, and delegates to backend-traits' modelLabel. */
-export function seamImageLabel(backend, provider, model) {
-    return modelLabel(backend, provider, model);
-}
-/** Compute RoleImageInfo for one role. `modelsPath` and `probes` are injectable; the providers
- * catalog is read (stat-cached) here and also handed to imageReroute so a poll that asks many
- * roles still parses the catalog once. All reads mirror the doctor's `image input` check, so
- * the surface and the check agree about capability. */
-export function roleImageInfo(config, role, modelsPath = piModelsPath(), probes, listed = null) {
+/** Compute RoleImageInfo for one role. `modelsPath` and `listed` are injectable; the providers
+ * catalog is read (stat-cached) here. The reroute field is a literal null — the peer-tier image
+ * reroute was subtracted (part 5g/6), so no role names a reroute target; 5h removes the field. */
+export function roleImageInfo(config, role, modelsPath = piModelsPath(), listed = null) {
     const providers = readPiProviders(modelsPath);
     const rc = configForRole(config, role);
-    const imageInput = seamImageInput(rc, providers, probes, listed);
-    const rr = imageReroute(config, role, "primary", modelsPath, null, probes, providers, listed);
-    const imageRerouteStr = rr
-        ? `${rr.tier} (${seamImageLabel(rr.config.agent, rr.config.provider, rr.config.model)})`
-        : null;
-    return { imageInput, imageReroute: imageRerouteStr };
+    const imageInput = seamImageInput(rc, providers, listed);
+    return { imageInput, imageReroute: null };
 }

package/dist/src/agent/notes-shim.js

@@ -1,5 +1,5 @@
 /** Installing the per-team `tumwater-notes` shim every backend's run finds on its PATH
- * (plans/notes-command.md "Reaching it from a run"): run-agent calls `ensureNotesShim(root)`
+ * (plans/notes-command.md "Reaching it from a run"): run-spawn calls `ensureNotesShim(root)`
  * before building each invocation, and the backend prepends the returned dir to the run's
  * PATH (backendBaseEnv's `binDir`, src/process/run-marker.ts). The shim is a two-line `sh`
  * script that execs the compiled notes CLI, so a model's shell — pi's, Claude Code's or
@@ -20,7 +20,7 @@ export const NOTES_SHIM_NAME = "tumwater-notes";
 /** Install the `tumwater-notes` shim under `<root>/.tumwater/bin` and return that directory.
  * The shim is written atomically with mode 0755, only when its content differs from what is
  * already there (a redeploy that changes `<dist>` rewrites it). Never throws: a failure to
- * write is the caller's to absorb — run-agent logs one warning and runs without the shim. */
+ * write is the caller's to absorb — run-spawn logs one warning and runs without the shim. */
 export function ensureNotesShim(root, execPath = process.execPath) {
     const dir = notesShimDir(root);
     const target = path.join(dir, NOTES_SHIM_NAME);

package/dist/src/agent/opencode/opencode-backend.js

@@ -1,8 +1,8 @@
 /** The opencode adapter for the agent seam (plans/opencode-backend.md "The invocation",
  * "Sessions", §6). It shapes one run's argv/stdin/env, translates opencode's `run --format
  * json` into the canonical stream, runs the authoritative session export after the process
- * exits, and classifies the exit's stderr — everything backend-specific. src/agent/run-agent.ts
- * owns the spawn and records this run in the session ledger; opencode mints its own session id
+ * exits, and classifies the exit's stderr — everything backend-specific. src/agent/run-spawn.ts
+ * spawns the run and records this run in the session ledger; opencode mints its own session id
  * (a `ses_…` id, or the resumed record's id), which `invocation` returns so the ledger can
  * carry it.
  *

package/dist/src/agent/opencode/opencode-catalog.js

@@ -4,8 +4,8 @@
  * `.tumwater/state/opencode-models.json` that survives a failed fetch, and
  * `opencodeModelFree` as the one predicate part 6b/7's seam reads. No seam is wired here: that
  * is part 6b/7 (the budget gate), part 6c/7 (a billedAt demotion on an observed cost) and
- * part 7/7 (a startup-cache seed and doctor), so this module's only callers today are its own
- * tests. */
+ * part 7/7 (a startup-cache seed and doctor), so this module only publishes the data and
+ * predicates those seam consumers read. */
 import { spawnSync } from "node:child_process";
 import { isJsonObject, validEntries } from "../../files/json-object.js";
 import { readJsonFile, writeJsonAtomic } from "../../files/json-files.js";

package/dist/src/agent/opencode/opencode-config.js

@@ -18,7 +18,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { readTextOrNull } from "../../files/files.js";
+import { readTextOrNull, xdgConfigHomeDir } from "../../files/files.js";
 import { isJsonObject } from "../../files/json-object.js";
 /** The operator's global opencode config lives in `$XDG_CONFIG_HOME/opencode/` (or
  * `~/.config/opencode/`), in `config.json`, `opencode.json` or `opencode.jsonc`. */
@@ -123,7 +123,7 @@ function stripJsonc(src) {
  * parse; doctor reports a broken one in part 7/7. `homeDir` is the operator's home directory;
  * the process's own `XDG_CONFIG_HOME` env, when set, wins over `~/.config` (the XDG default). */
 export function operatorMcpNames(env, homeDir) {
-    const configHome = env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
+    const configHome = xdgConfigHomeDir(env, homeDir);
     const dir = path.join(configHome, "opencode");
     for (const file of OPERATOR_CONFIG_FILES) {
         const text = readTextOrNull(path.join(dir, file));

package/dist/src/agent/opencode/opencode-stream.js

@@ -16,6 +16,7 @@
  * `opencode_free_tier_refused` is added there once when any step was refused. `--thinking` is
  * never passed, so no `reasoning` event appears; the mapping below still recognizes one so a
  * future `--thinking` run degrades gracefully. */
+import { transientProseKind } from "../backend-traits.js";
 import { canonicalUsageBlock, isJsonObject, nonNegativeNumber, objectOrEmpty, parseJsonObject } from "../../files/json-object.js";
 /** opencode's tool names → the canonical pi names the readers already know. `shell`→`bash` and
  * `patch`→`edit` (pi has one edit tool); anything else is lower-cased so a future tool still
@@ -66,10 +67,9 @@ function classifyError(err) {
     // Transient server, connection and timeout failures.
     if (/\b(500|501|502|503|504|529)\b|internal server error|bad gateway|service unavailable|gateway timeout|overloaded/i.test(message))
         return { kind: "transientBackend", backendKind: "server" };
-    if (/connection|econn|refused|reset|terminated/i.test(message))
-        return { kind: "transientBackend", backendKind: "connection" };
-    if (/timed out|timeout/i.test(message))
-        return { kind: "transientBackend", backendKind: "timeout" };
+    const prose = transientProseKind(message);
+    if (prose)
+        return prose;
     return {};
 }
 /** The step's token counts and cost → pi's canonical usage block: the four counts, their sum
@@ -117,14 +117,7 @@ export function opencodeTranslator(opts = {}) {
         }
         return out;
     };
-    const translate = (line) => {
-        const parsed = parseJsonObject(line);
-        if (!parsed) {
-            // A malformed / non-JSON line on stdout is skipped with one warning for the run.
-            record("malformed");
-            return [];
-        }
-        const event = parsed;
+    const announceSession = (event) => {
         // The first event with a non-empty `sessionID` announces the session and the agent start.
         // An error raised before a session exists has `sessionID: ""` (or none) and emits neither.
         let out = [];
@@ -140,92 +133,108 @@ export function opencodeTranslator(opts = {}) {
                 out.push(JSON.stringify({ type: "agent_start" }));
             }
         }
+        return out;
+    };
+    const handleStepStart = () => {
+        step = { content: [], calls: [] };
+        return [];
+    };
+    const handleText = (event) => {
+        // A content block with no open buffer opens one: `step_start` is sometimes missing, and
+        // edit-run.jsonl's final `text` lands after its last `step_finish`, so a block dropped
+        // for want of a buffer would lose the run's last turn.
+        step ??= { content: [], calls: [] };
+        step.content.push({ type: "text", text: objectOrEmpty(event.part).text ?? "" });
+        return [];
+    };
+    const handleReasoning = (event) => {
+        step ??= { content: [], calls: [] };
+        const thinking = objectOrEmpty(event.part).text ?? "";
+        step.content.push({ type: "thinking", thinking: typeof thinking === "string" ? thinking : "" });
+        return [];
+    };
+    const handleToolUse = (event) => {
+        // As above, a tool reported with no open buffer opens one.
+        step ??= { content: [], calls: [] };
+        const partValue = objectOrEmpty(event.part);
+        const state = objectOrEmpty(partValue.state);
+        const input = objectOrEmpty(state.input);
+        // `arguments` is the tool's `input` plus a `path` alias of `filePath` —
+        // describeToolCall reads either.
+        const args = { ...input };
+        if (typeof input.filePath === "string")
+            args.path = input.filePath;
+        // V2 2.0.32 emits the native tool name in `part.tool` (not `part.name`); the live
+        // captures agree.
+        const name = typeof partValue.tool === "string" ? partValue.tool : "";
+        // Own-property test, not a bare index: a tool name like `constructor` or
+        // `__proto__` would otherwise inherit a function from the table's prototype chain and
+        // bypass the lower-cased fallback (the same guard claude-stream.ts applies).
+        const canonicalName = Object.hasOwn(TOOL_NAMES, name) ? (TOOL_NAMES[name] ?? name.toLowerCase()) : name.toLowerCase();
+        const id = typeof partValue.id === "string" ? partValue.id : "";
+        step.content.push({ type: "toolCall", id, name: canonicalName, arguments: args });
+        step.calls.push({ id, name: canonicalName, args, isError: state.status === "error" });
+        return [];
+    };
+    const handleStepFinish = (event) => {
+        if (!step)
+            return [];
+        const part = objectOrEmpty(event.part);
+        const tokens = objectOrEmpty(part.tokens);
+        const cache = objectOrEmpty(tokens.cache);
+        step.usage = canonicalUsage({
+            input: tokens.input,
+            output: tokens.output,
+            cache: { read: cache.read, write: cache.write },
+        }, nonNegativeNumber(part.cost, 0));
+        return flush(true);
+    };
+    const handleError = (event) => {
+        // Errors carry their payload in `event.error` (`{type, message, status?, response?}`,
+        // plan finding 8); classification reads type first, message second.
+        const err = objectOrEmpty(event.error);
+        const cls = classifyError(err);
+        if (cls.freeTier)
+            sawFreeTier = true;
+        const message = typeof err.message === "string" ? err.message : "";
+        // The open step (if any) is cut off by the error and flushed without usage first.
+        const out = flush(false);
+        const m = { role: "assistant", content: [], stopReason: "error" };
+        if (message !== "")
+            m.errorMessage = message;
+        // tumwaterKind/backendKind ride the canonical EVENT (not its message): the parser
+        // reads event.tumwaterKind and trusts it before its text regexes.
+        out.push(JSON.stringify({
+            type: "message_end",
+            message: m,
+            ...(cls.kind !== undefined ? { tumwaterKind: cls.kind } : {}),
+            ...(cls.backendKind !== undefined ? { backendKind: cls.backendKind } : {}),
+            ...(cls.retryAfterSeconds !== undefined ? { retryAfterSeconds: cls.retryAfterSeconds } : {}),
+        }));
+        return out;
+    };
+    const translate = (line) => {
+        const parsed = parseJsonObject(line);
+        if (!parsed) {
+            // A malformed / non-JSON line on stdout is skipped with one warning for the run.
+            record("malformed");
+            return [];
+        }
+        const event = parsed;
+        const out = announceSession(event);
         const type = event.type;
         switch (type) {
-            case "step_start":
-                step = { content: [], calls: [] };
-                break;
-            case "text": {
-                // A content block with no open buffer opens one: `step_start` is sometimes missing, and
-                // edit-run.jsonl's final `text` lands after its last `step_finish`, so a block dropped
-                // for want of a buffer would lose the run's last turn.
-                step ??= { content: [], calls: [] };
-                step.content.push({ type: "text", text: objectOrEmpty(event.part).text ?? "" });
-                break;
-            }
-            case "reasoning": {
-                step ??= { content: [], calls: [] };
-                const thinking = objectOrEmpty(event.part).text ?? "";
-                step.content.push({ type: "thinking", thinking: typeof thinking === "string" ? thinking : "" });
-                break;
-            }
-            case "tool_use": {
-                // As above, a tool reported with no open buffer opens one.
-                step ??= { content: [], calls: [] };
-                const partValue = objectOrEmpty(event.part);
-                const state = objectOrEmpty(partValue.state);
-                const input = objectOrEmpty(state.input);
-                // `arguments` is the tool's `input` plus a `path` alias of `filePath` —
-                // describeToolCall reads either.
-                const args = { ...input };
-                if (typeof input.filePath === "string")
-                    args.path = input.filePath;
-                // V2 2.0.32 emits the native tool name in `part.tool` (not `part.name`); the live
-                // captures agree.
-                const name = typeof partValue.tool === "string" ? partValue.tool : "";
-                // Own-property test, not a bare index: a tool name like `constructor` or
-                // `__proto__` would otherwise inherit a function from the table's prototype chain and
-                // bypass the lower-cased fallback (the same guard claude-stream.ts applies).
-                const canonicalName = Object.hasOwn(TOOL_NAMES, name) ? (TOOL_NAMES[name] ?? name.toLowerCase()) : name.toLowerCase();
-                const id = typeof partValue.id === "string" ? partValue.id : "";
-                step.content.push({ type: "toolCall", id, name: canonicalName, arguments: args });
-                step.calls.push({ id, name: canonicalName, args, isError: state.status === "error" });
-                break;
-            }
-            case "step_finish": {
-                if (!step)
-                    break;
-                const part = objectOrEmpty(event.part);
-                const tokens = objectOrEmpty(part.tokens);
-                const cache = objectOrEmpty(tokens.cache);
-                step.usage = canonicalUsage({
-                    input: tokens.input,
-                    output: tokens.output,
-                    cache: { read: cache.read, write: cache.write },
-                }, nonNegativeNumber(part.cost, 0));
-                out.push(...flush(true));
-                break;
-            }
-            case "error": {
-                // Errors carry their payload in `event.error` (`{type, message, status?, response?}`,
-                // plan finding 8); classification reads type first, message second.
-                const err = objectOrEmpty(event.error);
-                const cls = classifyError(err);
-                if (cls.freeTier)
-                    sawFreeTier = true;
-                const message = typeof err.message === "string" ? err.message : "";
-                // The open step (if any) is cut off by the error and flushed without usage first.
-                out.push(...flush(false));
-                const m = { role: "assistant", content: [], stopReason: "error" };
-                if (message !== "")
-                    m.errorMessage = message;
-                // tumwaterKind/backendKind ride the canonical EVENT (not its message): the parser
-                // reads event.tumwaterKind and trusts it before its text regexes.
-                out.push(JSON.stringify({
-                    type: "message_end",
-                    message: m,
-                    ...(cls.kind !== undefined ? { tumwaterKind: cls.kind } : {}),
-                    ...(cls.backendKind !== undefined ? { backendKind: cls.backendKind } : {}),
-                    ...(cls.retryAfterSeconds !== undefined ? { retryAfterSeconds: cls.retryAfterSeconds } : {}),
-                }));
-                break;
-            }
+            case "step_start": return [...out, ...handleStepStart()];
+            case "text": return [...out, ...handleText(event)];
+            case "reasoning": return [...out, ...handleReasoning(event)];
+            case "tool_use": return [...out, ...handleToolUse(event)];
+            case "step_finish": return [...out, ...handleStepFinish(event)];
+            case "error": return [...out, ...handleError(event)];
             default:
                 // Record the unknown type ("" for a type-less line), once, in first-seen order.
                 record(typeof type === "string" ? type : "unknown");
-                break;
+                return out;
         }
-        return out;
     };
     return {
         translate,