maesttro 0.2.0 → 0.2.1

package/README.md

@@ -1,7 +1,7 @@
 # maesttro
 
-Isolated Docker sandbox for local coding agents — `claude`, `opencode`, `codex`,
-and others. Inside the sandbox, `gh` and `git` act as the Maesttro GitHub App's
+Isolated Docker runner for local coding agents — `opencode`, `claude`,
+and others. Inside the runner, `gh` and `git` act as the Maesttro GitHub App's
 bot, using a token that is scoped to the current repo and lasts at most an hour.
 Your personal `~/.ssh` and `~/.config/gh` are never used. Install once, then
 `maesttro` just works from any project.
@@ -56,10 +56,9 @@ maesttro login / logout / status         # manage the GitHub login
 maesttro list                            # see available clients
 maesttro doctor                          # health check anytime
 
-maesttro                                 # from a repo root: new session clone + default client (claude)
+maesttro                                 # from a repo root: new session clone + default client (opencode)
 maesttro opencode                        # same, with opencode
-maesttro codex                           # same, with codex
-maesttro bash                            # plain shell inside the sandbox, for debugging
+maesttro bash                            # plain shell inside the runner, for debugging
 maesttro sessions                        # list this repo's kept sessions
 maesttro resume <id>                     # continue one
 maesttro push [branch]                   # push a branch a session created (shows what goes out, asks first)
@@ -82,7 +81,7 @@ part of the repo the container sees:
 - The host never runs git inside the clone, so agent-authored git config, hooks
   or attributes can't make your host git run anything.
 - The agent commits on its own branch in the clone. It **cannot push**:
-  the sandbox's GitHub token is read-only for code.
+  the runner's GitHub token is read-only for code.
 - When a branch is ready, the agent asks you to run `maesttro push <branch>`
   from the repo root. That command pushes only branches a session created,
   never the default branch or branches that existed before. It shows you the
@@ -110,9 +109,9 @@ comments). It acts as the Maesttro GitHub App's bot:
 ## Your instructions come along
 
 At every container start, `maesttro configure` copies your host
-`~/.claude/CLAUDE.md`, `~/.config/opencode/AGENTS.md`, `~/.codex/AGENTS.md` and
-`~/.claude/{agents,commands,skills}` into the sandbox, read-only at the
-source, and adds a short section explaining the sandbox rules. Credentials and
+`~/.claude/CLAUDE.md`, `~/.config/opencode/AGENTS.md` and
+`~/.claude/{agents,commands,skills}` into the runner, read-only at the
+source, and adds a short section explaining the runner rules. Credentials and
 settings files are never copied.
 
 Upgrading from 0.1.x: the first launch removes the token you pasted before;
@@ -125,25 +124,40 @@ Defined in `src/clients.ts`, installed in `docker/Dockerfile`, configured via
 
 | Key | Client | Package |
 |---|---|---|
-| `claude` (default) | Claude Code | `@anthropic-ai/claude-code` |
-| `opencode` | opencode | `opencode-ai` |
-| `codex` | OpenAI Codex CLI | `@openai/codex` |
+| `opencode` (default) | opencode | `opencode-ai` |
+| `claude` | Claude Code | `@anthropic-ai/claude-code` |
 
 Adding a new client: add an entry to `src/clients.ts`, an install line in
 `docker/Dockerfile`, and a `docker/configs/<key>/` directory with any default
-config — then `maesttro update` rebuilds the image with it included.
+config — then `maesttro update` rebuilds the runner image with it included.
+
+### Maesttro provider
+
+Every launch builds opencode's config on your machine: your own
+`~/.config/opencode/opencode.json(c)`, with secrets removed, and Maesttro's
+config on top (`$MAESTTRO_URL`, default `http://100.64.0.2`). Only the result
+is mounted into the runner, read-only, and copied into place at start. Your
+raw config never enters the container, and your host's config is never written.
+
+Injected: a `maesttro` provider (Orchestrate) at `/v1`, a `dgx-spark` provider
+(lorem direct on the DGX), compaction, default model `maesttro/maesttro`, and
+thinking blocks shown. The two providers replace yours of the same name; the
+rest (`mcp`, `plugin`, other providers) is merged. Removed secrets are listed
+at launch by path. `{env:X}` / `$X` references are kept.
+
+Claude Code gets no Maesttro config and uses its own defaults and login.
 
 ---
 
 ## How `maesttro update` keeps configs current
 
 `docker/configs/<client>/` holds the curated client defaults. They aren't baked
-into the image: at every container start, `maesttro configure` runs from your
+into the runner image: at every container start, `maesttro configure` runs from your
 installed package, which is mounted read-only, and merges them into each client's
 config, keeping your own keys. So `maesttro update` has two steps:
 1. `npm i -g maesttro@latest` refreshes the package, including `docker/configs/`,
    which the next session picks up.
-2. It rebuilds the sandbox image, for new client and tool versions.
+2. It rebuilds the runner image, for new client and tool versions.
 
 Your session state (in the `maesttro-home` volume) and your project files are
 untouched by an update.
@@ -189,9 +203,7 @@ maesttro/
     ├── Dockerfile
     ├── gitconfig    # → /etc/gitconfig: SSH→HTTPS, gh as credential helper
     └── configs/
-        ├── claude/
-        ├── opencode/
-        └── codex/
+        └── opencode/
 ```
 
 ## Trying it locally
@@ -214,7 +226,6 @@ registry it was installed from.
 
 ## Open items
 
-- Fill in real curated defaults in `docker/configs/*` (currently placeholders)
 - Pin exact client CLI versions in the Dockerfile once stable
 - Decide whether each client gets its own volume, or shares one (current setup: shared)
 - Homebrew tap as an alternative install path for non-Node users — optional

package/dist/maesttro.js

@@ -351,15 +351,342 @@ async function status() {
 
 // src/configure.ts
 import {
-  cpSync,
-  existsSync,
-  mkdirSync as mkdirSync2,
+  cpSync as cpSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname5, join as join4 } from "node:path";
+
+// src/client-configs.ts
+import {
+  chmodSync as chmodSync2,
+  cpSync,
+  existsSync,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  readFileSync as readFileSync3,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// src/json-file.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeJson(existing, curated) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(curated)) {
+    const current = merged[key];
+    merged[key] = isObject(current) && isObject(value) ? mergeJson(current, value) : value;
+  }
+  return merged;
+}
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return isObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeJson(path, value) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function skipInsignificant(text, from) {
+  let index = from;
+  while (index < text.length) {
+    if (/\s/.test(text[index] ?? "")) {
+      index++;
+    } else if (text.startsWith("//", index)) {
+      while (index < text.length && text[index] !== `
+`)
+        index++;
+    } else if (text.startsWith("/*", index)) {
+      const end = text.indexOf("*/", index + 2);
+      index = end === -1 ? text.length : end + 2;
+    } else {
+      return index;
+    }
+  }
+  return index;
+}
+function stripJsonc(text) {
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === '"') {
+      const start = index;
+      index++;
+      while (index < text.length && text[index] !== '"') {
+        index += text[index] === "\\" ? 2 : 1;
+      }
+      index++;
+      output += text.slice(start, index);
+      continue;
+    }
+    const significant = skipInsignificant(text, index);
+    if (significant > index) {
+      output += " ";
+      index = significant;
+      continue;
+    }
+    const trailingComma = char === "," && /[}\]]/.test(text[skipInsignificant(text, index + 1)] ?? "");
+    if (!trailingComma)
+      output += char;
+    index++;
+  }
+  return output;
+}
+function parseJsonc(text) {
+  const parsed = JSON.parse(stripJsonc(text));
+  if (!isObject(parsed))
+    throw new Error("expected a JSON object");
+  return parsed;
+}
+
+// src/maesttro-endpoint.ts
+var DEFAULT_MAESTTRO_URL = "http://100.64.0.2";
+var ORCHESTRATOR_MODEL = "maesttro";
+function maesttroUrl(env = process.env) {
+  return (env.MAESTTRO_URL?.trim() || DEFAULT_MAESTTRO_URL).replace(/\/+$/, "");
+}
+
+// src/provider-configs.ts
+var PROVIDER_ID = "maesttro";
+var MAESTTRO_API_KEY = "maesttro";
+var DGX_SPARK_PROVIDER_ID = "dgx-spark";
+var DGX_SPARK_URL = "http://100.64.0.1:8001";
+var INJECTED_OPENCODE_PROVIDERS = [PROVIDER_ID, DGX_SPARK_PROVIDER_ID];
+function without(object, keys) {
+  if (!isObject(object))
+    return {};
+  return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
+}
+function opencodeHostBase(host) {
+  return isObject(host.provider) ? { ...host, provider: without(host.provider, INJECTED_OPENCODE_PROVIDERS) } : host;
+}
+var IMAGE_INPUT = {
+  attachment: true,
+  modalities: { input: ["text", "image"] }
+};
+function opencodeProviders(url) {
+  return {
+    [PROVIDER_ID]: {
+      npm: "@ai-sdk/openai-compatible",
+      name: "Maesttro",
+      options: { baseURL: `${url}/v1`, apiKey: MAESTTRO_API_KEY },
+      models: {
+        [ORCHESTRATOR_MODEL]: { name: "Orchestrate", ...IMAGE_INPUT }
+      }
+    },
+    [DGX_SPARK_PROVIDER_ID]: {
+      npm: "@ai-sdk/openai-compatible",
+      name: "DGX-Spark",
+      options: { baseURL: `${DGX_SPARK_URL}/v1`, apiKey: "" },
+      models: {
+        "maesttro/lorem": {
+          name: "Qwen3.8 27B",
+          ...IMAGE_INPUT,
+          limit: { context: 131072, output: 32768 }
+        }
+      }
+    }
+  };
+}
+function opencodeConfig(base, url) {
+  const merged = mergeJson({ $schema: "https://opencode.ai/config.json", ...base }, {
+    model: `${PROVIDER_ID}/${ORCHESTRATOR_MODEL}`,
+    compaction: { auto: true, keep: { tokens: 24000 }, buffer: 32000 }
+  });
+  const enabled = stringList(base.enabled_providers);
+  const disabled = stringList(base.disabled_providers);
+  return {
+    ...merged,
+    ...enabled ? {
+      enabled_providers: [
+        ...enabled.filter((id) => !INJECTED_OPENCODE_PROVIDERS.includes(id)),
+        ...INJECTED_OPENCODE_PROVIDERS
+      ]
+    } : {},
+    ...disabled ? {
+      disabled_providers: disabled.filter((id) => !INJECTED_OPENCODE_PROVIDERS.includes(id))
+    } : {},
+    provider: {
+      ...isObject(base.provider) ? base.provider : {},
+      ...opencodeProviders(url)
+    }
+  };
+}
+
+// src/secrets.ts
+var SECRET_KEY = /api[_-]?key|token|secret|passw(or)?d|credential|authorization|bearer|private[_-]?key|cookie/i;
+var ENV_NAME_KEY = /(^|_)env(_var|_key|_vars)?$/i;
+var SECRET_MAPS = new Set(["env", "environment", "headers", "http_headers"]);
+var CREDENTIAL_SHAPES = [
+  /(^|[^A-Za-z0-9])sk[-_][A-Za-z0-9_-]{16,}/,
+  /(^|[^A-Za-z0-9])gh[pousr]_[A-Za-z0-9]{20,}/,
+  /github_pat_[A-Za-z0-9_]{20,}/,
+  /glpat-[A-Za-z0-9_-]{16,}/,
+  /xox[abposr]-[A-Za-z0-9-]{10,}/,
+  /(^|[^A-Za-z0-9])(AKIA|ASIA)[0-9A-Z]{16}/,
+  /AIza[0-9A-Za-z_-]{30,}/,
+  /\bbearer\s+[A-Za-z0-9._~+/=-]{8,}/i,
+  /:\/\/[^/\s:@]+:[^/\s@]+@/,
+  /[?&](api[_-]?key|key|token|access_token|secret)=/i,
+  /hooks\.slack\.com\/services\//
+];
+var SECRET_FLAG = /^--?[\w-]*(token|api[_-]?key|secret|passw(or)?d)[\w-]*$/i;
+var SECRET_FLAG_WITH_VALUE = /^--?[\w-]*(token|api[_-]?key|secret|passw(or)?d)[\w-]*=/i;
+var REFERENCE = /^\{(env|file):[^}]+\}$|^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/;
+var HARMLESS_MAP_VALUE = /^(\d+(\.\d+)?|true|false|yes|no|on|off)$/i;
+function isSecretString({
+  key,
+  value,
+  inSecretMap
+}) {
+  if (value.trim() === "" || REFERENCE.test(value.trim()))
+    return false;
+  if (CREDENTIAL_SHAPES.some((shape) => shape.test(value)))
+    return true;
+  if (inSecretMap)
+    return !HARMLESS_MAP_VALUE.test(value.trim());
+  return SECRET_KEY.test(key) && !ENV_NAME_KEY.test(key);
+}
+function redactValue(value, key, path, inSecretMap, removed) {
+  if (typeof value === "string") {
+    if (isSecretString({ key, value, inSecretMap })) {
+      removed.push(path);
+      return { keep: false, value };
+    }
+    return { keep: true, value };
+  }
+  if (Array.isArray(value)) {
+    const items = value.flatMap((item, index) => {
+      const previous = value[index - 1];
+      const flagged = typeof item === "string" && (typeof previous === "string" && SECRET_FLAG.test(previous) || SECRET_FLAG_WITH_VALUE.test(item));
+      if (flagged) {
+        removed.push(`${path}[${index}]`);
+        return [];
+      }
+      const result = redactValue(item, key, `${path}[${index}]`, inSecretMap, removed);
+      return result.keep ? [result.value] : [];
+    });
+    return { keep: true, value: items };
+  }
+  if (isObject(value)) {
+    return {
+      keep: true,
+      value: redactObject(value, path, inSecretMap || SECRET_MAPS.has(key), removed)
+    };
+  }
+  return { keep: true, value };
+}
+function redactObject(object, path, inSecretMap, removed) {
+  const kept = {};
+  for (const [key, value] of Object.entries(object)) {
+    const result = redactValue(value, key, path ? `${path}.${key}` : key, inSecretMap, removed);
+    const emptied = isObject(value) && Object.keys(value).length > 0 && isObject(result.value) && Object.keys(result.value).length === 0;
+    if (result.keep && !emptied)
+      kept[key] = result.value;
+  }
+  return kept;
+}
+function redactSecrets(config) {
+  const removed = [];
+  return { value: redactObject(config, "", false, removed), removed };
+}
+
+// src/client-configs.ts
+var CONTAINER_CLIENT_CONFIGS = "/opt/maesttro-clients";
+var OPENCODE_HOST_CONFIGS = [
+  ".config/opencode/opencode.json",
+  ".config/opencode/opencode.jsonc"
+];
+var OPENCODE_CONFIG = ".config/opencode/opencode.json";
+var OPENCODE_TUI_STATE = ".local/state/opencode/kv.json";
+var CURATED_OPENCODE_TUI_STATE = {
+  thinking_mode: "show",
+  thinking_visibility: true
+};
+function readHostFile({
+  home,
+  file,
+  parse,
+  warn
+}) {
+  const path = join2(home, file);
+  if (!existsSync(path))
+    return {};
+  try {
+    return parse(readFileSync3(path, "utf8"));
+  } catch {
+    warn(`maesttro: ignoring your ~/${file}, it doesn't parse`);
+    return {};
+  }
+}
+function readHostClientConfigs({
+  home,
+  warn = (message) => console.error(message)
+}) {
+  return {
+    opencode: OPENCODE_HOST_CONFIGS.reduce((config, file) => mergeJson(config, readHostFile({ home, file, parse: parseJsonc, warn })), {})
+  };
+}
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function buildClientConfigs({
+  host,
+  url
+}) {
+  const opencode = redactSecrets(opencodeHostBase(host.opencode));
+  return {
+    files: { [OPENCODE_CONFIG]: json(opencodeConfig(opencode.value, url)) },
+    removed: opencode.removed.map((path) => `opencode ${path}`)
+  };
+}
+function writeClientConfigDir(files, parent = tmpdir()) {
+  const root = mkdtempSync(join2(parent, "maesttro-clients-"));
+  chmodSync2(root, 448);
+  const dir = join2(root, "home");
+  for (const [file, content] of Object.entries(files)) {
+    const path = join2(dir, file);
+    mkdirSync3(dirname3(path), { recursive: true, mode: 493 });
+    writeFileSync3(path, content);
+    chmodSync2(path, 420);
+  }
+  chmodSync2(dir, 493);
+  return { dir, remove: () => rmSync2(root, { recursive: true, force: true }) };
+}
+function installClientConfigs({
+  home,
+  source = CONTAINER_CLIENT_CONFIGS
+}) {
+  if (!existsSync(source))
+    return false;
+  cpSync(source, home, { recursive: true, force: true });
+  return true;
+}
+function injectOpencodeTuiState({ home }) {
+  const path = join2(home, OPENCODE_TUI_STATE);
+  writeJson(path, mergeJson(readJson(path), CURATED_OPENCODE_TUI_STATE));
+  return path;
+}
 
 // src/clients.ts
 var CLIENTS = {
@@ -374,15 +701,9 @@ var CLIENTS = {
     npmPackage: "opencode-ai",
     binary: "opencode",
     configDir: "/home/agent/.config/opencode"
-  },
-  codex: {
-    label: "OpenAI Codex CLI",
-    npmPackage: "@openai/codex",
-    binary: "codex",
-    configDir: "/home/agent/.codex"
   }
 };
-var DEFAULT_CLIENT = "claude";
+var DEFAULT_CLIENT = "opencode";
 function isClientKey(value) {
   return Object.hasOwn(CLIENTS, value);
 }
@@ -396,21 +717,20 @@ var STAGED_DIRECTORIES = [
 ];
 var INSTRUCTION_FILES = [
   ".claude/CLAUDE.md",
-  ".config/opencode/AGENTS.md",
-  ".codex/AGENTS.md"
+  ".config/opencode/AGENTS.md"
 ];
 var STAGED_PATHS = [...INSTRUCTION_FILES, ...STAGED_DIRECTORIES];
 
 // src/paths.ts
-import { dirname as dirname2, join as join2, resolve } from "node:path";
+import { dirname as dirname4, join as join3, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-var PACKAGE_ROOT = resolve(dirname2(fileURLToPath(import.meta.url)), "..");
-var DOCKERFILE_DIR = join2(PACKAGE_ROOT, "docker");
+var PACKAGE_ROOT = resolve(dirname4(fileURLToPath(import.meta.url)), "..");
+var DOCKERFILE_DIR = join3(PACKAGE_ROOT, "docker");
 var IMAGE = "maesttro-runner:latest";
 var VOLUME = process.env.MAESTTRO_VOLUME?.trim() || "maesttro-home";
 
-// src/sandbox-context.ts
-function sandboxContextFromEnv(env) {
+// src/runner-context.ts
+function runnerContextFromEnv(env) {
   return {
     sessionId: env.MAESTTRO_SESSION_ID,
     base: env.MAESTTRO_BASE,
@@ -418,7 +738,7 @@ function sandboxContextFromEnv(env) {
     githubAccess: env.MAESTTRO_GITHUB === "on"
   };
 }
-function sandboxInstructions(context) {
+function runnerInstructions(context) {
   const base = context.base ?? "the default branch";
   const github = context.githubAccess ? [
     `- \`gh\` works for ${context.repo ?? "this repo"} only: issues, pull requests, comments. Its token is short-lived and refreshed for you.`,
@@ -427,20 +747,20 @@ function sandboxInstructions(context) {
     "- GitHub access is unavailable in this session, so `gh` has no token. Local git work still works."
   ];
   return [
-    "# Maesttro sandbox",
+    "# Maesttro runner",
     "",
-    "You are running inside Maesttro's isolated sandbox container. These rules describe what the environment allows, so plan around them.",
+    "You are running inside Maesttro's isolated runner container. These rules describe what the environment allows, so plan around them.",
     "",
     "## Your workspace",
     "",
     `- The current directory is an isolated clone of the repository${context.sessionId ? ` for this session (\`${context.sessionId}\`)` : ""}, detached at \`${base}\`. It is the only checkout you can see or change; your main checkout is not here.`,
     "- Before your first commit, create a branch for the task: `git switch -c <short-descriptive-name>`. Keep one branch per task.",
     "- Work in this directory. Anything outside it is not persisted.",
-    "- Commit on a branch you create here. The user pushes it from their machine with `maesttro push`; the sandbox cannot push, merge, or delete remote branches.",
+    "- Commit on a branch you create here. The user pushes it from their machine with `maesttro push`; the runner cannot push, merge, or delete remote branches.",
     "",
     "## Pushing",
     "",
-    "- `git push` does not work here: the sandbox has read-only access to the remote. This is deliberate.",
+    "- `git push` does not work here: the runner has read-only access to the remote. This is deliberate.",
     '- When a branch is ready, commit everything, then tell the user: "Ready to push: <branch>. Run `maesttro push <branch>` from the repository root."',
     "- After the user confirms it is pushed, `git fetch` and continue. Open the pull request with `gh pr create --head <branch>` if asked to.",
     "",
@@ -453,52 +773,33 @@ function sandboxInstructions(context) {
 }
 
 // src/configure.ts
-var SANDBOX_MARKER = "/etc/maesttro/sandbox";
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+var RUNNER_MARKER = "/etc/maesttro/runner";
 function withoutComments(value) {
   return Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith("_comment")).map(([key, inner]) => [
     key,
     isObject(inner) ? withoutComments(inner) : inner
   ]));
 }
-function mergeJson(existing, curated) {
-  const merged = { ...existing };
-  for (const [key, value] of Object.entries(curated)) {
-    const current = merged[key];
-    merged[key] = isObject(current) && isObject(value) ? mergeJson(current, value) : value;
-  }
-  return merged;
-}
-function readJson(path) {
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return isObject(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
 function applyProviderConfigs({
   home,
-  configsDir = join3(DOCKERFILE_DIR, "configs")
+  configsDir = join4(DOCKERFILE_DIR, "configs")
 }) {
   const written = [];
   for (const [key, client] of Object.entries(CLIENTS)) {
-    const source = join3(configsDir, key);
-    if (!existsSync(source))
+    const source = join4(configsDir, key);
+    if (!existsSync2(source))
       continue;
-    const targetDir = join3(home, client.configDir.replace(/^\/home\/agent\/?/, ""));
+    const targetDir = join4(home, client.configDir.replace(/^\/home\/agent\/?/, ""));
     for (const name of readdirSync(source)) {
       if (!name.endsWith(".json"))
         continue;
-      const curated = withoutComments(readJson(join3(source, name)));
+      const curated = withoutComments(readJson(join4(source, name)));
       if (Object.keys(curated).length === 0)
         continue;
-      const target = join3(targetDir, name);
-      mkdirSync2(targetDir, { recursive: true });
+      const target = join4(targetDir, name);
+      mkdirSync4(targetDir, { recursive: true });
       const merged = mergeJson(readJson(target), curated);
-      writeFileSync2(target, `${JSON.stringify(merged, null, 2)}
+      writeFileSync4(target, `${JSON.stringify(merged, null, 2)}
 `);
       written.push(target);
     }
@@ -511,33 +812,41 @@ function stageHostInstructions({
   context
 }) {
   for (const directory of STAGED_DIRECTORIES) {
-    const source = join3(staging, directory);
-    if (!existsSync(source))
+    const source = join4(staging, directory);
+    if (!existsSync2(source))
       continue;
     try {
-      cpSync(source, join3(home, directory), { recursive: true, force: true });
+      cpSync2(source, join4(home, directory), { recursive: true, force: true });
     } catch {}
   }
-  const instructions = sandboxInstructions(context);
+  const instructions = runnerInstructions(context);
   for (const file of INSTRUCTION_FILES) {
-    const source = join3(staging, file);
-    const hostCopy = existsSync(source) ? readFileSync2(source, "utf8") : "";
-    const target = join3(home, file);
-    mkdirSync2(dirname3(target), { recursive: true });
-    writeFileSync2(target, hostCopy ? `${hostCopy.trimEnd()}
+    const source = join4(staging, file);
+    const hostCopy = existsSync2(source) ? readFileSync4(source, "utf8") : "";
+    const target = join4(home, file);
+    mkdirSync4(dirname5(target), { recursive: true });
+    writeFileSync4(target, hostCopy ? `${hostCopy.trimEnd()}
 
 ${instructions}` : instructions);
   }
 }
 function configure({
   home = homedir2(),
-  inSandbox = existsSync(SANDBOX_MARKER),
-  env = process.env
+  inRunner = existsSync2(RUNNER_MARKER),
+  env = process.env,
+  staging = HOST_STAGING_DIR,
+  clientConfigs
 } = {}) {
   applyProviderConfigs({ home });
-  if (inSandbox) {
-    stageHostInstructions({ home, context: sandboxContextFromEnv(env) });
-  }
+  if (!inRunner)
+    return;
+  installClientConfigs({ home, source: clientConfigs });
+  injectOpencodeTuiState({ home });
+  stageHostInstructions({
+    home,
+    staging,
+    context: runnerContextFromEnv(env)
+  });
 }
 
 // src/doctor.ts
@@ -646,7 +955,7 @@ function purgeLegacyToken() {
 function hasLegacyToken() {
   return inVolume(DETECT_LEGACY_TOKEN).includes("FOUND");
 }
-var REVOKE_NOTICE = "Removed a long-lived GitHub token that an older maesttro stored in the sandbox volume. Revoke it on GitHub too: https://github.com/settings/tokens?type=beta";
+var REVOKE_NOTICE = "Removed a long-lived GitHub token that an older maesttro stored in the runner volume. Revoke it on GitHub too: https://github.com/settings/tokens?type=beta";
 function purgeLegacyTokenOnce({
   config,
   saveConfig,
@@ -661,8 +970,8 @@ function purgeLegacyTokenOnce({
 }
 
 // src/repo.ts
-import { appendFileSync, mkdirSync as mkdirSync3, realpathSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync5, realpathSync } from "node:fs";
+import { join as join5 } from "node:path";
 var MINIMUM_GIT = [2, 48];
 var WORKTREES_DIR = ".worktrees";
 
@@ -705,7 +1014,7 @@ function repoRoot(run, cwd) {
     "--git-common-dir"
   ]).out;
   const root = realpathSync(top.out);
-  if (realpathSync(commonDir) !== join4(root, ".git")) {
+  if (realpathSync(commonDir) !== join5(root, ".git")) {
     throw new LaunchError("This is a git worktree. Run maesttro from the main checkout; each session gets its own isolated clone.");
   }
   if (realpathSync(cwd) !== root) {
@@ -732,12 +1041,12 @@ function defaultBranch(run, root) {
   throw new LaunchError("Can't find the default branch of origin. Run `git remote set-head origin --auto`.");
 }
 function ensureWorktreesDir(run, root) {
-  mkdirSync3(join4(root, WORKTREES_DIR), { recursive: true });
+  mkdirSync5(join5(root, WORKTREES_DIR), { recursive: true });
   if (git(run, root, ["check-ignore", "-q", `${WORKTREES_DIR}/`]).ok)
     return;
-  const info = join4(root, ".git", "info");
-  mkdirSync3(info, { recursive: true });
-  appendFileSync(join4(info, "exclude"), `
+  const info = join5(root, ".git", "info");
+  mkdirSync5(info, { recursive: true });
+  appendFileSync(join5(info, "exclude"), `
 ${WORKTREES_DIR}/
 `);
 }
@@ -779,7 +1088,7 @@ async function check(label, probe) {
     return false;
   }
 }
-function inSandbox(command, { withVolume = true } = {}) {
+function inRunner(command, { withVolume = true } = {}) {
   const volume = withVolume ? `-v ${VOLUME}:/home/agent ` : "";
   return execSync2(`docker run --rm ${hostIdentityFlags()} ${volume}${IMAGE} "${command}"`).toString();
 }
@@ -802,7 +1111,7 @@ async function doctor() {
       }
     ],
     [
-      "Sandbox image built",
+      "Runner image built",
       () => `built ${execSync2(`docker image inspect ${IMAGE} --format "{{.Created}}"`).toString().trim()}`
     ],
     [
@@ -845,9 +1154,9 @@ async function doctor() {
       }
     ],
     [
-      "Personal SSH key NOT visible inside sandbox (isolation intact)",
+      "Personal SSH key NOT visible inside runner (isolation intact)",
       () => {
-        const out = inSandbox("cat ~/.ssh/id_rsa 2>&1 || echo MISSING");
+        const out = inRunner("cat ~/.ssh/id_rsa 2>&1 || echo MISSING");
         if (!out.includes("MISSING") && !out.includes("No such file")) {
           throw new Error("isolation broken");
         }
@@ -856,7 +1165,7 @@ async function doctor() {
     ...Object.values(CLIENTS).map((client) => [
       `Client available: ${client.label}`,
       () => {
-        inSandbox(`which ${client.binary}`, { withVolume: false });
+        inRunner(`which ${client.binary}`, { withVolume: false });
       }
     ])
   ];
@@ -873,10 +1182,10 @@ async function doctor() {
 }
 
 // src/help.ts
-var HELP = `maesttro — isolated sandbox for local coding agents
+var HELP = `maesttro — isolated runner for local coding agents
 
 Usage:
-  maesttro                Start a session from the repo root: new clone, default client (claude)
+  maesttro                Start a session from the repo root: new clone, default client (opencode)
   maesttro <client>        Same, with a specific client — see \`maesttro list\`
   maesttro resume <id>     Continue a kept session in its clone
   maesttro sessions        List this repo's sessions (\`sessions remove <id>\` to drop one)
@@ -886,57 +1195,57 @@ Usage:
   maesttro login           Log in to GitHub (device flow) so sessions get repo access
   maesttro logout          Remove the stored GitHub credentials
   maesttro status          Show GitHub login status
-  maesttro configure       Apply maesttro's client configs (also runs inside the sandbox)
-  maesttro update          Update the package and rebuild the image with refreshed client configs
+  maesttro configure       Apply maesttro's client configs (also runs inside the runner)
+  maesttro update          Update the package and rebuild the runner image with refreshed client configs
   maesttro doctor          Health check — Docker, image, volume, GitHub login, broker, isolation, clients
   maesttro help            Show this message
 `;
 
 // src/launch.ts
 import { execSync as execSync3, spawn } from "node:child_process";
-import { existsSync as existsSync3, rmSync as rmSync5 } from "node:fs";
+import { existsSync as existsSync4, rmSync as rmSync6 } from "node:fs";
 import { constants, homedir as homedir4 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // src/backup.ts
 import { createHash } from "node:crypto";
-import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, rmSync as rmSync2 } from "node:fs";
-import { basename, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync7, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { basename, join as join7 } from "node:path";
 
 // src/maesttro-home.ts
 import {
   appendFileSync as appendFileSync2,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync5,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function maesttroHome() {
-  return join5(homedir3(), ".config", "maesttro");
+  return join6(homedir3(), ".config", "maesttro");
 }
 function configPath() {
-  return join5(maesttroHome(), "config.json");
+  return join6(maesttroHome(), "config.json");
 }
 function readMaesttroConfig() {
   try {
-    return JSON.parse(readFileSync3(configPath(), "utf8"));
+    return JSON.parse(readFileSync5(configPath(), "utf8"));
   } catch {
     return {};
   }
 }
 function writeMaesttroConfig(config) {
-  mkdirSync4(maesttroHome(), { recursive: true, mode: 448 });
+  mkdirSync6(maesttroHome(), { recursive: true, mode: 448 });
   const temporary = `${configPath()}.tmp`;
-  writeFileSync3(temporary, `${JSON.stringify(config, null, 2)}
+  writeFileSync5(temporary, `${JSON.stringify(config, null, 2)}
 `);
   renameSync2(temporary, configPath());
 }
-function fileSessionLog(path = join5(maesttroHome(), "maesttro.log")) {
+function fileSessionLog(path = join6(maesttroHome(), "maesttro.log")) {
   return (event, detail) => {
     try {
-      mkdirSync4(maesttroHome(), { recursive: true, mode: 448 });
+      mkdirSync6(maesttroHome(), { recursive: true, mode: 448 });
       appendFileSync2(path, `${new Date().toISOString()} ${event}${detail ? ` ${detail}` : ""}
 `);
     } catch {}
@@ -949,7 +1258,7 @@ function shortHash(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 8);
 }
 function backupDir(repoRoot, home = maesttroHome()) {
-  return join6(home, "backups", `${basename(repoRoot)}-${shortHash(repoRoot)}`);
+  return join7(home, "backups", `${basename(repoRoot)}-${shortHash(repoRoot)}`);
 }
 function refsFingerprint(refs) {
   const sorted = Object.keys(refs).sort().map((ref) => `${ref} ${refs[ref]}`);
@@ -967,20 +1276,20 @@ function backupRepo({
 }) {
   if (Object.keys(refs).length === 0)
     return;
-  mkdirSync5(dir, { recursive: true, mode: 448 });
+  mkdirSync7(dir, { recursive: true, mode: 448 });
   const fingerprint = refsFingerprint(refs);
   const existing = readdirSync2(dir).filter((name) => name.endsWith(".bundle")).sort();
   const latest = existing.at(-1);
   if (latest?.endsWith(`-${fingerprint}.bundle`)) {
-    return { path: join6(dir, latest), reused: true };
+    return { path: join7(dir, latest), reused: true };
   }
   const stamp = now.toISOString().replace(/[:.]/g, "-");
-  const path = join6(dir, `${stamp}-${sessionId}-${fingerprint}.bundle`);
+  const path = join7(dir, `${stamp}-${sessionId}-${fingerprint}.bundle`);
   if (!git(run, repoRoot, ["bundle", "create", "--quiet", path, "--all"]).ok) {
     return;
   }
   for (const stale of [...existing, basename(path)].sort().slice(0, -keep)) {
-    rmSync2(join6(dir, stale), { force: true });
+    rmSync3(join7(dir, stale), { force: true });
   }
   return { path, reused: false };
 }
@@ -1065,20 +1374,20 @@ function startRefresher({
 
 // src/session-dir.ts
 import {
-  chmodSync as chmodSync2,
-  mkdirSync as mkdirSync6,
-  mkdtempSync,
+  chmodSync as chmodSync3,
+  mkdirSync as mkdirSync8,
+  mkdtempSync as mkdtempSync2,
   renameSync as renameSync3,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync4
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join8 } from "node:path";
 var CONTAINER_GH_CONFIG_DIR = "/home/agent/.config/gh-maesttro";
 function writeAtomically(path, content) {
   const temporary = `${path}.tmp`;
-  writeFileSync4(temporary, content, { mode: 420 });
-  chmodSync2(temporary, 420);
+  writeFileSync6(temporary, content, { mode: 420 });
+  chmodSync3(temporary, 420);
   renameSync3(temporary, path);
 }
 function hostsYaml(token, user) {
@@ -1091,20 +1400,20 @@ function hostsYaml(token, user) {
   ].join(`
 `);
 }
-function createSessionDir(parent = tmpdir()) {
-  const root = mkdtempSync(join7(parent, "maesttro-"));
-  chmodSync2(root, 448);
-  const ghDir = join7(root, "gh");
-  mkdirSync6(ghDir);
-  chmodSync2(ghDir, 493);
-  writeAtomically(join7(ghDir, "config.yml"), `version: "1"
+function createSessionDir(parent = tmpdir2()) {
+  const root = mkdtempSync2(join8(parent, "maesttro-"));
+  chmodSync3(root, 448);
+  const ghDir = join8(root, "gh");
+  mkdirSync8(ghDir);
+  chmodSync3(ghDir, 493);
+  writeAtomically(join8(ghDir, "config.yml"), `version: "1"
 `);
   return {
     ghDir,
-    writeToken: (token, user) => writeAtomically(join7(ghDir, "hosts.yml"), hostsYaml(token, user)),
-    writeStatus: (status) => writeAtomically(join7(ghDir, "status"), `${status}
+    writeToken: (token, user) => writeAtomically(join8(ghDir, "hosts.yml"), hostsYaml(token, user)),
+    writeStatus: (status) => writeAtomically(join8(ghDir, "status"), `${status}
 `),
-    remove: () => rmSync3(root, { recursive: true, force: true })
+    remove: () => rmSync4(root, { recursive: true, force: true })
   };
 }
 
@@ -1247,13 +1556,13 @@ function ask(question) {
 // src/session-clone.ts
 import {
   copyFileSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   lstatSync,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync4
+  readFileSync as readFileSync6
 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/sanitize.ts
 function stripControl(text) {
@@ -1345,14 +1654,14 @@ function dirents(dir) {
   }
 }
 function cloneGitDir(clonePath) {
-  const gitDir = join8(clonePath, ".git");
+  const gitDir = join9(clonePath, ".git");
   return realDir(gitDir) ? gitDir : undefined;
 }
 function readSha(path) {
   try {
     if (!lstatSync(path).isFile())
       return;
-    const text = readFileSync4(path, "utf8").trim();
+    const text = readFileSync6(path, "utf8").trim();
     return SHA.test(text) ? text : undefined;
   } catch {
     return;
@@ -1362,7 +1671,7 @@ function packedRefs(gitDir) {
   const refs = new Map;
   let text;
   try {
-    text = readFileSync4(join8(gitDir, "packed-refs"), "utf8");
+    text = readFileSync6(join9(gitDir, "packed-refs"), "utf8");
   } catch {
     return refs;
   }
@@ -1387,12 +1696,12 @@ function cloneBranches(clonePath) {
         continue;
       const name = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory())
-        walk(join8(dir, entry.name), name);
+        walk(join9(dir, entry.name), name);
       else if (entry.isFile())
         names.add(name);
     }
   };
-  walk(join8(gitDir, "refs", "heads"), "");
+  walk(join9(gitDir, "refs", "heads"), "");
   for (const ref of packedRefs(gitDir).keys()) {
     if (ref.startsWith(HEADS_PREFIX))
       names.add(ref.slice(HEADS_PREFIX.length));
@@ -1405,7 +1714,7 @@ function branchTip(clonePath, branch) {
   const gitDir = cloneGitDir(clonePath);
   if (!gitDir)
     return;
-  return readSha(join8(gitDir, "refs", "heads", branch)) ?? packedRefs(gitDir).get(`${HEADS_PREFIX}${branch}`);
+  return readSha(join9(gitDir, "refs", "heads", branch)) ?? packedRefs(gitDir).get(`${HEADS_PREFIX}${branch}`);
 }
 function cloneHead(clonePath) {
   const gitDir = cloneGitDir(clonePath);
@@ -1413,9 +1722,9 @@ function cloneHead(clonePath) {
     return;
   let text;
   try {
-    if (!lstatSync(join8(gitDir, "HEAD")).isFile())
+    if (!lstatSync(join9(gitDir, "HEAD")).isFile())
       return;
-    text = readFileSync4(join8(gitDir, "HEAD"), "utf8").trim();
+    text = readFileSync6(join9(gitDir, "HEAD"), "utf8").trim();
   } catch {
     return;
   }
@@ -1436,31 +1745,31 @@ function copyObjectFiles(fromDir, intoDir) {
   for (const entry of dirents(fromDir)) {
     if (!entry.isFile())
       continue;
-    const dest = join8(intoDir, entry.name);
-    if (existsSync2(dest))
+    const dest = join9(intoDir, entry.name);
+    if (existsSync3(dest))
       continue;
     if (!created) {
-      mkdirSync7(intoDir, { recursive: true });
+      mkdirSync9(intoDir, { recursive: true });
       created = true;
     }
-    copyFileSync(join8(fromDir, entry.name), dest);
+    copyFileSync(join9(fromDir, entry.name), dest);
   }
 }
 function importObjects(run, root, clonePath, tip) {
   const gitDir = cloneGitDir(clonePath);
   if (!gitDir)
     return false;
-  const objects = join8(gitDir, "objects");
+  const objects = join9(gitDir, "objects");
   if (!realDir(objects))
     return false;
-  const into = join8(root, ".git", "objects");
+  const into = join9(root, ".git", "objects");
   for (const entry of dirents(objects)) {
     if (entry.name === "info" || entry.isSymbolicLink() || !entry.isDirectory()) {
       continue;
     }
     if (!OBJECT_SUBDIR.test(entry.name) && entry.name !== "pack")
       continue;
-    copyObjectFiles(join8(objects, entry.name), join8(into, entry.name));
+    copyObjectFiles(join9(objects, entry.name), join9(into, entry.name));
   }
   return git(run, root, ["cat-file", "-e", `${tip}^{commit}`]).ok;
 }
@@ -1468,36 +1777,36 @@ function importObjects(run, root, clonePath, tip) {
 // src/sessions.ts
 import { randomBytes } from "node:crypto";
 import {
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync7,
   renameSync as renameSync4,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function newSessionId() {
   return `maesttro-${randomBytes(4).toString("hex")}`;
 }
 function sessionsDir(home = maesttroHome()) {
-  return join9(home, "sessions");
+  return join10(home, "sessions");
 }
 function saveSession(record, dir = sessionsDir()) {
-  mkdirSync8(dir, { recursive: true, mode: 448 });
-  const path = join9(dir, `${record.id}.json`);
-  writeFileSync5(`${path}.tmp`, `${JSON.stringify(record, null, 2)}
+  mkdirSync10(dir, { recursive: true, mode: 448 });
+  const path = join10(dir, `${record.id}.json`);
+  writeFileSync7(`${path}.tmp`, `${JSON.stringify(record, null, 2)}
 `);
   renameSync4(`${path}.tmp`, path);
 }
 function readSession(id, dir = sessionsDir()) {
   try {
-    return JSON.parse(readFileSync5(join9(dir, `${id}.json`), "utf8"));
+    return JSON.parse(readFileSync7(join10(dir, `${id}.json`), "utf8"));
   } catch {
     return;
   }
 }
 function deleteSession(id, dir = sessionsDir()) {
-  rmSync4(join9(dir, `${id}.json`), { force: true });
+  rmSync5(join10(dir, `${id}.json`), { force: true });
 }
 function sessionsForRepo(repoRoot, dir = sessionsDir()) {
   let names;
@@ -1555,19 +1864,25 @@ function sessionMounts({
   packageRoot,
   hostHome,
   stagedPaths,
+  clientConfigs,
   sharedSkills
 }) {
-  const objects = join10(repoRoot, ".git", "objects");
+  const objects = join11(repoRoot, ".git", "objects");
   const mounts = [
     { host: VOLUME, container: "/home/agent" },
     { host: objects, container: objects, readOnly: true },
     { host: sessionDir, container: CONTAINER_REPO },
     { host: packageRoot, container: CONTAINER_PACKAGE, readOnly: true },
     ...stagedPaths.map((path) => ({
-      host: join10(hostHome, path),
+      host: join11(hostHome, path),
       container: `${HOST_STAGING_DIR}/${path}`,
       readOnly: true
-    }))
+    })),
+    {
+      host: clientConfigs,
+      container: CONTAINER_CLIENT_CONFIGS,
+      readOnly: true
+    }
   ];
   if (sharedSkills) {
     mounts.push({
@@ -1616,12 +1931,12 @@ function ensureReady() {
     execSync3(`docker image inspect ${IMAGE}`, { stdio: "ignore" });
     execSync3(`docker volume inspect ${VOLUME}`, { stdio: "ignore" });
   } catch {
-    throw new LaunchError("Sandbox isn't set up yet. Run `maesttro setup` first.");
+    throw new LaunchError("Runner isn't set up yet. Run `maesttro setup` first.");
   }
 }
 function sharedSkillsDir() {
-  const dir = process.env.AGENT_SHARED_SKILLS ?? join10(homedir4(), "agent-shared", "skills");
-  return existsSync3(dir) ? dir : undefined;
+  const dir = process.env.AGENT_SHARED_SKILLS ?? join11(homedir4(), "agent-shared", "skills");
+  return existsSync4(dir) ? dir : undefined;
 }
 async function resolveAuthor(workspace) {
   const fromRepo = workspaceAuthor(runCommand, workspace);
@@ -1632,7 +1947,7 @@ async function resolveAuthor(workspace) {
     return config.author;
   if (!process.stdin.isTTY)
     return;
-  console.log("No git identity found for this repo. Commits in the sandbox need an author (stored in ~/.config/maesttro/config.json).");
+  console.log("No git identity found for this repo. Commits in the runner need an author (stored in ~/.config/maesttro/config.json).");
   const name = await ask("Author name: ");
   const email = await ask("Author email: ");
   if (!name || !email)
@@ -1650,7 +1965,7 @@ function startSession(run, root) {
   if (!baseSha)
     throw new LaunchError(`Can't resolve ${base}.`);
   const id = newSessionId();
-  const sessionDir = join10(root, WORKTREES_DIR, id);
+  const sessionDir = join11(root, WORKTREES_DIR, id);
   createSessionClone(run, root, sessionDir, baseSha);
   return {
     id,
@@ -1667,7 +1982,7 @@ function resumeSession(root, id) {
   if (!session || session.repoRoot !== root) {
     throw new LaunchError(`No session ${id} in this repo. See \`maesttro sessions\`.`);
   }
-  if (!existsSync3(session.worktree)) {
+  if (!existsSync4(session.worktree)) {
     throw new LaunchError(`The clone for ${id} is gone: ${session.worktree}`);
   }
   return session;
@@ -1690,13 +2005,13 @@ function preserveBranches(run, session) {
   return preserved;
 }
 function finishSession(run, session) {
-  if (!existsSync3(session.worktree)) {
+  if (!existsSync4(session.worktree)) {
     deleteSession(session.id);
     return;
   }
   const preserved = preserveBranches(run, session);
   if (!cloneHasWork(session.worktree, session.baseSha)) {
-    rmSync5(session.worktree, { recursive: true, force: true });
+    rmSync6(session.worktree, { recursive: true, force: true });
     deleteSession(session.id);
     return;
   }
@@ -1762,12 +2077,21 @@ async function launch({
   if (github.notice)
     console.log(github.notice);
   const hostHome = homedir4();
+  const clientConfigs = buildClientConfigs({
+    host: readHostClientConfigs({ home: hostHome }),
+    url: maesttroUrl()
+  });
+  if (clientConfigs.removed.length > 0) {
+    console.log(`Kept out of the runner as secrets: ${clientConfigs.removed.join(", ")}`);
+  }
+  const clientConfigDir = writeClientConfigDir(clientConfigs.files);
   const { mounts, workdir } = sessionMounts({
     repoRoot: root,
     sessionDir: saved.worktree,
     packageRoot: PACKAGE_ROOT,
     hostHome,
-    stagedPaths: STAGED_PATHS.filter((path) => existsSync3(join10(hostHome, path))),
+    stagedPaths: STAGED_PATHS.filter((path) => existsSync4(join11(hostHome, path))),
+    clientConfigs: clientConfigDir.dir,
     sharedSkills: sharedSkillsDir()
   });
   const sessionEnv = {
@@ -1801,6 +2125,7 @@ async function launch({
   for (const signal of FORWARDED_SIGNALS)
     process.off(signal, forward);
   await github.close();
+  clientConfigDir.remove();
   finishSession(run, saved);
   process.exit(exitCode);
 }
@@ -1925,7 +2250,7 @@ Push? [y/N] `);
 }
 
 // src/sessions-command.ts
-import { existsSync as existsSync4, rmSync as rmSync6 } from "node:fs";
+import { existsSync as existsSync5, rmSync as rmSync7 } from "node:fs";
 function sessionsCommand({ args }) {
   const run = runCommand;
   const root = repoRoot(run, process.cwd());
@@ -1937,7 +2262,7 @@ function sessionsCommand({ args }) {
       process.exitCode = 1;
       return;
     }
-    if (existsSync4(session.worktree)) {
+    if (existsSync5(session.worktree)) {
       const preserved = preserveBranches(run, session);
       const head = cloneHead(session.worktree);
       if (preserved.length === 0 && head?.detached !== undefined && head.detached !== session.baseSha) {
@@ -1945,7 +2270,7 @@ function sessionsCommand({ args }) {
         process.exitCode = 1;
         return;
       }
-      rmSync6(session.worktree, { recursive: true, force: true });
+      rmSync7(session.worktree, { recursive: true, force: true });
       const kept = preserved.length > 0 ? ` Its branches are kept as refs/maesttro/${session.id}/*.` : "";
       console.log(`Removed session ${session.id}.${kept}`);
     } else {
@@ -1960,7 +2285,7 @@ function sessionsCommand({ args }) {
     return;
   }
   for (const session of sessions) {
-    const branches = existsSync4(session.worktree) ? cloneBranches(session.worktree) : undefined;
+    const branches = existsSync5(session.worktree) ? cloneBranches(session.worktree) : undefined;
     const where = branches === undefined ? "clone missing" : branches.length > 0 ? `branches: ${branches.join(", ")}` : "no branches yet";
     console.log(`  ${session.id}  ${session.createdAt.slice(0, 16)}  ${where}`);
   }
@@ -1984,7 +2309,7 @@ async function setup({ args }) {
   console.log(`== maesttro setup ==
 `);
   ensureDocker();
-  console.log("-> Building sandbox image (this pulls node:22-slim + installs CLIs, first run only)...");
+  console.log("-> Building runner image (this pulls node:22-slim + installs CLIs, first run only)...");
   run(`docker build -t ${IMAGE} "${DOCKERFILE_DIR}"`);
   console.log(`
 -> Ensuring persistent volume exists...`);
@@ -2010,10 +2335,10 @@ async function setup({ args }) {
 
 // src/update.ts
 import { execSync as execSync5 } from "node:child_process";
-import { readFileSync as readFileSync6 } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 function installedPackageName() {
-  const manifest = JSON.parse(readFileSync6(join11(PACKAGE_ROOT, "package.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync8(join12(PACKAGE_ROOT, "package.json"), "utf8"));
   return manifest.name;
 }
 function update() {
@@ -2023,11 +2348,11 @@ function update() {
   console.log(`-> Updating ${packageName} package...`);
   execSync5(`npm i -g ${packageName}@latest`, { stdio: "inherit" });
   console.log(`
--> Rebuilding sandbox image with refreshed client configs...`);
+-> Rebuilding runner image with refreshed client configs...`);
   execSync5(`docker build -t ${IMAGE} "${DOCKERFILE_DIR}"`, { stdio: "inherit" });
   console.log(`
 Update complete. Bot identity and your project files are untouched —`);
-  console.log("only the image (client versions + curated configs) was refreshed.");
+  console.log("only the runner image (client versions + curated configs) was refreshed.");
 }
 
 // src/main.ts

package/docker/Dockerfile

@@ -1,4 +1,4 @@
-# git is built from source: Debian ships 2.47 and the sandbox wants a recent
+# git is built from source: Debian ships 2.47 and the runner wants a recent
 # git. Builder matches node:22-slim's Debian so the runtime libs line up.
 FROM debian:bookworm-slim AS git-build
 ARG GIT_VERSION=2.55.0
@@ -35,19 +35,18 @@ RUN apt-get update \
 # System-level, not ~/.gitconfig: /home/agent is the persistent volume and
 # shadows anything baked into home for existing installs
 COPY gitconfig /etc/gitconfig
-COPY sandbox-marker /etc/maesttro/sandbox
+COPY runner-marker /etc/maesttro/runner
 
 # Curated client CLIs — keep in sync with src/clients.ts
 RUN npm install -g \
     @anthropic-ai/claude-code \
-    opencode-ai \
-    @openai/codex
+    opencode-ai
 
 RUN useradd -m -s /bin/bash agent
 USER agent
 # Created as agent so a fresh volume inherits them; otherwise Docker creates
 # ~/.config and ~/.claude as root when it sets up the nested read-only mounts
-RUN mkdir -p /home/agent/.config/opencode /home/agent/.claude /home/agent/.codex
+RUN mkdir -p /home/agent/.config/opencode /home/agent/.claude
 WORKDIR /workspace
 
 # Client configs are applied at container start by `maesttro configure`
@@ -59,4 +58,4 @@ WORKDIR /workspace
 USER root
 COPY --chmod=755 entrypoint.sh /usr/local/bin/maesttro-entrypoint
 ENTRYPOINT ["/usr/local/bin/maesttro-entrypoint"]
-CMD ["claude"]
+CMD ["opencode"]

package/docker/configs/opencode/config.json

@@ -1,3 +1,3 @@
 {
-  "_comment": "Curated default settings for opencode inside the maesttro sandbox. Replace with your actual house defaults."
+  "_comment": "Curated default settings for opencode inside the maesttro runner. Replace with your actual house defaults."
 }

package/docker/runner-marker

@@ -0,0 +1 @@
+maesttro runner

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maesttro",
-  "version": "0.2.0",
-  "description": "Isolated Docker sandbox for running local coding agents (claude, opencode, codex, ...) under a dedicated bot GitHub identity, with curated configs baked in per client.",
+  "version": "0.2.1",
+  "description": "Isolated Docker runner for local coding agents (opencode, claude, ...) under a dedicated bot GitHub identity, with curated configs baked in per client.",
   "type": "module",
   "bin": {
     "maesttro": "dist/maesttro.js"

package/docker/configs/claude/settings.json

@@ -1,3 +0,0 @@
-{
-  "_comment": "Curated default settings for Claude Code inside the maesttro sandbox. Replace with your actual house defaults."
-}

package/docker/configs/codex/config.json

@@ -1,3 +0,0 @@
-{
-  "_comment": "Curated default settings for OpenAI Codex CLI inside the maesttro sandbox. Replace with your actual house defaults."
-}

package/docker/sandbox-marker

@@ -1 +0,0 @@
-maesttro sandbox