tumwater 0.1.2 → 0.2.0

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

@@ -16,32 +16,47 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 import { resolvedAgentConfig } from "../../config/config-views.js";
 import { MODEL_TIERS } from "../../config/config-schema.js";
 import { routeModel } from "../../config/model-selector.js";
-import { agentBaseEnv } from "../../process/run-marker.js";
+import { agentBaseEnv, withNotesPath } from "../../process/run-marker.js";
 import { resolveBackendBin } from "../../pi/pi-bin.js";
+import { expandHomeTilde } from "../../files/files.js";
 import { claudeArgs } from "./claude-args.js";
 import { claudeEnv, claudeThirdPartyProvider } from "./claude-env.js";
 import { claudeTranslator } from "./claude-stream.js";
 import { resumableSession } from "../session-ledger.js";
-/** claude's per-cwd project directory name under `~/.claude/projects/`: every character that
- * is not a letter or digit becomes `-`. Exported with `claudeTranscriptPath` so the PATH fake
- * and the tests create and look for exactly the file the resume check reads. */
+/** claude's per-cwd project directory name under the claude config dir's `projects/`:
+ * every character that is not a letter or digit becomes `-`. Exported with
+ * `claudeTranscriptPath` so the PATH fake and the tests create and look for exactly the file
+ * the resume check reads. */
 export function claudeProjectSlug(cwd) {
     return cwd.replace(/[^A-Za-z0-9]/g, "-");
 }
+/** claude's config directory: `$CLAUDE_CONFIG_DIR` when non-empty (a leading `~` expands
+ * against the home dir), else `~/.claude`. A configured team `configDir` (the expanded
+ * `backends.claude.configDir`) wins over any inherited env var — the team's own directory is
+ * never overridden by the operator's shell. This mirrors claude's own lookup and pi's
+ * `piAgentDir`; exported so doctor reads the same dir the adapter writes transcripts into. */
+export function claudeConfigDir(env = process.env, homeDir = os.homedir(), configured) {
+    if (configured)
+        return expandHomeTilde(configured, homeDir);
+    const dir = env.CLAUDE_CONFIG_DIR;
+    if (!dir)
+        return path.join(homeDir, ".claude");
+    return expandHomeTilde(dir, homeDir);
+}
 /** The transcript file claude writes for a session started in `cwd`: its resume check must find
  * a real file before passing `--resume`. claude's own layout is
- * `~/.claude/projects/<slug>/<sessionId>.jsonl`; exported so the fake and the resume logic
- * cannot drift. */
-export function claudeTranscriptPath(cwd, id) {
-    return path.join(os.homedir(), ".claude", "projects", claudeProjectSlug(cwd), `${id}.jsonl`);
+ * `<config>/projects/<slug>/<sessionId>.jsonl`; exported so the fake and the resume logic
+ * cannot drift. `configDir` is the configured team dir, threaded through so the resume check
+ * looks where the run's own env will write. */
+export function claudeTranscriptPath(cwd, id, env = process.env, homeDir = os.homedir(), configDir) {
+    return path.join(claudeConfigDir(env, homeDir, configDir), "projects", claudeProjectSlug(cwd), `${id}.jsonl`);
 }
 /** The CLI version every gated claude model needs (plans/agent-backends.md finding 9): on
- * 2.1.216 Opus 5.5 is refused outright and Haiku 5.5 is mispriced about 250×, and fleet runs
+ * 2.1.216 Opus 5.5 is refused outright and Haiku 5.5 is mispriced about 250×, and team runs
  * set DISABLE_AUTOUPDATER so they never update themselves. The gated models are the three
  * tier defaults, derived from AGENT_DEFAULT_MODELS through the same routing the config uses
  * rather than listed again, so this table cannot drift from the models a seam resolves. */
@@ -65,37 +80,27 @@ function classifyClaudeExit(info) {
     }
     return {};
 }
-/** The inline `--mcp-config` JSON that runs the bundled role-notes server (part 5/7): the
- * same dist module pi's extension resolves to, spawned by the same node running this harness
- * so it needs no PATH lookup. */
-function roleNotesMcpConfig() {
-    const server = fileURLToPath(new URL("../mcp/role-notes-server.js", import.meta.url));
-    return JSON.stringify({ mcpServers: { tumwater: { command: process.execPath, args: [server] } } });
-}
 /** The ledger record this run may resume, or null: the newest record of `opts.kind` for
  * claude, at `opts.cwd` when one is given, whose transcript file exists. Shared by
  * `resolveClaudeSession` and the backend's `resumable` hook, so the resume guard and the
  * invocation can never drift on what counts as resumable. */
-function claudeResumableRecord(dir, opts) {
+function claudeResumableRecord(dir, opts, configDir) {
     const record = resumableSession(dir, opts);
     if (record === null)
         return null;
     if (opts.cwd !== undefined && record.cwd !== opts.cwd)
         return null;
-    if (!fs.existsSync(claudeTranscriptPath(record.cwd, record.id)))
+    if (!fs.existsSync(claudeTranscriptPath(record.cwd, record.id, process.env, os.homedir(), configDir)))
         return null;
     return record;
 }
 /** The session id this run uses: for a continue, the ledger's newest record of this kind when
  * it is claude's, this cwd's, and its transcript file exists; otherwise a fresh UUID. Returns
- * the id and the `--resume` id when resuming. */
-function resolveClaudeSession(run) {
+ * the id and the `--resume` id when resuming. `configDir` is the configured team dir, so the
+ * resume check looks where the run's own env will write transcripts. */
+function resolveClaudeSession(run, configDir) {
     if (run.continueSession) {
-        const record = claudeResumableRecord(run.sessionDir, {
-            kind: run.kind,
-            agent: "claude",
-            cwd: run.cwd,
-        });
+        const record = claudeResumableRecord(run.sessionDir, { kind: run.kind, agent: "claude", cwd: run.cwd }, configDir);
         if (record !== null)
             return { sessionId: record.id, resumeSessionId: record.id };
     }
@@ -117,35 +122,35 @@ export const claudeBackend = {
         if (run.config.model === undefined) {
             throw new Error("claude backend: no model resolved for this run");
         }
-        const { sessionId, resumeSessionId } = resolveClaudeSession(run);
+        // The configured team config dir (plans/notes-command.md "Keeping funes out of team runs"):
+        // the run's env, its resume lookup, and the account seed all follow it; unset, nothing changes.
+        const claudeCfg = resolvedAgentConfig(run.config, "claude");
+        const configDir = claudeCfg.configDir;
+        const expandedConfigDir = configDir !== undefined ? claudeConfigDir(process.env, os.homedir(), configDir) : undefined;
+        const { sessionId, resumeSessionId } = resolveClaudeSession(run, configDir);
         const { args, stdin } = claudeArgs({
             cwd: run.cwd,
             model: run.config.model,
             thinking: run.config.thinking,
             ...(resumeSessionId !== undefined ? { resumeSessionId } : { sessionId }),
-            // The operator's `agents.claude.args` passthrough, appended after the harness flags (the
+            // The operator's `backends.claude.args` passthrough, appended after the harness flags (the
             // builder rejects any entry that repeats a harness-managed flag). resolvedAgentConfig
             // owns the view so a caller cannot mutate the loaded config through the returned array.
-            args: resolvedAgentConfig(run.config, "claude").args,
+            args: claudeCfg.args,
             prompt: run.prompt,
             // The caller computes the remaining daily budget for an API-billed claude run and the
             // adapter forwards it; a subscription run or the director passes none (part 7a/7).
             ...(run.maxBudgetUsd !== undefined ? { maxBudgetUsd: run.maxBudgetUsd } : {}),
-            // claude does not load the bundled pi extensions, so a run carrying a notebook gets the
-            // role_notes MCP server instead. Passed on EVERY claude invocation that carries a
-            // notebook — fresh or resumed, a transient retry, a SUMMARY follow-up — because claude
-            // keeps no flags across --resume, so a resume without this would lose the tool.
-            ...(run.notesPath !== undefined ? { mcpConfig: roleNotesMcpConfig() } : {}),
         });
         // agentBaseEnv applies the run marker and the macOS preload (shared with the pi adapter);
         // claudeEnv layers the backend's own scrub-and-set on top. The notebook path rides beside
-        // the marker the same way pi's adapter carries it (pi-backend.ts withNotesPath), so the
-        // spawned MCP server — which inherits this environment — reads the same notes file.
-        const base = run.notesPath === undefined
-            ? agentBaseEnv(run.runMarker)
-            : { ...agentBaseEnv(run.runMarker), TUMWATER_NOTES_PATH: run.notesPath };
+        // the marker the same way pi's adapter carries it (withNotesPath); from part 2/4 the run
+        // saves its note through the `tumwater-notes` command on PATH, so no MCP server reaches the
+        // run and `--strict-mcp-config` (always in claude-args.ts) keeps it that way.
+        const base = withNotesPath(agentBaseEnv(run.runMarker, undefined, run.binDir), run.notesPath);
         const env = claudeEnv(base, {
             quietTimeoutSeconds: run.config.quietTimeoutSeconds,
+            ...(expandedConfigDir !== undefined ? { configDir: expandedConfigDir } : {}),
         });
         return { args, stdin, env, sessionId };
     },
@@ -155,8 +160,13 @@ export const claudeBackend = {
         // seed the account file, so both must classify it the same way.
         return claudeTranslator({ thirdPartyProvider: claudeThirdPartyProvider(process.env) });
     },
-    resumable(dir, opts) {
-        return claudeResumableRecord(dir, opts) !== null;
+    resumable(dir, opts, configDir) {
+        return claudeResumableRecord(dir, opts, configDir) !== null;
+    },
+    // Every Claude model reads images (Claude Code's Read tool returns them as image blocks), so
+    // a claude seam is always capable — the doctor probes nothing and never works around it.
+    imageInput() {
+        return true;
     },
     classifyExit: classifyClaudeExit,
 };

package/dist/src/agent/claude/claude-env.js

@@ -1,8 +1,7 @@
 /** Building the environment for one claude run (plans/agent-backends.md "The claude
  * invocation", "Findings" 2 and 4) — pure scrub-and-set over a base environment, with no
  * subprocess. The caller layers the run-marker, the macOS LaunchServices preload, and the
- * notebook on first (src/pi/pi-backend.ts's `withNotesPath` shows the pi adapter doing the
- * same), then hands the result here.
+ * notebook on first (src/process/run-marker.ts's `withNotesPath`), then hands the result here.
  *
  * Inherited Claude Code session variables break auth: spawned from inside a Claude Code
  * session, a child that keeps `CLAUDECODE`, `CLAUDE_CODE_*`, `CLAUDE_AGENT_SDK_*` or the host's
@@ -13,7 +12,7 @@
  *
  * The set half disables auto-memory, backgrounded Bash tasks (finding 4: claude refuses a long
  * foreground command, backgrounds it, and abandons it when `-p` ends, which would report work
- * never verified), the auto-updater (a mid-fleet self-update must not swap the binary under a
+ * never verified), the auto-updater (a mid-team self-update must not swap the binary under a
  * run), telemetry, and error reporting; and raises the Bash timeouts so a slow suite runs in
  * the foreground. `BASH_MAX_TIMEOUT_MS` is derived from `quietTimeoutSeconds` so claude's own
  * Bash timeout fires before tumwater's quiet kill and the model sees a tool error rather than a
@@ -80,5 +79,10 @@ export function claudeEnv(base, opts) {
     env.DISABLE_AUTOUPDATER = "1";
     env.DISABLE_TELEMETRY = "1";
     env.DISABLE_ERROR_REPORTING = "1";
+    // A team config dir (plans/notes-command.md "Keeping funes out of team runs"): force claude's
+    // own config and transcripts under it, so a funes hook on ~/.claude/projects never indexes
+    // team runs. Unset leaves any inherited CLAUDE_CONFIG_DIR (or claude's default) untouched.
+    if (opts.configDir)
+        env.CLAUDE_CONFIG_DIR = opts.configDir;
     return env;
 }

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

@@ -14,7 +14,7 @@
  * on the seam's optional `warnings()` — src/agent/run-agent.ts forwards each as an
  * `agent_unknown_event` warning after the run. `cost_unknown` is recorded the same way when a
  * run produced no authoritative `run_cost`. */
-import { isJsonObject, objectOrEmpty, nonNegativeNumber, parseJsonObject } from "../../files/json-object.js";
+import { canonicalUsageBlock, isJsonObject, objectOrEmpty, nonNegativeNumber, parseJsonObject } from "../../files/json-object.js";
 /** claude's tool names → the canonical pi names the readers already know. Glob/Grep are kept
  * lower-cased; MultiEdit collapses onto edit (pi has one edit tool). Anything else is
  * lower-cased so a future tool still reads as a name rather than as `undefined`. */
@@ -37,20 +37,10 @@ function str(value) {
 }
 /** claude's usage block → pi's canonical usage block, with `cost.total` 0 because the run's
  * authoritative cost rides the final `run_cost` event (a split-block message repeats its usage
- * on every event, so summing per event would double-count — the fold takes it once). */
+ * on every event, so summing per event would double-count — the fold takes it once). The
+ * wire-field reads stay here; the block's assembly is the shared canonicalUsageBlock. */
 function canonicalUsage(usage) {
-    const input = nonNegativeNumber(usage?.input_tokens, 0);
-    const cacheRead = nonNegativeNumber(usage?.cache_read_input_tokens, 0);
-    const cacheWrite = nonNegativeNumber(usage?.cache_creation_input_tokens, 0);
-    const output = nonNegativeNumber(usage?.output_tokens, 0);
-    return {
-        input,
-        cacheRead,
-        cacheWrite,
-        output,
-        totalTokens: input + cacheRead + cacheWrite + output,
-        cost: { total: 0 },
-    };
+    return canonicalUsageBlock(nonNegativeNumber(usage?.input_tokens, 0), nonNegativeNumber(usage?.cache_read_input_tokens, 0), nonNegativeNumber(usage?.cache_creation_input_tokens, 0), nonNegativeNumber(usage?.output_tokens, 0), 0);
 }
 /** One claude content block → one pi content block, or undefined for a block pi has no
  * vocabulary for (dropped, like any other unmapped native shape). `tool_use` becomes pi's
@@ -76,7 +66,7 @@ function canonicalBlock(block) {
             return {
                 type: "toolCall",
                 id: str(block.id) ?? "",
-                name: Object.hasOwn(TOOL_NAMES, name) ? TOOL_NAMES[name] : name.toLowerCase(),
+                name: Object.hasOwn(TOOL_NAMES, name) ? (TOOL_NAMES[name]) : name.toLowerCase(),
                 arguments: args,
             };
         }
@@ -347,7 +337,8 @@ export function claudeTranslator(opts = {}) {
                 return out;
             }
             case "tool_progress":
-                // A 30 s heartbeat of a running tool call: known, and the open call already tracks liveness.
+                // A 30 s heartbeat of a running tool call: known, and the open call already tracks
+                // liveness.
                 return [];
             default:
                 record(type ?? "unknown");

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

@@ -0,0 +1,107 @@
+/** 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";
+import { seamAgent } from "../config/model-selector.js";
+import { modelLabel } from "./backend-traits.js";
+import { piModelImageInput, piPairFree, piModelsPath, readPiProviders } from "../pi/pi-models.js";
+import { agentBackend } 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 (an unknown pair, a backend with no hook and no
+ * catalog entry — the doctor's `tier models` check already fails such pairs).
+ *
+ * The backend bookends: a backend with an `imageInput` hook (claude → true) owns the answer;
+ * 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). `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) {
+    const agent = seamAgent(seam);
+    const backend = agentBackend(agent);
+    // A backend with an imageInput hook owns the answer outright (claude: true for every model).
+    if (backend?.imageInput !== undefined)
+        return backend.imageInput(seam.model);
+    // An unknown backend without a hook has no catalog to consult — unknown, never assume.
+    if (agent !== "pi")
+        return null;
+    const base = piModelImageInput(providers, 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 agent.
+    const entry = probes?.[imageProbeKey(agent, seam.provider, seam.model)];
+    if (entry?.verdict === "fail" && imageProbeEntryFresh(entry))
+        return false;
+    return true;
+}
+/** 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) {
+    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) === 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) => piPairFree(providerMap, p.provider, p.model, account));
+    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) {
+    return imageReroute(config, role, regime, modelsPath, account, probes, providers)?.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(agent, provider, model) {
+    return modelLabel(agent, provider, model);
+}
+/** Compute RoleImageInfo for one loop. `modelsPath` and `probes` are injectable; the providers
+ * catalog is read (stat-cached) here and also handed to imageReroute so a poll that asks many
+ * loops 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) {
+    const providers = readPiProviders(modelsPath);
+    const rc = configForRole(config, role);
+    const imageInput = seamImageInput(rc, providers, probes);
+    const rr = imageReroute(config, role, "primary", modelsPath, null, probes, providers);
+    const imageRerouteStr = rr
+        ? `${rr.tier} (${seamImageLabel(rr.config.agent, rr.config.provider, rr.config.model)})`
+        : null;
+    return { imageInput, imageReroute: imageRerouteStr };
+}

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

@@ -0,0 +1,41 @@
+// vocabulary: plain
+/** 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)`
+ * before building each invocation, and the backend prepends the returned dir to the run's
+ * PATH (agentBaseEnv'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
+ * OpenCode's — runs the same command on every backend.
+ *
+ * The `<dist>` in the exec path is the shared distDir (src/build/build-info.ts), derived from
+ * this module's own location so a staged build (.tumwater/build/<sha>) points its shim at its
+ * own copy rather than the installed package's. The script is written
+ * atomically and made executable, only when its content differs, so a redeploy re-points it
+ * without churning the file. */
+import fs from "node:fs";
+import path from "node:path";
+import { distDir } from "../build/build-info.js";
+import { writeTextAtomic } from "../files/files.js";
+import { notesShimDir } from "../paths.js";
+/** The shim's file name — the command name every run sees on its PATH. */
+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. */
+export function ensureNotesShim(root) {
+    const dir = notesShimDir(root);
+    const target = path.join(dir, NOTES_SHIM_NAME);
+    const content = `#!/bin/sh\nexec "${process.execPath}" "${path.join(distDir(), "src", "notes-cli.js")}" "$@"\n`;
+    let needsWrite = true;
+    try {
+        needsWrite = fs.readFileSync(target, "utf8") !== content;
+    }
+    catch {
+        // Absent or unreadable — write it.
+    }
+    if (needsWrite) {
+        writeTextAtomic(target, content);
+    }
+    fs.chmodSync(target, 0o755);
+    return dir;
+}

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

@@ -0,0 +1,61 @@
+// vocabulary: plain
+/** Building one OpenCode run's command line (plans/opencode-backend.md "The invocation") —
+ * pure argv construction plus the prompt-on-stdin pairing, with no subprocess, backend
+ * registration, or session database. Part 5/7 wires this into the adapter; this module turns
+ * its inputs (the resolved model, the catalog's variant, the session choice, the session
+ * name, and the configured passthrough args) into the invocation's argv and stdin.
+ *
+ * The environment is built separately (opencode-env.ts) so each concern has one module.
+ *
+ * `.args` passthrough: a passthrough arg equal to a flag the harness itself sets would be
+ * appended AFTER the harness's own copy and OpenCode's parser is last-wins, so it would
+ * silently override the resolved model, the session choice, or the isolation flags. Each is
+ * rejected by opencodeArgs with the offending arg named, matching the same rejection in
+ * claudeArgs and the reserved set from plans/opencode-backend.md "Config and routing". */
+/** Flags the harness invocation sets. A passthrough arg equal to one of these is rejected by
+ * opencodeArgs with the offending arg named, so an operator's `backends.opencode.args` can
+ * never silently override the resolved model, the session choice, or the isolation flags. This
+ * is the reserved set from plans/opencode-backend.md "Config and routing"; part 3 adds
+ * `--title`, which tumwater now sets (finding 6). */
+import { appendPassthroughArgs } from "../agent-args.js";
+export const HARNESS_OPENCODE_FLAGS = new Set([
+    "run",
+    "--format",
+    "--model",
+    "-m",
+    "--session",
+    "-s",
+    "--continue",
+    "-c",
+    "--fork",
+    "--standalone",
+    "--server",
+    "--attach",
+    "--auto",
+    "--yolo",
+    "--dangerously-skip-permissions",
+    "--agent",
+    "--thinking",
+    "--dir",
+    "--title",
+]);
+/** Build one run's opencode argv and stdin. The prompt is never an argv element (OpenCode
+ * reads a non-TTY stdin to EOF, and the runner closes it). A model with no `/` names a model
+ * on OpenCode's own gateway and gets the `opencode/` provider; anything with a slash is the
+ * provider-qualified id and passes as is. Throws on a passthrough arg that repeats a harness
+ * flag, since OpenCode's last-wins parser would otherwise silently override what the harness
+ * asked for. */
+/** The opencode-namespaced model id: a bare id (no `/`) names a model on OpenCode's own
+ * gateway and gets the `opencode/` provider; an id bearing a slash is provider-qualified and
+ * passes as-is. The single home of this routing rule — shared by the argv builder
+ * (opencodeArgs, here) and the catalog's cache key (opencode-catalog.ts's opencodeModelKey) —
+ * so the id a run is invoked with always matches the id a run is priced by. */
+export function opencodeQualifiedModel(model) {
+    return model.includes("/") ? model : `opencode/${model}`;
+}
+export function opencodeArgs(opts) {
+    const model = opencodeQualifiedModel(opts.model) + (opts.variant !== undefined ? `#${opts.variant}` : "");
+    const args = ["run", "--standalone", "--format", "json", "--auto", "--model", model, "--session", opts.sessionId, "--title", opts.title];
+    appendPassthroughArgs(args, opts.args, HARNESS_OPENCODE_FLAGS, "opencodeArgs");
+    return { args, stdin: opts.prompt };
+}