maesttro 0.2.0 → 0.3.0

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,109 +717,108 @@ 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 githubMode(value) {
+  return value === "on" || value === "strict" ? value : "off";
+}
+function githubRules(context) {
+  switch (context.github) {
+    case "on":
+      return [
+        `- \`gh\` works for ${context.repo ?? "this repo"} only: issues, pull requests, comments. Its token is short-lived and refreshed for you.`,
+        "- Merging pull requests and deleting remote branches are not possible from here. A person merges."
+      ];
+    case "strict":
+      return [
+        "- This session runs in strict mode: GitHub is disabled on purpose and the runner holds no GitHub credentials. `gh` does not work, and `git fetch` fails for private repositories.",
+        "- Do not look for credentials or ask the user for a token. Local git work still works.",
+        "- When a task needs GitHub (an issue, a pull request, a comment, a review, a label), write out what should be posted and hand it to the user."
+      ];
+    case "off":
+      return [
+        "- GitHub access is unavailable in this session, so `gh` has no token. Local git work still works."
+      ];
+  }
+}
+function afterPushRule(github) {
+  return github === "on" ? "- After the user confirms it is pushed, `git fetch` and continue. Open the pull request with `gh pr create --head <branch>` if asked to." : "- After the user confirms it is pushed, continue on the same branch. The user opens the pull request.";
+}
+function runnerContextFromEnv(env) {
   return {
     sessionId: env.MAESTTRO_SESSION_ID,
     base: env.MAESTTRO_BASE,
     repo: env.MAESTTRO_REPO,
-    githubAccess: env.MAESTTRO_GITHUB === "on"
+    github: githubMode(env.MAESTTRO_GITHUB)
   };
 }
-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.`,
-    "- Merging pull requests and deleting remote branches are not possible from here. A person merges."
-  ] : [
-    "- 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.",
+    afterPushRule(context.github),
     "",
     "## GitHub",
     "",
-    ...github,
+    ...githubRules(context),
     ""
   ].join(`
 `);
 }
 
 // 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 +831,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 +974,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 +989,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 +1033,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 +1060,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 +1107,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 +1130,7 @@ async function doctor() {
       }
     ],
     [
-      "Sandbox image built",
+      "Runner image built",
       () => `built ${execSync2(`docker image inspect ${IMAGE} --format "{{.Created}}"`).toString().trim()}`
     ],
     [
@@ -845,9 +1173,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 +1184,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,12 +1201,15 @@ 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 --strict [client]
+                          Same, in strict mode: no GitHub token reaches the runner, so \`gh\` is off
+  maesttro resume <id>     Continue a kept session in its clone, in the mode it started with
+                          (\`--strict\` or \`--no-strict\` after the id changes it)
   maesttro sessions        List this repo's sessions (\`sessions remove <id>\` to drop one)
   maesttro push [branch]   Push a branch a session created, after showing what goes out
   maesttro list            Show available clients
@@ -886,57 +1217,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 +1280,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 +1298,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 +1396,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,26 +1422,27 @@ 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 })
   };
 }
 
 // src/github-session.ts
 var UNAVAILABLE = "GitHub access unavailable";
 var WITHOUT = "running without gh";
+var STRICT_NOTICE = "Strict mode: no GitHub token in the runner, so `gh` is off. Local git works; push with `maesttro push`.";
 function refusalNotice(code, repo) {
   switch (code) {
     case "broker_unreachable":
@@ -1153,6 +1485,7 @@ function errorCode(error) {
 function withoutGitHub(author, notice) {
   const env = {
     GH_CONFIG_DIR: CONTAINER_GH_CONFIG_DIR,
+    GIT_TERMINAL_PROMPT: "0",
     ...identityEnv(author, undefined)
   };
   return {
@@ -1165,12 +1498,15 @@ function withoutGitHub(author, notice) {
 async function openGitHubSession({
   repo,
   author,
+  strict = false,
   broker,
   login,
   log,
   fetch: fetchImpl = fetch,
   createDir = createSessionDir
 }) {
+  if (strict)
+    return withoutGitHub(author, STRICT_NOTICE);
   if (!repo)
     return withoutGitHub(author);
   const mint = async ({ interactive }) => {
@@ -1247,13 +1583,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 +1681,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 +1698,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 +1723,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 +1741,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 +1749,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 +1772,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 +1804,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 +1891,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 +1958,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 +1974,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 +1992,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 +2009,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 +2032,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;
   }
@@ -1710,6 +2052,18 @@ Session ${session.id} kept. Continue with \`maesttro resume ${session.id}\`.`);
     console.log("You have commits on a detached HEAD. Resume and `git switch -c <name>` to keep them.");
   }
 }
+function isStrict(requested, session) {
+  return requested ?? session.strict ?? false;
+}
+function runnerGitHubMode({
+  strict,
+  repo,
+  notice
+}) {
+  if (strict)
+    return "strict";
+  return notice || !repo ? "off" : "on";
+}
 function exitCodeOf(code, signal) {
   if (code !== null)
     return code;
@@ -1718,7 +2072,8 @@ function exitCodeOf(code, signal) {
 var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 async function launch({
   args,
-  resume
+  resume,
+  strict: requestedStrict
 }) {
   const run = runCommand;
   ensureReady();
@@ -1736,9 +2091,14 @@ async function launch({
     refs: snapshotRefs(run, root),
     sessionId: started.id
   });
-  const saved = { ...started, backup: started.backup ?? backup?.path };
+  const strict = isStrict(requestedStrict, started);
+  const saved = {
+    ...started,
+    backup: started.backup ?? backup?.path,
+    strict
+  };
   saveSession(saved);
-  console.log(`Session ${saved.id}: clone .worktrees/${saved.id} at ${saved.base}${backup ? `, backup ${backup.reused ? "reused" : "written"}` : ""}.`);
+  console.log(`Session ${saved.id}${strict ? " (strict)" : ""}: clone .worktrees/${saved.id} at ${saved.base}${backup ? `, backup ${backup.reused ? "reused" : "written"}` : ""}.`);
   const repo = workspaceRepo(run, root);
   if (repo && !resume) {
     git(run, saved.worktree, [
@@ -1751,6 +2111,7 @@ async function launch({
   const github = await openGitHubSession({
     repo,
     author: await resolveAuthor(root),
+    strict,
     broker: brokerUrl(),
     login: {
       clientId: githubAppClientId(),
@@ -1762,19 +2123,28 @@ 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 = {
     ...github.env,
     MAESTTRO_SESSION_ID: saved.id,
     MAESTTRO_BASE: saved.base,
-    MAESTTRO_GITHUB: github.notice || !repo ? "off" : "on",
+    MAESTTRO_GITHUB: runnerGitHubMode({ strict, repo, notice: github.notice }),
     ...hostIdentityEnv(),
     ...repo ? { MAESTTRO_REPO: repo } : {}
   };
@@ -1801,6 +2171,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 +2296,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 +2308,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 +2316,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,9 +2331,10 @@ 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}`);
+    const mode = session.strict ? "  strict" : "";
+    console.log(`  ${session.id}  ${session.createdAt.slice(0, 16)}  ${where}${mode}`);
   }
   console.log("\n`maesttro resume <id>` continues one; `maesttro sessions remove <id>` removes its clone.");
 }
@@ -1984,7 +2356,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 +2382,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 +2395,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
@@ -2044,11 +2416,48 @@ var defaultCommands = {
   status,
   print: (text) => console.log(text)
 };
+var MODE_FLAGS = {
+  "--strict": true,
+  "--no-strict": false
+};
+function takeModeFlags(args) {
+  let strict;
+  let index = 0;
+  while (index < args.length && Object.hasOwn(MODE_FLAGS, args[index] ?? "")) {
+    strict = MODE_FLAGS[args[index] ?? ""];
+    index++;
+  }
+  return {
+    ...strict === undefined ? {} : { strict },
+    rest: args.slice(index)
+  };
+}
+var NOT_LAUNCHING = new Set([
+  "setup",
+  "update",
+  "doctor",
+  "login",
+  "logout",
+  "status",
+  "push",
+  "sessions",
+  "configure",
+  "list",
+  "help",
+  "--help",
+  "-h"
+]);
 async function main(argv, commands = defaultCommands) {
-  const [command, ...rest] = argv;
+  const leading = takeModeFlags(argv);
+  const [command, ...rest] = leading.rest;
+  const mode = leading.strict === undefined ? {} : { strict: leading.strict };
+  if (leading.strict !== undefined && command !== undefined && NOT_LAUNCHING.has(command)) {
+    commands.print(`--strict and --no-strict apply to launching a session, not to \`${command}\`.`);
+    return;
+  }
   switch (command) {
     case undefined:
-      await commands.launch({ args: [] });
+      await commands.launch({ args: [], ...mode });
       return;
     case "setup":
       await commands.setup({ args: rest });
@@ -2075,12 +2484,19 @@ async function main(argv, commands = defaultCommands) {
       await commands.sessions({ args: rest });
       return;
     case "resume": {
-      const [id, ...clientArgs] = rest;
+      const beforeId = takeModeFlags(rest);
+      const [id, ...afterId] = beforeId.rest;
+      const afterIdFlags = takeModeFlags(afterId);
+      const strict = afterIdFlags.strict ?? beforeId.strict ?? leading.strict;
       if (!id) {
-        commands.print("Usage: maesttro resume <session-id> [client] [args...]");
+        commands.print("Usage: maesttro resume <session-id> [--strict|--no-strict] [client] [args...]");
         return;
       }
-      await commands.launch({ args: clientArgs, resume: id });
+      await commands.launch({
+        args: afterIdFlags.rest,
+        resume: id,
+        ...strict === undefined ? {} : { strict }
+      });
       return;
     }
     case "configure":
@@ -2095,7 +2511,7 @@ async function main(argv, commands = defaultCommands) {
       commands.print(HELP);
       return;
     default:
-      await commands.launch({ args: argv });
+      await commands.launch({ args: leading.rest, ...mode });
   }
 }