0sec-cli 0.22.1 → 0.22.4

package/chunks/{chunk-GOEA3NW6.js → chunk-XODDLNBI.js}

@@ -1,122 +1,987 @@
 #!/usr/bin/env node
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
+import {
+  createConsoleRuntime,
+  createWorkbenchProviderBroker,
+  runSmolvmWorkbench,
+  snapshotSmolvmWorkspace
+} from "./chunk-OAS5SAVZ.js";
+import {
+  TOOL_DEFINITIONS
+} from "./chunk-H6Q2QAIY.js";
 import {
   ANALYTICS_LEVEL_ENV,
-  analyticsPipeline,
+  getSmolvmWorkbenchStatus,
+  isAdmittedSmolvmWorkbench,
   levelAtLeast,
   loadCloudCredentials,
   resolveAnalyticsLevel
-} from "./chunk-OHHCGDJ2.js";
+} from "./chunk-2WWAPKAW.js";
+import {
+  ScopePolicy,
+  aggregateCapabilities,
+  emptyEnablement,
+  getScopeEnforcementState,
+  listInstalledPluginIds,
+  loadableIds,
+  pluginsRootDir,
+  readEnablement,
+  readInstalledPlugin,
+  reconcile,
+  writeEnablement
+} from "./chunk-C6JPA32H.js";
 import {
   DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
-  createPresentationEvent,
+  SERVICE_PLUGIN_CATALOG,
+  VERSION,
+  findingSchema,
   homeStateDir
-} from "./chunk-KAU6NLGP.js";
+} from "./chunk-6KFB6AYN.js";
 
-// packages/cli/src/tui/settings-store.ts
-import { useSyncExternalStore } from "react";
+// packages/cli/src/workbench.ts
+import { chmodSync, existsSync as existsSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync3, realpathSync as realpathSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join8 } from "node:path";
 
-// packages/cli/src/tui/settings.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+// packages/cli/src/workbench-assets.ts
+import { existsSync, lstatSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function currentWorkbenchAssets(moduleUrl = import.meta.url) {
+  let directory = dirname(fileURLToPath(moduleUrl));
+  for (let depth = 0; depth < 5; depth++) {
+    for (const candidate of [directory, join(directory, "dist")]) {
+      const entry = join(candidate, "0.js");
+      if (existsSync(entry) && lstatSync(entry).isFile() && !lstatSync(entry).isSymbolicLink()) return { cliDist: realpathSync(candidate) };
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error("Current workbench CLI distribution is unavailable. Build/install the current CLI bundle before isolated execution; an older image CLI is not used.");
+}
+
+// packages/cli/src/workbench-console-protocol.ts
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var WORKBENCH_FRAME_BYTES = 8 * 1024 * 1024;
+var WORKBENCH_MAX_PENDING = 64;
+function encodeWorkbenchFrame(frame) {
+  const encoded = JSON.stringify(frame);
+  if (Buffer.byteLength(encoded) > WORKBENCH_FRAME_BYTES) throw new Error("Workbench protocol frame exceeds its byte limit");
+  return encoded + "\n";
+}
+var WorkbenchFrameReader = class {
+  #pending = "";
+  push(data, receive) {
+    this.#pending += data;
+    let newline;
+    while ((newline = this.#pending.indexOf("\n")) !== -1) {
+      const line = this.#pending.slice(0, newline);
+      this.#pending = this.#pending.slice(newline + 1);
+      if (!line || Buffer.byteLength(line) > WORKBENCH_FRAME_BYTES) throw new Error("Invalid workbench protocol frame size");
+      const frame = JSON.parse(line);
+      if (!frame || typeof frame !== "object" || Array.isArray(frame) || typeof frame.type !== "string") throw new Error("Invalid workbench protocol frame");
+      const parsed = frame;
+      if (parsed.id !== void 0 && (typeof parsed.id !== "string" || !/^[A-Za-z0-9_-]{1,80}$/.test(parsed.id))) throw new Error("Invalid workbench protocol request id");
+      receive(parsed);
+    }
+    if (Buffer.byteLength(this.#pending) > WORKBENCH_FRAME_BYTES) throw new Error("Workbench protocol input exceeds its byte limit");
+  }
+};
+function guestWorkspacePath(path, workspace) {
+  if (path === "/workspace" || path.startsWith("/workspace/")) {
+    const normalized = resolve(path);
+    if (normalized !== "/workspace" && !normalized.startsWith("/workspace/")) throw new Error("Invalid guest workspace path");
+    return normalized;
+  }
+  if (!isAbsolute(path)) throw new Error("Workbench scope requires an absolute host path");
+  const suffix = relative(workspace, path);
+  if (isAbsolute(suffix) || suffix === ".." || suffix.startsWith(`..${sep}`)) throw new Error("Requested host path is outside the granted workbench workspace");
+  return suffix ? `/workspace/${suffix.split(sep).join("/")}` : "/workspace";
+}
+function hostWorkspacePath(path, workspace) {
+  if (path === "/workspace" || path.startsWith("/workspace/")) {
+    const normalized = resolve(path);
+    if (normalized !== "/workspace" && !normalized.startsWith("/workspace/")) throw new Error("Invalid guest workspace path");
+    return resolve(workspace, relative("/workspace", normalized));
+  }
+  throw new Error("Guest local scope is outside the granted workspace");
+}
+function mapWorkbenchTarget(target, workspace, host = false) {
+  const map = host ? hostWorkspacePath : guestWorkspacePath;
+  if (isAbsolute(target)) return map(target, workspace);
+  if (target.startsWith("source:") && isAbsolute(target.slice(7))) return `source:${map(target.slice(7), workspace)}`;
+  return target;
+}
+function mapWorkbenchCheckpoint(checkpoint, workspace, host) {
+  const result = structuredClone(checkpoint);
+  const map = host ? hostWorkspacePath : guestWorkspacePath;
+  result.workspaceRoot = map(result.workspaceRoot, workspace);
+  result.target = mapWorkbenchTarget(result.target, workspace, host);
+  if (result.localScopePath) result.localScopePath = map(result.localScopePath, workspace);
+  result.deniedLocalPaths = result.deniedLocalPaths.map((path) => {
+    try {
+      return map(path, workspace);
+    } catch {
+      return path;
+    }
+  });
+  if (result.harnessRoot) {
+    throw new Error("Workbench checkpoint handoff with live executable resources is not supported");
+  }
+  return result;
+}
+function serializeWorkbenchConfig(config, workspace) {
+  for (const key of ["pluginHost", "mcpHost", "jevRuntime", "contribution", "developmentSourceRoot", "executablePlugins", "executableEvolutionProfiles"]) {
+    if (config[key] !== void 0) throw new Error(`Host ${key} cannot execute through the workbench controller`);
+  }
+  const result = { workspaceRoot: "/workspace", target: mapWorkbenchTarget(config.target ?? "", workspace) };
+  for (const key of ["role", "tools", "scanId", "maxToolIterations", "allowScanners", "systemPrompt", "autonomyMode", "refineObjective", "allowModelSelfExtension", "costModel", "contextWindowTokens", "compaction", "initialMessages"]) {
+    if (config[key] !== void 0) result[key] = structuredClone(config[key]);
+  }
+  if (config.maxTurnTokens !== void 0 && Number.isFinite(config.maxTurnTokens)) result.maxTurnTokens = config.maxTurnTokens;
+  if (config.scope) result.scope = config.scope.raw;
+  if (config.initialCheckpoint) result.initialCheckpoint = mapWorkbenchCheckpoint(config.initialCheckpoint, workspace, false);
+  if (config.agentMessaging && typeof config.agentMessaging === "object") {
+    const messaging = config.agentMessaging;
+    result.agentMessaging = {
+      selfId: messaging.selfId,
+      selfRole: messaging.selfRole,
+      parentId: messaging.parentId,
+      operatorId: messaging.operatorId,
+      siblingPrefix: messaging.siblingPrefix,
+      siblingChannelEnabled: messaging.siblingChannelEnabled,
+      operatorChannelEnabled: messaging.operatorChannelEnabled,
+      projectPath: "/workspace",
+      homeDir: "/home/zero"
+    };
+  }
+  return result;
+}
+function mapWorkbenchCliArguments(args, workspace) {
+  const targetFlags = /* @__PURE__ */ new Set(["--target", "-t", "--repo"]);
+  const pathFlags = /* @__PURE__ */ new Set(["--scope", "--db-path", "--workspace", "--workspace-root", "--cwd", "--output", "-o", "--config"]);
+  const result = [...args];
+  for (let index = 0; index < result.length; index++) {
+    const argument = result[index];
+    const equal = argument.indexOf("=");
+    const flag = equal < 0 ? argument : argument.slice(0, equal);
+    if (!targetFlags.has(flag) && !pathFlags.has(flag)) continue;
+    const valueIndex = equal < 0 ? index + 1 : index;
+    const value = equal < 0 ? result[valueIndex] : argument.slice(equal + 1);
+    if (value === void 0) throw new Error(`Missing workbench argument for ${flag}`);
+    const mapped = targetFlags.has(flag) ? mapWorkbenchTarget(value, workspace) : isAbsolute(value) ? guestWorkspacePath(value, workspace) : value;
+    result[valueIndex] = equal < 0 ? mapped : `${flag}=${mapped}`;
+    if (equal < 0) index++;
+  }
+  return result;
+}
+
+// packages/cli/src/workbench-console-session.ts
 import { randomUUID } from "node:crypto";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { mkdir, mkdtemp as mkdtemp2, realpath as realpath2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 
-// packages/cli/src/tui/keybindings.ts
-var KEYBINDINGS = [
-  // ── Composer ──────────────────────────────────────────────────────────────
-  {
-    id: "composer.send",
-    keys: "Enter",
-    defaultChords: ["return"],
-    rebindable: false,
-    description: "Send the message or run the highlighted slash command; queues the line when a turn is already in flight.",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.name === "return") { \u2026 send / queue / dequeue }'
-  },
+// packages/cli/src/workbench-plugins.ts
+import { lstat, mkdtemp, realpath, rm } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var GUEST_PLUGIN_ASSETS = "/opt/0-approved-plugins";
+var reservedToolNames = Object.values(TOOL_DEFINITIONS).map((tool) => tool.name);
+var bounds = { maxBytes: 64 * 1024 * 1024, maxFiles: 4096 };
+async function prepareWorkbenchPlugins(project, homeDir) {
+  const root = pluginsRootDir(homeDir);
+  const record = readEnablement(project, homeDir);
+  const views = listInstalledPluginIds(root).flatMap((id) => {
+    const discovered = readInstalledPlugin(root, id, { reservedToolNames });
+    return discovered.ok ? [{ id, version: discovered.plugin.manifest.version, capabilities: aggregateCapabilities(discovered.plugin.manifest) }] : [];
+  });
+  const ids = loadableIds(reconcile(record, views));
+  const approvals = emptyEnablement("/workspace");
+  if (!ids.length) return { approvals, cleanup: async () => {
+  } };
+  const directory = await realpath(await mkdtemp("/tmp/0-guest-plugins-"));
+  const cleanup = () => rm(directory, { recursive: true, force: true });
+  try {
+    let bytes = 0, files = 0;
+    for (const id of ids) {
+      if ((await lstat(join2(root, id))).isSymbolicLink()) throw new Error("Workbench plugins cannot use linked source directories");
+      const snapshot = await snapshotSmolvmWorkspace(join2(root, id), join2(directory, id), { maxBytes: Math.max(1, bounds.maxBytes - bytes), maxFiles: Math.max(1, bounds.maxFiles - files) }, void 0, false, false);
+      bytes += snapshot.bytes;
+      files += snapshot.files.length;
+      if (bytes > bounds.maxBytes || files > bounds.maxFiles) throw new Error("Approved plugins exceed the workbench plugin limits");
+      const copied = readInstalledPlugin(directory, id, { reservedToolNames });
+      if (!copied.ok || !loadableIds(reconcile(record, [{ id, version: copied.plugin.manifest.version, capabilities: aggregateCapabilities(copied.plugin.manifest) }])).includes(id)) throw new Error(`Plugin ${id} changed during workbench preparation; approve its current permissions first`);
+      approvals.enabled[id] = record.enabled[id];
+    }
+    return { directory, approvals, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+async function installWorkbenchPlugins(approvals) {
+  if (!isAdmittedSmolvmWorkbench()) throw new Error("Plugin installation requires admitted VM execution");
+  const ids = Object.keys(approvals.enabled);
+  for (const id of ids) {
+    const discovered = readInstalledPlugin(GUEST_PLUGIN_ASSETS, id, { reservedToolNames });
+    if (!discovered.ok || !loadableIds(reconcile(approvals, [{ id, version: discovered.plugin.manifest.version, capabilities: aggregateCapabilities(discovered.plugin.manifest) }])).includes(id)) throw new Error(`Invalid approved guest plugin: ${id}`);
+    await snapshotSmolvmWorkspace(join2(GUEST_PLUGIN_ASSETS, id), join2(pluginsRootDir(), id), bounds, void 0, false, false);
+  }
+  if (ids.length && !writeEnablement("/workspace", { ...approvals, project: "/workspace" })) throw new Error("Could not save guest plugin approvals");
+}
+
+// packages/cli/src/workbench-service-plugins.ts
+function validateGuestServicePluginConnections(raw, networkGranted) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw) || raw.length > SERVICE_PLUGIN_CATALOG.length) throw new Error("Invalid guest service plugin grants");
+  const ids = /* @__PURE__ */ new Set();
+  const connections = raw.map((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid guest service plugin grant");
+    const row = value;
+    const plugin = SERVICE_PLUGIN_CATALOG.find((item) => item.id === row.id);
+    if (!plugin || ids.has(plugin.id) || row.enabled !== true || !row.fields || typeof row.fields !== "object" || Array.isArray(row.fields)) throw new Error("Invalid guest service plugin grant");
+    ids.add(plugin.id);
+    const fields = row.fields;
+    if (Object.keys(fields).some((key) => !plugin.fields.some((field) => field.key === key))) throw new Error("Invalid guest service plugin field");
+    const output = {};
+    for (const field of plugin.fields) {
+      const value2 = fields[field.key];
+      if (value2 === void 0 && !field.required) continue;
+      if (typeof value2 !== "string" || !value2.trim() || value2.length > 8192 || /[\x00-\x1f\x7f]/.test(value2)) throw new Error("Invalid guest service plugin field");
+      if (field.type === "url") {
+        let url;
+        try {
+          url = new URL(value2);
+        } catch {
+          throw new Error("Invalid guest service plugin URL");
+        }
+        if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) throw new Error("Invalid guest service plugin URL");
+      }
+      output[field.key] = value2;
+    }
+    return { id: plugin.id, enabled: true, fields: output };
+  });
+  if (connections.length && networkGranted !== true) throw new Error("Service plugins require the existing SmolVM network grant. Enable workbench networking before using connected plugins.");
+  return connections;
+}
+function servicePluginSecretRedactor(connections) {
+  const secrets = connections.flatMap((connection) => {
+    const plugin = SERVICE_PLUGIN_CATALOG.find((item) => item.id === connection.id);
+    const values = plugin.fields.filter((field) => field.type === "secret").map((field) => connection.fields[field.key]).filter((value) => !!value);
+    if (connection.id === "jira" && connection.fields.email && connection.fields.token) values.push(Buffer.from(`${connection.fields.email}:${connection.fields.token}`).toString("base64"));
+    return values.flatMap((value) => [value, encodeURIComponent(value), JSON.stringify(value).slice(1, -1)]);
+  }).sort((a, b) => b.length - a.length);
+  return (value) => secrets.reduce((text, secret) => text.split(secret).join("[redacted]"), value);
+}
+
+// packages/cli/src/workbench-console-session.ts
+var EVENTS = /* @__PURE__ */ new Set(["onHarnessUpdate", "onAssistantDelta", "onReasoningDelta", "onToolStart", "onToolResult", "onUsage", "onNotice", "onCompaction"]);
+var DECISIONS = /* @__PURE__ */ new Set(["requestScope", "requestLocalScope", "approveTool", "escalateScopedAudit", "askOperator", "historyList", "historyRead"]);
+function validateOptions(options) {
+  if (options.provider.provider !== "chatgpt-codex" || options.selection.provider && options.selection.provider !== "chatgpt-codex" || !options.provider.models.includes(options.selection.model)) throw new Error("Workbench requires an explicit host provider/model grant");
+  for (const model of Object.values(options.selection.agentModels ?? {})) if (model !== "auto" && !options.provider.models.includes(model)) throw new Error("Workbench worker model is outside the host provider grant");
+  for (const [name, value, max] of [["lifetimeMs", options.lifetimeMs ?? 30 * 6e4, 60 * 6e4], ["idleMs", options.idleMs ?? 5 * 6e4, 15 * 6e4]]) if (!Number.isSafeInteger(value) || value < 1e3 || value > max) throw new Error(`Invalid workbench ${name}`);
+}
+function guestCommand(options, cli) {
+  if (options.guestCommand) return { command: options.guestCommand };
+  const entry = cli ? "run-agent" : "console-agent";
+  if (!options.assets) return { command: ["/usr/local/bin/0", "--workbench-inner", "workbench", entry] };
+  const dependencies = options.assets.dependencies ? "/opt/0-controller-deps/node_modules" : "/opt/0/node_modules";
+  const script = `const fs=require('node:fs');const path='/tmp/0-controller-cli';fs.cpSync('/opt/0-controller-cli',path,{recursive:true});fs.symlinkSync(${JSON.stringify(dependencies)},path+'/node_modules');const child=require('node:child_process').spawn(process.execPath,[path+'/0.js','--workbench-inner','workbench',${JSON.stringify(entry)}],{stdio:'inherit',env:process.env});child.once('error',e=>{console.error(e.message);process.exit(1)});child.once('exit',code=>process.exit(code??1));`;
+  return { command: ["/usr/local/bin/node", "--eval", script], mounts: [{ source: options.assets.cliDist, target: "/opt/0-controller-cli" }, ...options.assets.dependencies ? [{ source: options.assets.dependencies, target: "/opt/0-controller-deps/node_modules" }] : []] };
+}
+var Controller = class {
+  constructor(options, init, cli) {
+    this.options = options;
+    this.init = init;
+    this.cli = cli;
+    validateOptions(options);
+    this.workspace = realpathSync2(options.workbench.workspaceRoot ?? process.cwd());
+    this.execution = { backend: "smolvm", status: "pending", runId: this.runId, workspacePath: this.workspace, guestWorkspacePath: "/workspace", imageDigest: options.workbench.imageDigest, cpus: options.workbench.cpus, memoryMb: options.workbench.memoryMb };
+    this.ready = new Promise((resolve2, reject) => {
+      this.resolveReady = resolve2;
+      this.rejectReady = reject;
+    });
+    void this.ready.catch(() => {
+    });
+  }
+  options;
+  init;
+  cli;
+  abort = new AbortController();
+  runId = randomUUID();
+  workspace;
+  execution;
+  ready;
+  done;
+  resolveReady;
+  rejectReady;
+  input;
+  pending = /* @__PURE__ */ new Map();
+  providers = /* @__PURE__ */ new Map();
+  idle;
+  lifetime;
+  started = false;
+  guestReady = false;
+  startupStderr = "";
+  redact = (value) => value;
+  receive = () => {
+  };
+  decision = async () => null;
+  status(status, message) {
+    const { message: _previous, ...snapshot } = this.execution;
+    this.execution = { ...snapshot, status, ...message ? { message } : {} };
+    this.options.onExecution?.(this.execution);
+  }
+  write(frame) {
+    if (!this.input || this.abort.signal.aborted) throw new Error("Workbench VM is unavailable");
+    this.input.write(encodeWorkbenchFrame(frame));
+  }
+  touch() {
+    clearTimeout(this.idle);
+    this.idle = setTimeout(() => {
+      this.abort.abort(new Error("Workbench idle deadline expired"));
+    }, this.options.idleMs ?? 5 * 6e4);
+    this.idle.unref();
+  }
+  async start() {
+    if (this.started) return this.ready;
+    this.started = true;
+    this.status("pending", "Starting isolated workbench");
+    let stagedPlugins;
+    this.lifetime = setTimeout(() => this.abort.abort(new Error("Workbench lifetime expired")), this.options.lifetimeMs ?? 30 * 6e4);
+    this.lifetime.unref();
+    try {
+      const root = join3(this.options.workbench.stateRoot, "controller-results");
+      await mkdir(root, { recursive: true, mode: 448 });
+      const artifacts = this.options.artifactDirectory ?? await realpath2(await mkdtemp2(join3(root, "run-")));
+      const reader = new WorkbenchFrameReader();
+      const launch = guestCommand(this.options, this.cli);
+      const connections = this.cli ? [] : (await import("./service-plugins-MSK2EQP6.js")).loadServicePluginConnections(this.options.pluginHomeDir).filter((item) => item.enabled);
+      const servicePluginConnections = validateGuestServicePluginConnections(connections, this.options.network);
+      this.redact = servicePluginSecretRedactor(servicePluginConnections);
+      const plugins = stagedPlugins = await prepareWorkbenchPlugins(this.workspace, this.options.pluginHomeDir);
+      this.done = runSmolvmWorkbench({
+        image: this.options.workbench.image,
+        stateRoot: this.options.workbench.stateRoot,
+        workspaceRoot: this.workspace,
+        command: launch.command,
+        environment: { ZERO_PROVIDER: "chatgpt-codex", ZERO_NO_TELEMETRY: "1", DO_NOT_TRACK: "1" },
+        network: this.options.network,
+        tty: false,
+        cpus: this.options.workbench.cpus,
+        memoryMb: this.options.workbench.memoryMb,
+        storageGb: this.options.workbench.storageGb,
+        approvedImages: this.options.workbench.approvedImages,
+        signal: this.abort.signal,
+        workspaceMode: "snapshot",
+        artifactDirectory: artifacts,
+        readOnlyMounts: [...launch.mounts ?? [], ...plugins.directory ? [{ source: plugins.directory, target: GUEST_PLUGIN_ASSETS }] : []],
+        transport: { initialInput: encodeWorkbenchFrame({ type: "init", ...this.init, servicePluginConnections, servicePluginNetworkGranted: this.options.network, pluginApprovals: plugins.approvals, guestSettings: this.options.guestSettings, selection: { ...this.options.selection, provider: "chatgpt-codex" } }), onReady: (input) => {
+          this.input = input;
+        }, onStdout: (data) => reader.push(data, (frame) => this.dispatch(frame)), onStderr: (data) => {
+          this.startupStderr = this.redact(this.startupStderr + data).slice(-4096);
+        } }
+      });
+      this.done = this.done.finally(() => plugins.cleanup());
+      void this.done.then(async (result) => {
+        const error = new Error(this.redact(result.error ?? "Workbench VM exited") + (!this.guestReady && this.startupStderr.trim() ? `: ${this.startupStderr.trim()}` : ""));
+        if (!this.guestReady) this.rejectReady(error);
+        for (const pending of this.pending.values()) pending.reject(error);
+        this.pending.clear();
+        clearTimeout(this.idle);
+        clearTimeout(this.lifetime);
+        for (const pending of this.providers.values()) pending.abort();
+        this.providers.clear();
+        await this.options.provider.close?.();
+        this.status(result.cleanupFailed || result.exitCode !== 0 && !this.abort.signal.aborted ? "failed" : "stopped", result.error ? this.redact(result.error) : void 0);
+      });
+      this.touch();
+      await this.ready;
+    } catch (error) {
+      if (!this.done) {
+        await stagedPlugins?.cleanup();
+        await this.options.provider.close?.();
+      }
+      clearTimeout(this.idle);
+      clearTimeout(this.lifetime);
+      this.abort.abort();
+      this.rejectReady(new Error(this.redact(error instanceof Error ? error.message : "Workbench startup failed")));
+      this.status("failed", this.redact(error instanceof Error ? error.message : "Workbench startup failed"));
+      throw new Error(this.redact(error instanceof Error ? error.message : "Workbench startup failed"));
+    }
+  }
+  dispatch(frame) {
+    if (frame.type === "ready") {
+      if (this.guestReady || frame.platform !== "linux" || frame.workspace !== "/workspace") throw new Error("Invalid workbench guest readiness");
+      this.guestReady = true;
+      this.status("ready");
+      this.resolveReady();
+      return;
+    }
+    if (frame.type === "provider") {
+      void this.provider(frame);
+      return;
+    }
+    if (frame.type === "provider-cancel") {
+      this.providers.get(frame.id)?.abort();
+      return;
+    }
+    if (frame.type === "decision") {
+      if (!DECISIONS.has(String(frame.name)) || !Array.isArray(frame.args)) throw new Error("Invalid guest decision callback");
+      void this.decision(String(frame.name), frame.args).then((value) => this.write({ type: "decision-result", id: frame.id, value }), () => this.write({ type: "decision-result", id: frame.id, error: "Host decision unavailable" })).catch(() => {
+      });
+      return;
+    }
+    if (frame.type === "result" || frame.type === "error") {
+      const pending = this.pending.get(frame.id);
+      this.pending.delete(frame.id);
+      if (frame.type === "error") {
+        const error = new Error(typeof frame.error === "string" ? this.redact(frame.error) : "Guest operation failed");
+        if (!this.guestReady) this.rejectReady(error);
+        pending?.reject(error);
+      } else pending?.resolve(frame.value);
+      return;
+    }
+    this.receive(frame);
+  }
+  async provider(frame) {
+    if (!frame.id || this.providers.size >= 4 || this.providers.has(frame.id)) {
+      this.abort.abort(new Error("Invalid guest provider request"));
+      return;
+    }
+    const envelope = frame.envelope;
+    const abort = new AbortController();
+    this.providers.set(frame.id, abort);
+    const cancel = () => abort.abort();
+    this.abort.signal.addEventListener("abort", cancel, { once: true });
+    try {
+      if (!envelope || envelope.provider !== "chatgpt-codex" || !this.options.provider.models.includes(envelope.model) || typeof envelope.body !== "string") throw new Error("Invalid guest provider envelope");
+      const response = await this.options.provider.request({ provider: envelope.provider, model: envelope.model, body: envelope.body }, abort.signal);
+      this.write({ type: "provider-headers", id: frame.id, status: response.status, contentType: response.headers.get("content-type") ?? "text/event-stream" });
+      let bytes = 0;
+      if (response.body) {
+        const reader = response.body.getReader();
+        try {
+          while (true) {
+            const next = await reader.read();
+            if (next.done) break;
+            const chunk = next.value;
+            bytes += chunk.length;
+            if (bytes > 16 * 1024 * 1024) throw new Error("Provider response exceeds controller limit");
+            for (let offset = 0; offset < chunk.length; offset += 49152) this.write({ type: "provider-chunk", id: frame.id, data: Buffer.from(chunk.subarray(offset, offset + 49152)).toString("base64") });
+          }
+        } finally {
+          await reader.cancel().catch(() => {
+          });
+          reader.releaseLock();
+        }
+      }
+      this.write({ type: "provider-end", id: frame.id });
+    } catch {
+      try {
+        this.write({ type: "provider-error", id: frame.id });
+      } catch {
+      }
+    } finally {
+      this.providers.delete(frame.id);
+      this.abort.signal.removeEventListener("abort", cancel);
+    }
+  }
+  async request(op, values = {}) {
+    await this.start();
+    if (this.pending.size >= WORKBENCH_MAX_PENDING) throw new Error("Workbench request limit reached");
+    this.touch();
+    const id = randomUUID();
+    const result = new Promise((resolve2, reject) => this.pending.set(id, { resolve: resolve2, reject }));
+    try {
+      this.write({ type: "request", id, op, ...values });
+    } catch (error) {
+      this.pending.delete(id);
+      throw error;
+    }
+    return result;
+  }
+  async close() {
+    if (!this.started) {
+      await this.options.provider.close?.();
+      return;
+    }
+    let exited = false;
+    try {
+      await Promise.race([this.request("close"), new Promise((resolve2) => setTimeout(resolve2, 1e3))]);
+      await Promise.race([this.done?.then(() => {
+        exited = true;
+      }), new Promise((resolve2) => setTimeout(resolve2, 1e3))]);
+    } catch {
+    } finally {
+      if (!exited) this.abort.abort();
+      const result = await this.done;
+      if (result?.cleanupFailed) throw new Error(result.error ?? "Workbench teardown could not be confirmed");
+    }
+  }
+};
+function createWorkbenchConsoleSession(options) {
+  const workspace = realpathSync2(options.workbench.workspaceRoot ?? options.config.workspaceRoot ?? process.cwd());
+  const config = { ...options.config, scanId: options.config.scanId ?? `console-${randomUUID()}` };
+  const serial = serializeWorkbenchConfig(config, workspace);
+  const callbacks = [...DECISIONS].filter((name) => name === "historyList" || name === "historyRead" ? !!config.conversationHistory : typeof config[name] === "function");
+  const scopeEnforcement = getScopeEnforcementState(workspace);
+  const controller = new Controller({ ...options, workbench: { ...options.workbench, workspaceRoot: workspace } }, { config: serial, callbacks, scopeEnforcement }, false);
+  let messages = structuredClone(config.initialMessages ?? config.initialCheckpoint?.messages ?? []);
+  let checkpoint = config.initialCheckpoint;
+  let target = config.target ?? "";
+  let scope = config.scope;
+  let localScopePath = config.initialCheckpoint?.localScopePath ?? void 0;
+  let autonomyMode = config.autonomyMode ?? "standard";
+  let systemPrompt = config.systemPrompt ?? "";
+  let tools = config.tools ?? [];
+  let render;
+  let active = false;
+  let findings = [];
+  let engineWorkStarted = false;
+  let lastOutcome;
+  let cleanupPromise;
+  const deferred = [];
+  const queue = (op, value) => {
+    if (!controller.done) {
+      serial[op === "autonomy" ? "autonomyMode" : op] = value;
+      return;
+    }
+    const pending = controller.request(op, { value });
+    deferred.push(pending);
+    void pending.catch(() => {
+    });
+  };
+  controller.decision = async (name, args) => {
+    if (name === "historyList") return config.conversationHistory.list(...args);
+    if (name === "historyRead") return config.conversationHistory.read(...args);
+    const callback = config[name];
+    if (!callback || !callbacks.includes(name)) return null;
+    if (name === "requestLocalScope") {
+      const request = structuredClone(args[0]);
+      for (const key of ["requestedPath", "currentScopePath"]) if (typeof request[key] === "string") request[key] = hostWorkspacePath(request[key], workspace);
+      const value = await callback(request);
+      if (!value) return null;
+      const resolution = value;
+      return { scopePath: guestWorkspacePath(resolution.scopePath, workspace) };
+    }
+    if (name === "requestScope") {
+      const request = args[0];
+      const value = await callback({ ...request, target: mapWorkbenchTarget(String(request.target ?? ""), workspace, true), ...request.currentScope ? { currentScope: new ScopePolicy(request.currentScope.raw) } : {} });
+      if (!value) return null;
+      const resolution = value;
+      return { target: mapWorkbenchTarget(resolution.target, workspace), scope: resolution.scope.raw };
+    }
+    return callback(...args);
+  };
+  controller.receive = (frame) => {
+    if (frame.type === "state") {
+      const state = frame.snapshot;
+      if (!state || state.scanId !== config.scanId || !Array.isArray(state.messages) || state.messages.length > 1e4 || !Array.isArray(state.tools)) throw new Error("Invalid guest session state");
+      messages = state.messages;
+      systemPrompt = String(state.systemPrompt ?? "");
+      tools = state.tools;
+      target = mapWorkbenchTarget(String(state.target ?? ""), workspace, true);
+      scope = state.scope ? new ScopePolicy(state.scope) : void 0;
+      localScopePath = state.localScopePath ? hostWorkspacePath(String(state.localScopePath), workspace) : void 0;
+      autonomyMode = state.autonomyMode;
+      checkpoint = state.checkpoint ? mapWorkbenchCheckpoint(state.checkpoint, workspace, true) : void 0;
+    } else if (frame.type === "event") {
+      if (!EVENTS.has(String(frame.name)) || !Array.isArray(frame.args)) throw new Error("Invalid guest render callback");
+      const callback = render?.[frame.name];
+      callback?.(...frame.args);
+    } else if (frame.type === "findings") {
+      if (!Array.isArray(frame.findings) || frame.findings.length > 1e3) throw new Error("Invalid guest findings");
+      findings = frame.findings.map((finding) => findingSchema.parse(finding));
+    } else throw new Error("Unsupported guest controller event");
+  };
+  return {
+    scanId: config.scanId,
+    ready: Promise.resolve(),
+    get execution() {
+      return controller.execution;
+    },
+    get systemPrompt() {
+      return systemPrompt;
+    },
+    get tools() {
+      return tools;
+    },
+    get messages() {
+      return messages;
+    },
+    get target() {
+      return target;
+    },
+    get scope() {
+      return scope;
+    },
+    get localScopePath() {
+      return localScopePath;
+    },
+    get autonomyMode() {
+      return autonomyMode;
+    },
+    scopeEnforcement,
+    setAutonomyMode(mode) {
+      autonomyMode = mode;
+      queue("autonomy", mode);
+    },
+    configureEngagement(selection) {
+      if (selection.target !== void 0) target = selection.target;
+      if (selection.scope !== void 0) scope = selection.scope ?? void 0;
+      const value = { ...selection.target === void 0 ? {} : { target: mapWorkbenchTarget(selection.target, workspace) }, ...selection.scope === void 0 ? {} : { scope: selection.scope?.raw ?? null } };
+      if (!controller.done) Object.assign(serial, value);
+      else queue("configure", value);
+    },
+    configureWorkspace(path) {
+      if (realpathSync2(path) !== workspace) throw new Error("The SmolVM workspace grant is fixed for this chat; start a new chat to change it");
+    },
+    reconfigureRuntime(selection) {
+      if (selection.env !== void 0 || selection.provider && selection.provider !== "chatgpt-codex" || selection.model && !options.provider.models.includes(selection.model) || Object.values(selection.agentModels ?? {}).some((model) => model !== "auto" && !options.provider.models.includes(model))) throw new Error("Runtime selection is outside workbench provider grant");
+      Object.assign(options.selection, selection);
+      if (controller.done) queue("reconfigure", selection);
+    },
+    clearConversation() {
+      messages = [];
+      checkpoint = void 0;
+      if (!controller.done) {
+        serial.initialMessages = [];
+        delete serial.initialCheckpoint;
+      } else queue("clear");
+    },
+    async send(text, callbacks2, sendOptions) {
+      if (active) throw new Error("Workbench turn already active");
+      active = true;
+      render = callbacks2;
+      let cancelTimer;
+      const cancel = () => {
+        try {
+          controller.write({ type: "cancel" });
+        } catch {
+        }
+        cancelTimer = setTimeout(() => controller.abort.abort(new Error("Operator cancelled workbench turn")), 2e3);
+      };
+      sendOptions?.signal?.addEventListener("abort", cancel, { once: true });
+      try {
+        await Promise.all(deferred.splice(0));
+        await controller.start();
+        if (sendOptions?.signal?.aborted) cancel();
+        controller.status("running");
+        engineWorkStarted = true;
+        lastOutcome = await controller.request("send", { text, generateTitle: sendOptions?.generateTitle });
+        return lastOutcome;
+      } finally {
+        clearTimeout(cancelTimer);
+        active = false;
+        render = void 0;
+        sendOptions?.signal?.removeEventListener("abort", cancel);
+        if (!controller.abort.signal.aborted && controller.execution.status !== "stopped" && controller.execution.status !== "failed") controller.status("ready");
+      }
+    },
+    async stopPersistentAgent(agentId) {
+      return await controller.request("stopWorker", { agentId });
+    },
+    async stopPersistentAgents() {
+      if (controller.done) await controller.request("stopWorkers");
+    },
+    exportCheckpoint() {
+      if (active || !checkpoint) throw new Error("No quiescent VM checkpoint is available");
+      return structuredClone(checkpoint);
+    },
+    async prepareHandoff() {
+      if (active) throw new Error("Cannot hand off active VM turn");
+      if (!controller.done) return {};
+      return await controller.request("handoff");
+    },
+    cleanup() {
+      return cleanupPromise ??= (async () => {
+        await controller.close();
+        if (engineWorkStarted && controller.done) await options.onFindings?.(findings, { outcome: lastOutcome });
+      })();
+    }
+  };
+}
+async function runWorkbenchCli(options) {
+  if (options.args.length > 512 || options.args.some((arg) => typeof arg !== "string" || arg.includes("\0"))) throw new Error("Invalid workbench CLI argv");
+  const controller = new Controller(options, { args: options.args }, true);
+  let exitCode;
+  controller.receive = (frame) => {
+    if ((frame.type === "stdout" || frame.type === "stderr") && typeof frame.data === "string") (frame.type === "stdout" ? options.onStdout : options.onStderr)?.(Buffer.from(frame.data, "base64").toString("utf8"));
+    else if (frame.type === "exit" && Number.isSafeInteger(frame.code)) {
+      exitCode = frame.code;
+    } else throw new Error("Invalid CLI guest event");
+  };
+  const cancel = () => controller.abort.abort();
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  try {
+    if (options.signal?.aborted) cancel();
+    await controller.start();
+    controller.status("running");
+    const result = await controller.done;
+    return { ...result, exitCode: exitCode ?? result.exitCode };
+  } finally {
+    options.signal?.removeEventListener("abort", cancel);
+  }
+}
+
+// packages/cli/src/tui/provider-status.ts
+var PROVIDER_DEFS = [
   {
-    id: "composer.newline",
-    keys: "Shift+Enter",
-    defaultChords: ["shift+return"],
-    rebindable: false,
-    description: "Insert a newline instead of sending (terminals without the kitty protocol fall through to send).",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.name === "return" && key.shift) setComposerText(`${\u2026}\\n`)'
+    id: "chatgpt-codex",
+    label: "ChatGPT Codex",
+    methods: ["oauth"],
+    // OAuth, not an API key. Both tokens are accepted and the access token is
+    // read first (llm-api.ts L874-875, L1386-1394), so it leads the list.
+    envVars: ["ZERO_CHATGPT_ACCESS_TOKEN", "ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"],
+    fileSource: "~/.codex/auth.json (override with ZERO_CHATGPT_AUTH_FILE)",
+    hint: "run `codex login` to write ~/.codex/auth.json, or invoke 0 with env ZERO_CHATGPT_OAUTH_REFRESH_TOKEN=..."
   },
   {
-    id: "composer.complete-command",
-    keys: "Tab",
-    defaultChords: ["tab"],
-    rebindable: false,
-    description: "Complete the highlighted slash command in the command menu.",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.name === "tab") setComposerText(completionFor(selectedSlashCommand, \u2026))'
+    id: "deepseek",
+    label: "DeepSeek",
+    methods: ["api-key"],
+    envVars: ["DEEPSEEK_API_KEY"],
+    hint: "set DEEPSEEK_API_KEY (endpoint override: DEEPSEEK_BASE_URL)"
   },
   {
-    id: "composer.edit-queued",
-    keys: "Ctrl+Y",
-    defaultChords: ["ctrl+y"],
-    rebindable: true,
-    description: "Pull the most recently queued message back into the composer to edit, re-send, or drop.",
-    category: "Composer",
-    handler: 'if (matchesBinding(key, "composer.edit-queued", \u2026) && queuedRef.current.length > 0) \u2026'
+    id: "openrouter",
+    label: "OpenRouter",
+    // OAuth (PKCE browser sign-in) is preferred; a pasted OPENROUTER_API_KEY
+    // remains a secondary path. The browser flow provisions a durable
+    // `sk-or-...` key and stores it as an api_key record written to
+    // OPENROUTER_API_KEY (envVars[0], which llm-api already reads), so — unlike
+    // the xai/kimi device flows — the credential is a key, not OAuth tokens.
+    methods: ["oauth", "api-key"],
+    envVars: ["OPENROUTER_API_KEY"],
+    hint: "sign in with your OpenRouter account, or set OPENROUTER_API_KEY=sk-or-... from openrouter.ai/keys"
   },
   {
-    id: "composer.delete-word",
-    keys: "Ctrl+W / Alt+Backspace",
-    defaultChords: ["ctrl+w", "option+backspace"],
-    rebindable: false,
-    description: "Delete the word before the cursor.",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.ctrl && key.name === "w") / if (key.name === "backspace" && (key.meta || key.option || key.ctrl)) \u2192 deletePreviousWord'
+    id: "azure",
+    label: "Azure OpenAI",
+    methods: ["api-key"],
+    // Only the Azure key authenticates; the deployment URL comes from
+    // AZURE_OPENAI_BASE_URL / OPENAI_BASE_URL / ~/.codex/config.toml
+    // (L1435-1445). A key with no reachable base URL still counts as
+    // configured here because detectProvider selects azure on the key alone.
+    envVars: ["AZURE_OPENAI_API_KEY"],
+    hint: "set AZURE_OPENAI_API_KEY plus AZURE_OPENAI_BASE_URL (or [model_providers.azure] in ~/.codex/config.toml)"
   },
   {
-    id: "composer.delete-to-start",
-    keys: "Ctrl+U",
-    defaultChords: ["ctrl+u"],
-    rebindable: false,
-    description: "Delete from the cursor to the start of the line.",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.ctrl && key.name === "u") \u2192 deleteToLineStart'
+    id: "openai",
+    label: "OpenAI",
+    methods: ["api-key"],
+    envVars: ["OPENAI_API_KEY"],
+    hint: "set OPENAI_API_KEY=sk-... from platform.openai.com/api-keys"
   },
   {
-    id: "composer.accept-suggestion",
-    keys: "Right",
-    defaultChords: ["right"],
-    rebindable: false,
-    description: "Accept the inline autosuggestion, filling the ghost suffix into the draft without sending.",
-    category: "Composer",
-    lockReason: "text entry",
-    handler: 'if (key.name === "right") { const suffix = suggestCompletion(...); if (suffix) setComposerText(`${\u2026}${suffix}`) }'
+    id: "z-ai",
+    label: "Z.ai GLM",
+    methods: ["api-key"],
+    envVars: ["Z_AI_API_KEY"],
+    hint: "set Z_AI_API_KEY from your Z.ai Coding Plan (endpoint override: Z_AI_BASE_URL)"
   },
-  // ── Navigation ──────────────────────────────────────────────────────────────
   {
-    id: "nav.palette",
-    keys: "Ctrl+P / Ctrl+K",
-    defaultChords: ["ctrl+p", "ctrl+k"],
-    rebindable: true,
-    description: "Open the slash-command palette.",
-    category: "Navigation",
-    handler: 'if (matchesBinding(key, "nav.palette", \u2026)) setComposerText("/")'
+    id: "kimi",
+    label: "Moonshot Kimi",
+    // OAuth (device sign-in) is preferred; a pasted KIMI_API_KEY remains a
+    // secondary path. The OAuth access token is written to KIMI_API_KEY as a
+    // Bearer (llm-api.ts reads it there, no change needed), and the refresh
+    // token to the 0-owned var so the store can round-trip it.
+    methods: ["oauth", "api-key"],
+    envVars: ["KIMI_API_KEY", "ZERO_KIMI_OAUTH_REFRESH_TOKEN"],
+    hint: "sign in with your Kimi account, or set KIMI_API_KEY from your Kimi coding plan (endpoint override: KIMI_BASE_URL)"
   },
   {
-    id: "nav.history-prev",
-    keys: "Up",
-    defaultChords: ["up"],
-    rebindable: false,
-    description: "Recall the previous submitted message into the composer (also moves the selection in menus and overlays).",
-    category: "Navigation",
-    lockReason: "modal",
-    handler: 'if (key.name === "up") recallComposerHistory("up")'
+    id: "qwen",
+    label: "Alibaba Qwen",
+    methods: ["api-key"],
+    envVars: ["QWEN_API_KEY"],
+    hint: "set QWEN_API_KEY from Alibaba Model Studio (endpoint override: QWEN_BASE_URL)"
   },
   {
-    id: "nav.history-next",
-    keys: "Down",
+    id: "xai",
+    label: "xAI Grok",
+    // OAuth (device sign-in) is preferred; a pasted XAI_API_KEY remains a
+    // secondary path. The OAuth access token is written to XAI_API_KEY as a
+    // Bearer (llm-api.ts reads it there, no change needed), and the refresh
+    // token to the 0-owned var so the store can round-trip it.
+    methods: ["oauth", "api-key"],
+    envVars: ["XAI_API_KEY", "ZERO_XAI_OAUTH_REFRESH_TOKEN"],
+    hint: "sign in with your xAI account, or set XAI_API_KEY from console.x.ai (endpoint override: XAI_BASE_URL)"
+  },
+  {
+    id: "opencode",
+    label: "OpenCode Zen",
+    methods: ["api-key"],
+    envVars: ["OPENCODE_API_KEY"],
+    hint: "set OPENCODE_API_KEY from opencode.ai/auth (endpoint override: OPENCODE_BASE_URL)"
+  },
+  {
+    id: "copilot",
+    label: "GitHub Copilot",
+    // OAuth only (device-code sign-in). The GitHub device-flow access token is
+    // written to ZERO_COPILOT_GITHUB_TOKEN (envVars[0]) and sent directly as a
+    // Bearer to api.githubcopilot.com — no secondary exchange, no refresh, so
+    // there is no refresh-token env var.
+    methods: ["oauth"],
+    envVars: ["ZERO_COPILOT_GITHUB_TOKEN"],
+    hint: "sign in with your GitHub Copilot account (device sign-in), or set ZERO_COPILOT_GITHUB_TOKEN=... (endpoint override: COPILOT_BASE_URL)"
+  },
+  {
+    id: "google",
+    label: "Google Gemini (Code Assist)",
+    // OAuth only (PKCE browser sign-in — the Gemini CLI flow). The minted
+    // access token is written to ZERO_GEMINI_ACCESS_TOKEN (envVars[0]) and the
+    // refresh token to ZERO_GEMINI_OAUTH_REFRESH_TOKEN (the /REFRESH/i var); the
+    // runtime refreshes on demand against oauth2.googleapis.com. There is no
+    // pasted-key equivalent — Code Assist authenticates only via OAuth.
+    methods: ["oauth"],
+    envVars: ["ZERO_GEMINI_ACCESS_TOKEN", "ZERO_GEMINI_OAUTH_REFRESH_TOKEN"],
+    hint: "sign in with your Google account (browser sign-in), or set ZERO_GEMINI_OAUTH_REFRESH_TOKEN=... for Gemini Code Assist (project override: GOOGLE_CLOUD_PROJECT / ZERO_GEMINI_PROJECT)"
+  },
+  {
+    id: "anthropic",
+    label: "Anthropic",
+    // API key only for now. The schema supports OAuth, but Anthropic/Claude
+    // subscription OAuth is deliberately deferred — do not add "oauth" here
+    // until that workstream lands.
+    methods: ["api-key"],
+    envVars: ["ANTHROPIC_API_KEY"],
+    hint: "set ANTHROPIC_API_KEY=sk-ant-... from console.anthropic.com"
+  }
+];
+function primaryMethod(methods) {
+  return methods[0] ?? "api-key";
+}
+var PROVIDERS = PROVIDER_DEFS.map((def) => ({
+  ...def,
+  auth: primaryMethod(def.methods)
+}));
+function providerSupportsMethod(providerId, method) {
+  const info = PROVIDERS.find((candidate) => candidate.id === providerId);
+  return info !== void 0 && info.methods.includes(method);
+}
+function hasCredential(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function satisfyingVar(info, env) {
+  return info.envVars.find((name) => hasCredential(env[name]));
+}
+function providerStates(env) {
+  return PROVIDERS.map((info) => {
+    const via = satisfyingVar(info, env);
+    return via === void 0 ? { ...info, configured: false } : { ...info, configured: true, via };
+  });
+}
+function isProviderConfigured(providerId, env) {
+  const info = PROVIDERS.find((candidate) => candidate.id === providerId);
+  return info !== void 0 && satisfyingVar(info, env) !== void 0;
+}
+
+// packages/cli/src/tui/settings.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { dirname as dirname3, join as join6 } from "node:path";
+
+// packages/cli/src/tui/keybindings.ts
+var KEYBINDINGS = [
+  // ── Composer ──────────────────────────────────────────────────────────────
+  {
+    id: "composer.send",
+    keys: "Enter",
+    defaultChords: ["return"],
+    rebindable: false,
+    description: "Send the message or run the highlighted slash command; queues the line when a turn is already in flight.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "return") { \u2026 send / queue / dequeue }'
+  },
+  {
+    id: "composer.newline",
+    keys: "Shift+Enter",
+    defaultChords: ["shift+return"],
+    rebindable: false,
+    description: "Insert a newline instead of sending (terminals without the kitty protocol fall through to send).",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "return" && key.shift) setComposerText(`${\u2026}\\n`)'
+  },
+  {
+    id: "composer.complete-command",
+    keys: "Tab",
+    defaultChords: ["tab"],
+    rebindable: false,
+    description: "Complete the highlighted slash command in the command menu.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "tab") setComposerText(completionFor(selectedSlashCommand, \u2026))'
+  },
+  {
+    id: "composer.edit-queued",
+    keys: "Ctrl+Y",
+    defaultChords: ["ctrl+y"],
+    rebindable: true,
+    description: "Pull the most recently queued message back into the composer to edit, re-send, or drop.",
+    category: "Composer",
+    handler: 'if (matchesBinding(key, "composer.edit-queued", \u2026) && queuedRef.current.length > 0) \u2026'
+  },
+  {
+    id: "composer.delete-word",
+    keys: "Ctrl+W / Alt+Backspace",
+    defaultChords: ["ctrl+w", "option+backspace"],
+    rebindable: false,
+    description: "Delete the word before the cursor.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.ctrl && key.name === "w") / if (key.name === "backspace" && (key.meta || key.option || key.ctrl)) \u2192 deletePreviousWord'
+  },
+  {
+    id: "composer.delete-to-start",
+    keys: "Ctrl+U",
+    defaultChords: ["ctrl+u"],
+    rebindable: false,
+    description: "Delete from the cursor to the start of the line.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.ctrl && key.name === "u") \u2192 deleteToLineStart'
+  },
+  {
+    id: "composer.accept-suggestion",
+    keys: "Right",
+    defaultChords: ["right"],
+    rebindable: false,
+    description: "Accept the inline autosuggestion, filling the ghost suffix into the draft without sending.",
+    category: "Composer",
+    lockReason: "text entry",
+    handler: 'if (key.name === "right") { const suffix = suggestCompletion(...); if (suffix) setComposerText(`${\u2026}${suffix}`) }'
+  },
+  // ── Navigation ──────────────────────────────────────────────────────────────
+  {
+    id: "nav.palette",
+    keys: "Ctrl+P / Ctrl+K",
+    defaultChords: ["ctrl+p", "ctrl+k"],
+    rebindable: true,
+    description: "Open the slash-command palette.",
+    category: "Navigation",
+    handler: 'if (matchesBinding(key, "nav.palette", \u2026)) setComposerText("/")'
+  },
+  {
+    id: "nav.history-prev",
+    keys: "Up",
+    defaultChords: ["up"],
+    rebindable: false,
+    description: "Recall the previous submitted message into the composer (also moves the selection in menus and overlays).",
+    category: "Navigation",
+    lockReason: "modal",
+    handler: 'if (key.name === "up") recallComposerHistory("up")'
+  },
+  {
+    id: "nav.history-next",
+    keys: "Down",
     defaultChords: ["down"],
     rebindable: false,
     description: "Recall the next message, or \u2014 on an empty composer with workers running \u2014 drop into the active-subagents list.",
@@ -416,11 +1281,11 @@ function sanitizeKeybindingOverrides(raw, bindings = KEYBINDINGS) {
 
 // packages/cli/src/tui/themes.ts
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join5 } from "node:path";
 
 // packages/cli/src/tui/user-themes.ts
 import { readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join as join4 } from "node:path";
 function coerceUserTheme(id, raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     return { ok: false, reason: "file is not a JSON object" };
@@ -468,7 +1333,7 @@ function loadUserThemes(dir) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync(join(dir, file), "utf8"));
+      parsed = JSON.parse(readFileSync(join4(dir, file), "utf8"));
     } catch (err) {
       rejected.push({
         name: id,
@@ -1221,11 +2086,11 @@ function degradePalette(palette, depth) {
   return out;
 }
 var INSTALLED_THEMES_DIRNAME = "themes";
-function installedThemesDir(homeDir2) {
-  return join2(homeStateDir(homeDir2), INSTALLED_THEMES_DIRNAME);
+function installedThemesDir(homeDir) {
+  return join5(homeStateDir(homeDir), INSTALLED_THEMES_DIRNAME);
 }
-function installedThemeFilePath(id, homeDir2) {
-  return join2(installedThemesDir(homeDir2), `${id}.json`);
+function installedThemeFilePath(id, homeDir) {
+  return join5(installedThemesDir(homeDir), `${id}.json`);
 }
 var THEME_ID_RE = /^[a-z][a-z0-9]*([._-][a-z0-9]+)*$/;
 var THEME_ID_MAX = 64;
@@ -1234,36 +2099,36 @@ function isSafeThemeId(id) {
 }
 var installedThemes = null;
 var installedFromHome;
-function readInstalledThemes(homeDir2) {
+function readInstalledThemes(homeDir) {
   const out = /* @__PURE__ */ new Map();
-  for (const entry of loadUserThemes(installedThemesDir(homeDir2)).valid) {
+  for (const entry of loadUserThemes(installedThemesDir(homeDir)).valid) {
     out.set(entry.name, entry);
   }
   return out;
 }
-function ensureInstalledThemesLoaded(homeDir2) {
-  if (installedThemes === null || installedFromHome !== homeDir2) {
-    installedThemes = readInstalledThemes(homeDir2);
-    installedFromHome = homeDir2;
+function ensureInstalledThemesLoaded(homeDir) {
+  if (installedThemes === null || installedFromHome !== homeDir) {
+    installedThemes = readInstalledThemes(homeDir);
+    installedFromHome = homeDir;
   }
   return installedThemes;
 }
-function reloadInstalledThemes(homeDir2) {
-  installedThemes = readInstalledThemes(homeDir2);
-  installedFromHome = homeDir2;
+function reloadInstalledThemes(homeDir) {
+  installedThemes = readInstalledThemes(homeDir);
+  installedFromHome = homeDir;
   return installedThemes;
 }
-function installedThemeEntries(homeDir2) {
-  return [...ensureInstalledThemesLoaded(homeDir2).values()];
+function installedThemeEntries(homeDir) {
+  return [...ensureInstalledThemesLoaded(homeDir).values()];
 }
-function allThemeNames(homeDir2) {
-  return [...THEME_NAMES, ...ensureInstalledThemesLoaded(homeDir2).keys()];
+function allThemeNames(homeDir) {
+  return [...THEME_NAMES, ...ensureInstalledThemesLoaded(homeDir).keys()];
 }
 function isKnownTheme(value) {
   if (isThemeName(value)) return true;
   return typeof value === "string" && installedThemes !== null && installedThemes.has(value);
 }
-function writeInstalledTheme(file, homeDir2) {
+function writeInstalledTheme(file, homeDir) {
   if (!isSafeThemeId(file.id)) return { ok: false, error: `unsafe theme id ${JSON.stringify(file.id)}` };
   if (isThemeName(file.id)) return { ok: false, error: `"${file.id}" is a built-in theme name and cannot be overridden` };
   const issues = validateTheme(file.palette);
@@ -1271,8 +2136,8 @@ function writeInstalledTheme(file, homeDir2) {
     return { ok: false, error: `invalid palette: ${issues.map((i) => i.message).join("; ")}` };
   }
   try {
-    const path = installedThemeFilePath(file.id, homeDir2);
-    mkdirSync(dirname(path), { recursive: true });
+    const path = installedThemeFilePath(file.id, homeDir);
+    mkdirSync(dirname2(path), { recursive: true });
     const body = {
       id: file.id,
       ...file.label !== void 0 ? { label: file.label } : {},
@@ -1287,13 +2152,13 @@ function writeInstalledTheme(file, homeDir2) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
-function removeInstalledTheme(id, homeDir2) {
+function removeInstalledTheme(id, homeDir) {
   if (!isSafeThemeId(id)) return { ok: false, error: `unsafe theme id ${JSON.stringify(id)}` };
   if (isThemeName(id)) return { ok: false, error: `"${id}" is a built-in theme and cannot be removed` };
-  const cache = ensureInstalledThemesLoaded(homeDir2);
+  const cache = ensureInstalledThemesLoaded(homeDir);
   if (!cache.has(id)) return { ok: false, error: `theme "${id}" is not installed` };
   try {
-    rmSync(installedThemeFilePath(id, homeDir2), { force: true });
+    rmSync(installedThemeFilePath(id, homeDir), { force: true });
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -1302,15 +2167,15 @@ function removeInstalledTheme(id, homeDir2) {
 
 // packages/cli/src/tui/settings.ts
 var THEME_CHOICES = [...THEME_NAMES];
-function syncThemeChoices(homeDir2) {
-  ensureInstalledThemesLoaded(homeDir2);
-  THEME_CHOICES.splice(0, THEME_CHOICES.length, ...allThemeNames(homeDir2));
+function syncThemeChoices(homeDir) {
+  ensureInstalledThemesLoaded(homeDir);
+  THEME_CHOICES.splice(0, THEME_CHOICES.length, ...allThemeNames(homeDir));
 }
 var DEFS = [
   {
     key: "showStatusBar",
     label: "Status bar",
-    description: "Optional bottom-bar telemetry: model, working directory, git state and token counters. Permission mode and the turn timer share that row and stay visible with this off.",
+    description: "Bottom bar with model, folder, git and token counts. Permission mode and turn timer always show.",
     kind: "boolean",
     default: true,
     group: "Display"
@@ -1326,7 +2191,7 @@ var DEFS = [
   {
     key: "composerSuggestions",
     label: "Composer autosuggestions",
-    description: "Inline ghost-text continuation from your submitted-message history, accepted with the Right arrow at end-of-input.",
+    description: "Ghost-text suggestions from your past messages. Right arrow accepts.",
     kind: "boolean",
     default: true,
     group: "Display"
@@ -1334,7 +2199,7 @@ var DEFS = [
   {
     key: "mouseSupport",
     label: "Mouse support",
-    description: "Scroll-wheel scrolling, click-to-select on list rows, and clickable hints. Turn off for a keyboard-only console where the terminal's own text selection works.",
+    description: "Scroll, click rows and hints. Turn off to use your terminal's own text selection.",
     kind: "boolean",
     default: true,
     group: "Display"
@@ -1350,7 +2215,7 @@ var DEFS = [
   {
     key: "showRuntimeNotices",
     label: "Runtime notices",
-    description: "Surface runtime stdout/stderr as transcript notices.",
+    description: "Show engine output (stdout/stderr) in the conversation.",
     kind: "boolean",
     default: true,
     group: "Transcript"
@@ -1382,7 +2247,7 @@ var DEFS = [
   {
     key: "showObjective",
     label: "Objective",
-    description: `Bottom-bar "objective" pill: a short "what am I working on" title derived from the session's first message.`,
+    description: "Short title for the current session in the bottom bar.",
     kind: "boolean",
     default: true,
     group: "Display"
@@ -1390,7 +2255,7 @@ var DEFS = [
   {
     key: "showScope",
     label: "Scope",
-    description: "Show the configured multi-host scope and exclusions. An absent scope is distinct from an explicit empty scope.",
+    description: "Show the target scope and exclusions. No scope is different from an empty scope.",
     kind: "boolean",
     default: true,
     group: "Display"
@@ -1441,7 +2306,7 @@ var DEFS = [
   {
     key: "transcriptStyle",
     label: "Transcript style",
-    description: "Minimal (the default) drops every bubble and box: your turns carry a thin coloured accent rail and the answer flows as plain body text, the OpenCode / oh-my-pi flat look. Bubble right-aligns your messages against left-aligned answers and titles each card on its border. Balanced: only your own messages are bubbled; everything else is flat. Rail, plain, compact and document offer alternative transcript layouts.",
+    description: "How the conversation looks. Minimal (default) is flat text; Bubble and Balanced add message bubbles; Rail, plain, compact and document are alternatives.",
     kind: "enum",
     default: "minimal",
     choices: ["minimal", "rail", "bubble", "balanced", "plain", "compact", "document"],
@@ -1450,7 +2315,7 @@ var DEFS = [
   {
     key: "roleLabelStyle",
     label: "Role label",
-    description: 'Labels your messages as "You"; assistant replies stay unlabeled. Full and short include the optional age, glyph shows the name alone, and off hides the label.',
+    description: 'Label your messages as "You". Full and short add the age, glyph shows the name only, off hides it.',
     kind: "enum",
     default: "off",
     choices: ["full", "short", "glyph", "off"],
@@ -1468,7 +2333,7 @@ var DEFS = [
   {
     key: "richToolCards",
     label: "Rich tool cards",
-    description: "Draw bash/run_command output and apply_patch edits as bordered cards (command + output + wall/exit footer, or an edit header + diff) instead of a plain line.",
+    description: "Show command output and file edits as cards instead of one line.",
     kind: "boolean",
     default: true,
     group: "Transcript"
@@ -1476,7 +2341,7 @@ var DEFS = [
   {
     key: "transcriptDetail",
     label: "Transcript detail",
-    description: "Fold tool and reasoning steps. Output previews stay within 20 lines; click a card for retained detail.",
+    description: "Fold tool and reasoning steps. Click a card to see more.",
     kind: "enum",
     default: "collapsed",
     choices: ["collapsed", "expanded"],
@@ -1485,7 +2350,7 @@ var DEFS = [
   {
     key: "autoCompaction",
     label: "Auto-compaction",
-    description: "Automatically summarise older turns when the conversation nears the model's context window.",
+    description: "Summarise older turns when the context window gets full.",
     kind: "boolean",
     default: true,
     group: "Context"
@@ -1502,7 +2367,7 @@ var DEFS = [
   {
     key: "theme",
     label: "Theme",
-    description: "Colour palette. Slate (neutral grey, default) and Midnight (deep blue-black) and Carbon (warm dark), Standard/Paper (light), plus Contrast, Mono Dim and ANSI 16 for 16-colour terminals. Drop validated palettes in ~/.0/themes to add your own.",
+    description: "Colour theme. Contrast, Mono Dim and ANSI 16 suit 16-colour terminals. Add your own in ~/.0/themes.",
     kind: "enum",
     default: DEFAULT_THEME_NAME,
     choices: THEME_CHOICES,
@@ -1511,7 +2376,7 @@ var DEFS = [
   {
     key: "allowModelSelfExtension",
     label: "Model self-extension",
-    description: "Allow new sessions to add sandboxed tools and live harness generations. Existing disabled sessions stay disabled. Trusted harness code requires separate workspace trust; development engine updates are controlled independently.",
+    description: "Let new sessions add sandboxed tools. Sessions started with this off stay off. Trusted tool code also needs workspace trust; engine updates are a separate setting.",
     kind: "boolean",
     default: DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
     group: "Security"
@@ -1519,7 +2384,7 @@ var DEFS = [
   {
     key: "allowDevSourceUpdates",
     label: "Development engine updates",
-    description: "0dev only. Reload changed core engine code between turns without losing the session. Runs with host privileges, including credential access; independent of sandboxed tool extension.",
+    description: "0dev only. Reload changed engine code between turns. Runs with full host access, including your credentials; separate from sandboxed tools.",
     kind: "boolean",
     default: false,
     group: "Security"
@@ -1527,7 +2392,7 @@ var DEFS = [
   {
     key: "autoEvolveFinderLenses",
     label: "Auto-evolve finder lenses",
-    description: "Start the TUI watcher for ~/.0/lens-synthesis/miss-input.json (or OSEC_TUI_LENS_SYNTH_INPUT) so each new curated revision can invoke the configured model.",
+    description: "Watch ~/.0/lens-synthesis/miss-input.json (or OSEC_TUI_LENS_SYNTH_INPUT) and let the model draft new finder lenses.",
     kind: "boolean",
     default: false,
     group: "Security"
@@ -1535,7 +2400,7 @@ var DEFS = [
   {
     key: "autoPromoteFinderLenses",
     label: "Auto-promote validated lenses",
-    description: "Permit the TUI watcher to persist a candidate only after its positive and negative-control corpus gate passes, otherwise automatic evaluation stays dry-run.",
+    description: "Save a drafted lens only after it passes its positive and negative test cases. Otherwise evaluation is dry-run.",
     kind: "boolean",
     default: false,
     group: "Security"
@@ -1576,7 +2441,7 @@ var DEFS = [
   {
     key: "elapsedTimer",
     label: "Elapsed timer",
-    description: "Show the running-turn elapsed time as a compact clock-glyphed pill next to the left status icon, or hide it.",
+    description: "Show how long the current turn has been running.",
     kind: "enum",
     default: "left",
     choices: ["left", "off"],
@@ -1585,7 +2450,7 @@ var DEFS = [
   {
     key: "logoAnimation",
     label: "Logo animation",
-    description: 'Intro animation for the "0.SECURITY" wordmark: glitch (a neon-flecked scramble that resolves \u2014 the default), rainbow (a looping hue sweep), matrix (a green matrix-rain cascade), wave (a rippling cyan wavefront), neon (a neon-sign warm-up flicker), shimmer (a bright comet with a gradient tail), pulse (the slash breathes), strike (an orange slash strikes through the 0), draw (letters draw in behind a pen tip), fade (a centre-out bloom), typein (per-cell reveal), sweep (a bright bar wipes across) or off (static).',
+    description: "Intro animation for the 0 logo, or off.",
     kind: "enum",
     default: "glitch",
     choices: [
@@ -1609,7 +2474,7 @@ var DEFS = [
   {
     key: "reduceMotion",
     label: "Reduce motion",
-    description: "Master reduce-motion: the console keeps essential feedback but disables decorative animations like the logo intro, shimmers and sweeps.",
+    description: "Turn off decorative animations (logo intro, shimmers, sweeps).",
     kind: "boolean",
     default: false,
     group: "Motion"
@@ -1617,16 +2482,16 @@ var DEFS = [
   {
     key: "analyticsLevel",
     label: "Data sharing",
-    description: "Usage sends counts, timing, cost and error categories. Commands adds tool inputs/outputs and code; Full adds scope and findings. Credentials are scrubbed, but identifying content may remain. Uploads require an endpoint and are not anonymous. Environment opt-outs take precedence. Applies to this computer.",
+    description: "Usage shares pseudonymous counts, timing, cost and error types, never code or tool content. Off sends nothing. Environment opt-outs win. Applies to this computer.",
     kind: "enum",
     default: "off",
-    choices: ["off", "usage", "commands", "full"],
+    choices: ["off", "usage"],
     group: "Privacy"
   },
   {
     key: "diagnosticReporting",
     label: "Problem reports",
-    description: "Review diagnostics before sending, send automatically, or keep reports local. Requires a configured endpoint. Off/Usage sharing sends categories only; Commands/Full can include scrubbed errors, stacks and failure output. Applies to this computer.",
+    description: "Review error reports before sending, send automatically, or keep them local. Needs a configured destination; separate from usage sharing. Applies to this computer.",
     kind: "enum",
     default: "ask",
     choices: ["off", "ask", "automatic"],
@@ -1635,7 +2500,7 @@ var DEFS = [
   {
     key: "updatePolicy",
     label: "Updates",
-    description: "Off, notify about releases, or install updates before the console starts. Applies to this computer; project settings cannot enable installation.",
+    description: "Off, notify about new releases, or install updates at startup. Applies to this computer; project settings can't turn on installing.",
     kind: "enum",
     default: "automatic",
     choices: ["off", "notify", "automatic"],
@@ -1644,7 +2509,7 @@ var DEFS = [
   {
     key: "executionProfile",
     label: "Execution profile",
-    description: "SmolVM runs the whole console, agents, browser and shell in the online Kali workbench. Prepare its approved image and explicit credential grants with 0 workbench setup. Applies to this computer on the next launch; failures never fall back to host execution.",
+    description: "SmolVM runs everything (agents, browser, shell) in the online Kali workbench. Set it up with 0 workbench setup. Applies to this computer on next launch; failures never fall back to running on your machine.",
     kind: "enum",
     default: "local",
     choices: ["local", "smolvm"],
@@ -1653,7 +2518,7 @@ var DEFS = [
   {
     key: "symbolPreset",
     label: "Symbols",
-    description: "Glyph set for icons, status marks and checkboxes: Unicode (default, works everywhere), Nerd Font (crisp patched-font icons \u2014 requires a Nerd Font terminal) or ASCII (plain, single-cell).",
+    description: "Icon set: Unicode (default), Nerd Font (needs a Nerd Font terminal) or ASCII.",
     kind: "enum",
     default: "unicode",
     choices: ["unicode", "nerd", "ascii"],
@@ -1662,7 +2527,7 @@ var DEFS = [
   {
     key: "rosterSort",
     label: "Roster order",
-    description: "Order the agent herd and comms fleet by attention (blocked and working agents float to the top \u2014 the default) or by fixed lifecycle status.",
+    description: "Sort agents by attention (blocked and working first, default) or by status.",
     kind: "enum",
     default: "attention",
     choices: ["attention", "status"],
@@ -1671,7 +2536,7 @@ var DEFS = [
   {
     key: "leaderKey",
     label: "Leader key",
-    description: "Optional tmux-style prefix chord for the roster views: press it, then a number to focus that agent, or n/p to step. Off disables it (the direct number keys work regardless).",
+    description: "Optional prefix key for agent views: press it, then a number to focus an agent or n/p to step. Number keys work either way.",
     kind: "enum",
     default: "off",
     choices: ["off", "ctrl+a", "ctrl+b", "ctrl+space"],
@@ -1706,1068 +2571,246 @@ var DEFAULT_SETTINGS = {
   transcriptDetail: "collapsed",
   autoCompaction: true,
   compactionThreshold: "80%",
-  theme: DEFAULT_THEME_NAME,
-  allowModelSelfExtension: DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
-  allowDevSourceUpdates: false,
-  autoEvolveFinderLenses: false,
-  autoPromoteFinderLenses: false,
-  showTokenUsage: false,
-  showCost: false,
-  showContextMeter: true,
-  modelDisplay: "statusbar",
-  elapsedTimer: "left",
-  logoAnimation: "glitch",
-  reduceMotion: false,
-  analyticsLevel: "off",
-  diagnosticReporting: "ask",
-  diagnosticReportingPrompted: false,
-  updatePolicy: "automatic",
-  symbolPreset: "unicode",
-  rosterSort: "attention",
-  leaderKey: "off",
-  keybindings: {},
-  modelPreference: null
-};
-var SETTINGS_FILENAME = "tui-settings.json";
-function settingsFilePath(homeDir2) {
-  return join3(homeStateDir(homeDir2), SETTINGS_FILENAME);
-}
-function projectStateDir(projectDir2 = process.cwd()) {
-  return join3(projectDir2, ".0");
-}
-function projectSettingsFilePath(projectDir2 = process.cwd()) {
-  return join3(projectStateDir(projectDir2), SETTINGS_FILENAME);
-}
-function readRawSettingsFile(path) {
-  try {
-    return JSON.parse(readFileSync2(path, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function projectSettingsExist(projectDir2 = process.cwd()) {
-  const raw = readRawSettingsFile(projectSettingsFilePath(projectDir2));
-  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
-}
-function strictValueAt(raw, key) {
-  const value = rawValue(raw, key);
-  if (value === void 0) return void 0;
-  if (key === "onboardingCompleted" || key === "diagnosticReportingPrompted") {
-    return typeof value === "boolean" ? value : void 0;
-  }
-  if (value === false && (key === "diagnosticReporting" || key === "updatePolicy")) {
-    return "off";
-  }
-  if (key === "theme") {
-    return typeof value === "string" && isKnownTheme(value) ? value : void 0;
-  }
-  if (key === "keybindings") {
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? sanitizeKeybindingOverrides(value) : void 0;
-  }
-  if (key === "modelPreference") {
-    return normalizeModelPreference(value);
-  }
-  const def = DEF_BY_KEY.get(key);
-  if (def?.kind === "boolean") {
-    return typeof value === "boolean" ? value : void 0;
-  }
-  const choices = def?.choices ?? [];
-  return typeof value === "string" && choices.includes(value) ? value : void 0;
-}
-function isOperatorSetting(key) {
-  return key === "onboardingCompleted" || key === "analyticsLevel" || key === "diagnosticReporting" || key === "diagnosticReportingPrompted" || key === "updatePolicy" || key === "allowDevSourceUpdates" || key === "executionProfile" || key === "modelPreference";
-}
-function resolveLayeredSettings(globalRaw, projectRaw) {
-  const settings = {};
-  const sources = {};
-  for (const key of Object.keys(DEFAULT_SETTINGS)) {
-    const projectValue = isOperatorSetting(key) ? void 0 : strictValueAt(projectRaw, key);
-    if (projectValue !== void 0) {
-      settings[key] = projectValue;
-      sources[key] = "project";
-      continue;
-    }
-    const globalValue = strictValueAt(globalRaw, key);
-    if (globalValue !== void 0) {
-      settings[key] = globalValue;
-      sources[key] = "global";
-      continue;
-    }
-    settings[key] = DEFAULT_SETTINGS[key];
-    sources[key] = "default";
-  }
-  return { settings, sources };
-}
-function loadLayeredSettings(opts = {}) {
-  syncThemeChoices(opts.homeDir);
-  const globalRaw = readRawSettingsFile(settingsFilePath(opts.homeDir));
-  const projectRaw = readRawSettingsFile(projectSettingsFilePath(opts.projectDir));
-  return resolveLayeredSettings(globalRaw, projectRaw);
-}
-function rawValue(raw, key) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
-  const value = raw[key];
-  return key === "transcriptStyle" && value === "messenger" ? "bubble" : value;
-}
-function booleanAt(raw, key) {
-  const value = rawValue(raw, key);
-  return typeof value === "boolean" ? value : DEFAULT_SETTINGS[key];
-}
-function enumAt(raw, key) {
-  const def = DEF_BY_KEY.get(key);
-  const value = rawValue(raw, key);
-  const choices = def?.choices ?? [];
-  return typeof value === "string" && choices.includes(value) ? value : DEFAULT_SETTINGS[key];
-}
-function themeAt(raw) {
-  const value = rawValue(raw, "theme");
-  return typeof value === "string" && isKnownTheme(value) ? value : DEFAULT_SETTINGS.theme;
-}
-function keybindingsAt(raw) {
-  return sanitizeKeybindingOverrides(rawValue(raw, "keybindings"));
-}
-function normalizeModelPreference(raw) {
-  if (raw === null) return null;
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
-  const value = raw;
-  if (typeof value.providerId !== "string" || !value.providerId.trim() || typeof value.model !== "string" || !value.model.trim() || typeof value.connectionIdentity !== "string" || !/^[a-f0-9]{64}$/.test(value.connectionIdentity)) return void 0;
-  return { providerId: value.providerId, model: value.model, connectionIdentity: value.connectionIdentity };
-}
-function normalizeSettings(raw) {
-  return {
-    showStatusBar: booleanAt(raw, "showStatusBar"),
-    showComposerHints: booleanAt(raw, "showComposerHints"),
-    composerSuggestions: booleanAt(raw, "composerSuggestions"),
-    mouseSupport: booleanAt(raw, "mouseSupport"),
-    showLogo: booleanAt(raw, "showLogo"),
-    showRuntimeNotices: booleanAt(raw, "showRuntimeNotices"),
-    showTurnSummary: booleanAt(raw, "showTurnSummary"),
-    showSubagents: booleanAt(raw, "showSubagents"),
-    showTimestamps: booleanAt(raw, "showTimestamps"),
-    showObjective: booleanAt(raw, "showObjective"),
-    showScope: booleanAt(raw, "showScope"),
-    density: enumAt(raw, "density"),
-    composerStyle: enumAt(raw, "composerStyle"),
-    busyInputMode: enumAt(raw, "busyInputMode"),
-    onboardingCompleted: booleanAt(raw, "onboardingCompleted"),
-    executionProfile: enumAt(raw, "executionProfile"),
-    allowSubagentPeerMessaging: booleanAt(raw, "allowSubagentPeerMessaging"),
-    allowSubagentOperatorMessaging: booleanAt(raw, "allowSubagentOperatorMessaging"),
-    transcriptStyle: enumAt(raw, "transcriptStyle"),
-    roleLabelStyle: enumAt(raw, "roleLabelStyle"),
-    toolCardStyle: enumAt(raw, "toolCardStyle"),
-    richToolCards: booleanAt(raw, "richToolCards"),
-    transcriptDetail: enumAt(raw, "transcriptDetail"),
-    autoCompaction: booleanAt(raw, "autoCompaction"),
-    compactionThreshold: enumAt(raw, "compactionThreshold"),
-    theme: themeAt(raw),
-    allowModelSelfExtension: booleanAt(raw, "allowModelSelfExtension"),
-    allowDevSourceUpdates: booleanAt(raw, "allowDevSourceUpdates"),
-    autoEvolveFinderLenses: booleanAt(raw, "autoEvolveFinderLenses"),
-    autoPromoteFinderLenses: booleanAt(raw, "autoPromoteFinderLenses"),
-    showTokenUsage: booleanAt(raw, "showTokenUsage"),
-    showCost: booleanAt(raw, "showCost"),
-    showContextMeter: booleanAt(raw, "showContextMeter"),
-    modelDisplay: enumAt(raw, "modelDisplay"),
-    elapsedTimer: enumAt(raw, "elapsedTimer"),
-    logoAnimation: enumAt(raw, "logoAnimation"),
-    reduceMotion: booleanAt(raw, "reduceMotion"),
-    analyticsLevel: enumAt(raw, "analyticsLevel"),
-    diagnosticReporting: strictValueAt(raw, "diagnosticReporting") ?? DEFAULT_SETTINGS.diagnosticReporting,
-    diagnosticReportingPrompted: booleanAt(raw, "diagnosticReportingPrompted"),
-    updatePolicy: strictValueAt(raw, "updatePolicy") ?? DEFAULT_SETTINGS.updatePolicy,
-    symbolPreset: enumAt(raw, "symbolPreset"),
-    rosterSort: enumAt(raw, "rosterSort"),
-    leaderKey: enumAt(raw, "leaderKey"),
-    keybindings: keybindingsAt(raw),
-    modelPreference: normalizeModelPreference(rawValue(raw, "modelPreference")) ?? null
-  };
-}
-function loadSettings(homeDir2, projectDir2) {
-  return loadLayeredSettings({ homeDir: homeDir2, projectDir: projectDir2 }).settings;
-}
-function loadGlobalSettings(homeDir2, options = {}) {
-  syncThemeChoices(homeDir2);
-  const raw = readRawSettingsFile(settingsFilePath(homeDir2));
-  if (options.requireExecutionProfile && strictValueAt(raw, "executionProfile") === void 0) {
-    throw new Error("Configured workbench execution profile is missing or invalid. Run 0 workbench setup or 0 workbench disable to make an explicit operator choice; host fallback is refused.");
-  }
-  return normalizeSettings(raw);
-}
-function saveSettings(settings, homeDir2) {
-  const path = settingsFilePath(homeDir2);
-  const temporary = `${path}.${randomUUID()}.tmp`;
-  try {
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync2(temporary, `${JSON.stringify(normalizeSettings(settings), null, 2)}
-`, { encoding: "utf8", flag: "wx", mode: 384 });
-    renameSync(temporary, path);
-    return true;
-  } catch {
-    return false;
-  } finally {
-    try {
-      rmSync2(temporary, { force: true });
-    } catch {
-    }
-  }
-}
-function sanitizeOverrides(raw) {
-  const out = {};
-  for (const key of Object.keys(DEFAULT_SETTINGS)) {
-    if (isOperatorSetting(key)) continue;
-    const value = strictValueAt(raw, key);
-    if (value !== void 0) out[key] = value;
-  }
-  return out;
-}
-function readProjectOverrides(projectDir2) {
-  return sanitizeOverrides(readRawSettingsFile(projectSettingsFilePath(projectDir2)));
-}
-function saveProjectOverrides(patch, projectDir2) {
-  try {
-    const path = projectSettingsFilePath(projectDir2);
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync2(path, `${JSON.stringify(sanitizeOverrides(patch), null, 2)}
-`, "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// packages/cli/src/tui/settings-store.ts
-var cached = null;
-var globalDraft = null;
-var projectDraft = null;
-var homeDir;
-var projectDir;
-var subscribers = /* @__PURE__ */ new Set();
-function notify(settings) {
-  bridgeAnalyticsLevel(settings);
-  for (const fn of [...subscribers]) {
-    try {
-      fn(settings);
-    } catch {
-    }
-  }
-}
-function loadLayered() {
-  return globalDraft === null && projectDraft === null ? loadLayeredSettings({ homeDir, projectDir }) : resolveLayeredSettings(globalDraft ?? loadGlobalSettings(homeDir), projectDraft ?? readProjectOverrides(projectDir));
-}
-function getSettings() {
-  if (cached === null) {
-    cached = loadLayered();
-    bridgeAnalyticsLevel(cached.settings);
-  }
-  return cached.settings;
-}
-function getSettingSources() {
-  getSettings();
-  return cached.sources;
-}
-function setSettings(next) {
-  const value = normalizeSettings(next);
-  const saved = saveSettings(value, homeDir);
-  globalDraft = saved ? null : value;
-  cached = loadLayered();
-  notify(cached.settings);
-  return saved;
-}
-function defaultWriteLayer() {
-  return projectSettingsExist(projectDir) ? "project" : "global";
-}
-function updateSetting(key, value, opts = {}) {
-  const operatorOnly = isOperatorSetting(key);
-  if (operatorOnly && opts.scope === "project") return false;
-  const layer = operatorOnly ? "global" : opts.scope ?? defaultWriteLayer();
-  if (layer === "global") {
-    return setSettings({ ...globalDraft ?? loadGlobalSettings(homeDir), [key]: value });
-  }
-  const patch = { ...projectDraft ?? readProjectOverrides(projectDir), [key]: value };
-  const saved = saveProjectOverrides(patch, projectDir);
-  projectDraft = saved ? null : patch;
-  cached = loadLayered();
-  notify(cached.settings);
-  return saved;
-}
-function resetSettings(next, keys) {
-  const selected = keys.filter((key) => SETTING_DEFS.some((def) => def.key === key));
-  if (selected.length === 0) return true;
-  const global = { ...globalDraft ?? loadGlobalSettings(homeDir) };
-  const project = { ...projectDraft ?? readProjectOverrides(projectDir) };
-  let projectChanged = false;
-  for (const key of selected) {
-    global[key] = next[key];
-    if (Object.hasOwn(project, key)) {
-      delete project[key];
-      projectChanged = true;
-    }
-  }
-  const value = normalizeSettings(global);
-  const globalSaved = saveSettings(value, homeDir);
-  globalDraft = globalSaved ? null : value;
-  const projectSaved = !projectChanged || saveProjectOverrides(project, projectDir);
-  if (projectChanged) projectDraft = projectSaved ? null : project;
-  cached = loadLayered();
-  notify(cached.settings);
-  return globalSaved && projectSaved;
-}
-function previewSetting(key, value) {
-  if (cached === null) cached = loadLayered();
-  cached = { settings: { ...cached.settings, [key]: value }, sources: cached.sources };
-  notify(cached.settings);
-}
-function subscribeSettings(fn) {
-  subscribers.add(fn);
-  return () => {
-    subscribers.delete(fn);
-  };
-}
-var bridgedAnalyticsEnv;
-function bridgeAnalyticsLevel(settings) {
-  try {
-    const current = process.env[ANALYTICS_LEVEL_ENV];
-    if (current === void 0 || current === bridgedAnalyticsEnv) {
-      process.env[ANALYTICS_LEVEL_ENV] = settings.analyticsLevel;
-      bridgedAnalyticsEnv = settings.analyticsLevel;
-    } else {
-      bridgedAnalyticsEnv = void 0;
-    }
-    const environmentLevel = resolveAnalyticsLevel();
-    analyticsPipeline.setLevel(levelAtLeast(environmentLevel, settings.analyticsLevel) ? settings.analyticsLevel : environmentLevel);
-  } catch {
-  }
-}
-function reloadSettings() {
-  globalDraft = null;
-  projectDraft = null;
-  cached = loadLayered();
-  notify(cached.settings);
-  return cached.settings;
-}
-function configureSettingsStore(options) {
-  homeDir = options.homeDir;
-  projectDir = options.projectDir;
-  reloadSettings();
-}
-function useSettings() {
-  return useSyncExternalStore(subscribeSettings, getSettings, getSettings);
-}
-
-// packages/cli/src/codex-auth.ts
-import { readFileSync as readFileSync3, existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join as join4 } from "node:path";
-var AUTH_FILE_ENV = "ZERO_CHATGPT_AUTH_FILE";
-var LEGACY_AUTH_FILE_ENV = "ZERO_CODEX_AUTH_JSON_PATH";
-function maybeLoadCodexAuth(options = {}) {
-  const env = options.env ?? process.env;
-  if (!options.force && (env["ZERO_CHATGPT_ACCESS_TOKEN"] || env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"])) {
-    return;
-  }
-  const home = options.home ?? homedir();
-  const override = nonEmpty(env[AUTH_FILE_ENV]) ?? nonEmpty(env[LEGACY_AUTH_FILE_ENV]);
-  const path = override ?? join4(home, ".codex", "auth.json");
-  if (!existsSync(path)) return;
-  try {
-    const raw = JSON.parse(readFileSync3(path, "utf8"));
-    const accessToken = nonEmpty(asString(raw.tokens?.access_token));
-    const refreshToken = nonEmpty(asString(raw.tokens?.refresh_token));
-    if (!accessToken && !refreshToken) return;
-    if (options.force) {
-      delete env["ZERO_CHATGPT_ACCESS_TOKEN"];
-      delete env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"];
-    }
-    if (accessToken) {
-      env["ZERO_CHATGPT_ACCESS_TOKEN"] = accessToken;
-    }
-    if (refreshToken) {
-      env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"] = refreshToken;
-    }
-  } catch {
-  }
-}
-function nonEmpty(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function asString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-
-// packages/cli/src/presentation/event-bus.ts
-var PresentationEventBus = class {
-  listeners = [];
-  subscribe(listener) {
-    this.listeners.push(listener);
-    return () => {
-      const index = this.listeners.indexOf(listener);
-      if (index >= 0) this.listeners.splice(index, 1);
-    };
-  }
-  emit(event) {
-    for (const listener of [...this.listeners]) {
-      try {
-        listener.emit(event);
-      } catch {
-      }
-    }
-  }
-  get size() {
-    return this.listeners.length;
-  }
-};
-var presentationEventBus = new PresentationEventBus();
-function createPresentationEmitter(options = {}) {
-  const source = options.source ?? "cli";
-  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const bus = options.bus ?? presentationEventBus;
-  let sequence = 0;
-  return {
-    emit(eventType, payload, correlation = {}) {
-      const event = createPresentationEvent({
-        source,
-        sequence: ++sequence,
-        at: now(),
-        eventType,
-        payload,
-        ...correlation.scanId ? { scanId: correlation.scanId } : {},
-        ...correlation.sessionId ? { sessionId: correlation.sessionId } : {}
-      });
-      bus.emit(event);
-      return event;
-    }
-  };
-}
-
-// packages/cli/src/presentation/process-output.ts
-import { format } from "node:util";
-var streamBridgeSuppressionDepth = 0;
-var activeStreamBridge = null;
-function currentPresentationTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function createProcessPresentationOutput(options = {}) {
-  const stdout = options.stdout ?? { write: process.stdout.write.bind(process.stdout) };
-  const stderr = options.stderr ?? { write: process.stderr.write.bind(process.stderr) };
-  const source = options.source ?? "cli";
-  const now = options.now ?? currentPresentationTimestamp;
-  let sequence = 0;
-  const write = (channel, target, text, eventType) => {
-    const event = createPresentationEvent({
-      source,
-      sequence: ++sequence,
-      at: now(),
-      eventType,
-      payload: { channel, text }
-    });
-    streamBridgeSuppressionDepth += 1;
-    try {
-      target.write(text);
-    } finally {
-      streamBridgeSuppressionDepth -= 1;
-    }
-    options.onEvent?.(event);
-    return event;
-  };
-  return {
-    stdout(text, eventType = "output.stdout") {
-      return write("stdout", stdout, text, eventType);
-    },
-    stderr(text, eventType = "output.stderr") {
-      return write("stderr", stderr, text, eventType);
-    }
-  };
-}
-function createConsolePresentationOutput(options = {}) {
-  const source = options.source ?? "cli";
-  const now = options.now ?? currentPresentationTimestamp;
-  let sequence = 0;
-  const emit = (channel, text, eventType) => {
-    const event = createPresentationEvent({
-      source,
-      sequence: ++sequence,
-      at: now(),
-      eventType,
-      payload: { channel, text }
-    });
-    streamBridgeSuppressionDepth += 1;
-    try {
-      if (channel === "stdout") {
-        (options.log ?? console.log)(text);
-      } else {
-        (options.error ?? console.error)(text);
-      }
-    } finally {
-      streamBridgeSuppressionDepth -= 1;
-    }
-    options.onEvent?.(event);
-    return event;
-  };
-  return {
-    stdout(text, eventType = "output.stdout") {
-      return emit("stdout", text, eventType);
-    },
-    stderr(text, eventType = "output.stderr") {
-      return emit("stderr", text, eventType);
-    }
-  };
-}
-var consolePresentationOutput = createConsolePresentationOutput({
-  onEvent(event) {
-    presentationEventBus.emit(event);
-  }
-});
-function installConsolePresentationBridge(options = {}) {
-  const target = options.target ?? console;
-  const originals = {
-    log: target.log,
-    info: target.info,
-    warn: target.warn,
-    error: target.error
-  };
-  const source = options.source ?? "cli";
-  const now = options.now ?? currentPresentationTimestamp;
-  let sequence = 0;
-  const emit = (method, channel, args, eventType) => {
-    const text = format(...args);
-    if (streamBridgeSuppressionDepth > 0) {
-      originals[method].call(target, text);
-      return;
-    }
-    const event = createPresentationEvent({
-      source,
-      sequence: ++sequence,
-      at: now(),
-      eventType,
-      payload: { channel, text }
-    });
-    streamBridgeSuppressionDepth += 1;
-    try {
-      originals[method].call(target, text);
-    } finally {
-      streamBridgeSuppressionDepth -= 1;
-    }
-    presentationEventBus.emit(event);
-    options.onEvent?.(event);
-  };
-  const bridgedLog = (...args) => emit("log", "stdout", args, "output.console.log");
-  const bridgedInfo = (...args) => emit("info", "stdout", args, "output.console.info");
-  const bridgedWarn = (...args) => emit("warn", "stderr", args, "output.console.warn");
-  const bridgedError = (...args) => emit("error", "stderr", args, "output.console.error");
-  target.log = bridgedLog;
-  target.info = bridgedInfo;
-  target.warn = bridgedWarn;
-  target.error = bridgedError;
-  return {
-    restore() {
-      if (target.log === bridgedLog) target.log = originals.log;
-      if (target.info === bridgedInfo) target.info = originals.info;
-      if (target.warn === bridgedWarn) target.warn = originals.warn;
-      if (target.error === bridgedError) target.error = originals.error;
-    }
-  };
-}
-function installProcessPresentationStreamBridge(options = {}) {
-  if (activeStreamBridge) return activeStreamBridge;
-  const source = options.source ?? "cli";
-  const now = options.now ?? currentPresentationTimestamp;
-  let sequence = 0;
-  let suspended = false;
-  const streams = [];
-  const emit = (channel, chunk, encoding) => {
-    const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8") : String(chunk ?? "");
-    if (channel === "stdout" && text.startsWith("ZERO_EVENT_")) return;
-    const event = createPresentationEvent({
-      source,
-      sequence: ++sequence,
-      at: now(),
-      eventType: channel === "stdout" ? "output.stream.stdout" : "output.stream.stderr",
-      payload: { channel, text }
-    });
-    presentationEventBus.emit(event);
-    options.onEvent?.(event);
-  };
-  for (const [channel, stream] of [
-    ["stdout", options.stdout ?? process.stdout],
-    ["stderr", options.stderr ?? process.stderr]
-  ]) {
-    const original = stream.write;
-    const patched = ((chunk, encoding, callback) => {
-      const result = original.call(stream, chunk, encoding, callback);
-      if (!suspended && streamBridgeSuppressionDepth === 0) emit(channel, chunk, encoding);
-      return result;
-    });
-    streams.push({ channel, stream, original, patched });
-  }
-  const bridge = {
-    suspend() {
-      if (suspended) return;
-      suspended = true;
-      for (const item of streams) {
-        if (item.stream.write === item.patched) item.stream.write = item.original;
-      }
-    },
-    resume() {
-      if (!suspended) return;
-      suspended = false;
-      for (const item of streams) {
-        if (item.stream.write === item.original) item.stream.write = item.patched;
-      }
-    },
-    restore() {
-      for (const item of streams) {
-        if (item.stream.write === item.patched) item.stream.write = item.original;
-      }
-      if (activeStreamBridge === bridge) activeStreamBridge = null;
-    }
-  };
-  for (const item of streams) item.stream.write = item.patched;
-  activeStreamBridge = bridge;
-  return bridge;
-}
-function suspendProcessPresentationStreamBridge() {
-  activeStreamBridge?.suspend();
-}
-function resumeProcessPresentationStreamBridge() {
-  activeStreamBridge?.resume();
-}
-var processPresentationOutput = createProcessPresentationOutput({
-  onEvent(event) {
-    presentationEventBus.emit(event);
-  }
-});
-function writePresentationLine(text, eventType = "output.stdout") {
-  return processPresentationOutput.stdout(`${text}
-`, eventType);
-}
-
-// packages/cli/src/tui/provider-status.ts
-var PROVIDER_DEFS = [
-  {
-    id: "chatgpt-codex",
-    label: "ChatGPT Codex",
-    methods: ["oauth"],
-    // OAuth, not an API key. Both tokens are accepted and the access token is
-    // read first (llm-api.ts L874-875, L1386-1394), so it leads the list.
-    envVars: ["ZERO_CHATGPT_ACCESS_TOKEN", "ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"],
-    fileSource: "~/.codex/auth.json (override with ZERO_CHATGPT_AUTH_FILE)",
-    hint: "run `codex login` to write ~/.codex/auth.json, or invoke 0 with env ZERO_CHATGPT_OAUTH_REFRESH_TOKEN=..."
-  },
-  {
-    id: "deepseek",
-    label: "DeepSeek",
-    methods: ["api-key"],
-    envVars: ["DEEPSEEK_API_KEY"],
-    hint: "set DEEPSEEK_API_KEY (endpoint override: DEEPSEEK_BASE_URL)"
-  },
-  {
-    id: "openrouter",
-    label: "OpenRouter",
-    // OAuth (PKCE browser sign-in) is preferred; a pasted OPENROUTER_API_KEY
-    // remains a secondary path. The browser flow provisions a durable
-    // `sk-or-...` key and stores it as an api_key record written to
-    // OPENROUTER_API_KEY (envVars[0], which llm-api already reads), so — unlike
-    // the xai/kimi device flows — the credential is a key, not OAuth tokens.
-    methods: ["oauth", "api-key"],
-    envVars: ["OPENROUTER_API_KEY"],
-    hint: "sign in with your OpenRouter account, or set OPENROUTER_API_KEY=sk-or-... from openrouter.ai/keys"
-  },
-  {
-    id: "azure",
-    label: "Azure OpenAI",
-    methods: ["api-key"],
-    // Only the Azure key authenticates; the deployment URL comes from
-    // AZURE_OPENAI_BASE_URL / OPENAI_BASE_URL / ~/.codex/config.toml
-    // (L1435-1445). A key with no reachable base URL still counts as
-    // configured here because detectProvider selects azure on the key alone.
-    envVars: ["AZURE_OPENAI_API_KEY"],
-    hint: "set AZURE_OPENAI_API_KEY plus AZURE_OPENAI_BASE_URL (or [model_providers.azure] in ~/.codex/config.toml)"
-  },
-  {
-    id: "openai",
-    label: "OpenAI",
-    methods: ["api-key"],
-    envVars: ["OPENAI_API_KEY"],
-    hint: "set OPENAI_API_KEY=sk-... from platform.openai.com/api-keys"
-  },
-  {
-    id: "z-ai",
-    label: "Z.ai GLM",
-    methods: ["api-key"],
-    envVars: ["Z_AI_API_KEY"],
-    hint: "set Z_AI_API_KEY from your Z.ai Coding Plan (endpoint override: Z_AI_BASE_URL)"
-  },
-  {
-    id: "kimi",
-    label: "Moonshot Kimi",
-    // OAuth (device sign-in) is preferred; a pasted KIMI_API_KEY remains a
-    // secondary path. The OAuth access token is written to KIMI_API_KEY as a
-    // Bearer (llm-api.ts reads it there, no change needed), and the refresh
-    // token to the 0-owned var so the store can round-trip it.
-    methods: ["oauth", "api-key"],
-    envVars: ["KIMI_API_KEY", "ZERO_KIMI_OAUTH_REFRESH_TOKEN"],
-    hint: "sign in with your Kimi account, or set KIMI_API_KEY from your Kimi coding plan (endpoint override: KIMI_BASE_URL)"
-  },
-  {
-    id: "qwen",
-    label: "Alibaba Qwen",
-    methods: ["api-key"],
-    envVars: ["QWEN_API_KEY"],
-    hint: "set QWEN_API_KEY from Alibaba Model Studio (endpoint override: QWEN_BASE_URL)"
-  },
-  {
-    id: "xai",
-    label: "xAI Grok",
-    // OAuth (device sign-in) is preferred; a pasted XAI_API_KEY remains a
-    // secondary path. The OAuth access token is written to XAI_API_KEY as a
-    // Bearer (llm-api.ts reads it there, no change needed), and the refresh
-    // token to the 0-owned var so the store can round-trip it.
-    methods: ["oauth", "api-key"],
-    envVars: ["XAI_API_KEY", "ZERO_XAI_OAUTH_REFRESH_TOKEN"],
-    hint: "sign in with your xAI account, or set XAI_API_KEY from console.x.ai (endpoint override: XAI_BASE_URL)"
-  },
-  {
-    id: "opencode",
-    label: "OpenCode Zen",
-    methods: ["api-key"],
-    envVars: ["OPENCODE_API_KEY"],
-    hint: "set OPENCODE_API_KEY from opencode.ai/auth (endpoint override: OPENCODE_BASE_URL)"
-  },
-  {
-    id: "copilot",
-    label: "GitHub Copilot",
-    // OAuth only (device-code sign-in). The GitHub device-flow access token is
-    // written to ZERO_COPILOT_GITHUB_TOKEN (envVars[0]) and sent directly as a
-    // Bearer to api.githubcopilot.com — no secondary exchange, no refresh, so
-    // there is no refresh-token env var.
-    methods: ["oauth"],
-    envVars: ["ZERO_COPILOT_GITHUB_TOKEN"],
-    hint: "sign in with your GitHub Copilot account (device sign-in), or set ZERO_COPILOT_GITHUB_TOKEN=... (endpoint override: COPILOT_BASE_URL)"
-  },
-  {
-    id: "google",
-    label: "Google Gemini (Code Assist)",
-    // OAuth only (PKCE browser sign-in — the Gemini CLI flow). The minted
-    // access token is written to ZERO_GEMINI_ACCESS_TOKEN (envVars[0]) and the
-    // refresh token to ZERO_GEMINI_OAUTH_REFRESH_TOKEN (the /REFRESH/i var); the
-    // runtime refreshes on demand against oauth2.googleapis.com. There is no
-    // pasted-key equivalent — Code Assist authenticates only via OAuth.
-    methods: ["oauth"],
-    envVars: ["ZERO_GEMINI_ACCESS_TOKEN", "ZERO_GEMINI_OAUTH_REFRESH_TOKEN"],
-    hint: "sign in with your Google account (browser sign-in), or set ZERO_GEMINI_OAUTH_REFRESH_TOKEN=... for Gemini Code Assist (project override: GOOGLE_CLOUD_PROJECT / ZERO_GEMINI_PROJECT)"
-  },
-  {
-    id: "anthropic",
-    label: "Anthropic",
-    // API key only for now. The schema supports OAuth, but Anthropic/Claude
-    // subscription OAuth is deliberately deferred — do not add "oauth" here
-    // until that workstream lands.
-    methods: ["api-key"],
-    envVars: ["ANTHROPIC_API_KEY"],
-    hint: "set ANTHROPIC_API_KEY=sk-ant-... from console.anthropic.com"
-  }
-];
-function primaryMethod(methods) {
-  return methods[0] ?? "api-key";
-}
-var PROVIDERS = PROVIDER_DEFS.map((def) => ({
-  ...def,
-  auth: primaryMethod(def.methods)
-}));
-function providerSupportsMethod(providerId, method) {
-  const info = PROVIDERS.find((candidate) => candidate.id === providerId);
-  return info !== void 0 && info.methods.includes(method);
-}
-function hasCredential(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function satisfyingVar(info, env) {
-  return info.envVars.find((name) => hasCredential(env[name]));
-}
-function providerStates(env) {
-  return PROVIDERS.map((info) => {
-    const via = satisfyingVar(info, env);
-    return via === void 0 ? { ...info, configured: false } : { ...info, configured: true, via };
-  });
+  theme: DEFAULT_THEME_NAME,
+  allowModelSelfExtension: DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
+  allowDevSourceUpdates: false,
+  autoEvolveFinderLenses: false,
+  autoPromoteFinderLenses: false,
+  showTokenUsage: false,
+  showCost: false,
+  showContextMeter: true,
+  modelDisplay: "statusbar",
+  elapsedTimer: "left",
+  logoAnimation: "glitch",
+  reduceMotion: false,
+  analyticsLevel: "off",
+  diagnosticReporting: "ask",
+  diagnosticReportingPrompted: false,
+  updatePolicy: "automatic",
+  symbolPreset: "unicode",
+  rosterSort: "attention",
+  leaderKey: "off",
+  keybindings: {},
+  modelPreference: null
+};
+var SETTINGS_FILENAME = "tui-settings.json";
+function settingsFilePath(homeDir) {
+  return join6(homeStateDir(homeDir), SETTINGS_FILENAME);
 }
-function isProviderConfigured(providerId, env) {
-  const info = PROVIDERS.find((candidate) => candidate.id === providerId);
-  return info !== void 0 && satisfyingVar(info, env) !== void 0;
+function projectStateDir(projectDir = process.cwd()) {
+  return join6(projectDir, ".0");
 }
-
-// packages/cli/src/tui/credential-store.ts
-import { chmodSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
-var CREDENTIALS_FILENAME = "credentials.json";
-var FILE_MODE = 384;
-var DIR_MODE = 448;
-function credentialsFilePath(homeDir2) {
-  return join5(homeStateDir(homeDir2), CREDENTIALS_FILENAME);
-}
-var STORABLE_PROVIDER_IDS = new Set(
-  PROVIDERS.filter((provider) => provider.methods.includes("api-key")).map((provider) => provider.id)
-);
-function hasCredential2(value) {
-  return typeof value === "string" && value.trim().length > 0;
+function projectSettingsFilePath(projectDir = process.cwd()) {
+  return join6(projectStateDir(projectDir), SETTINGS_FILENAME);
 }
-function normalizeCredentials(raw) {
-  const out = {};
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return out;
-  for (const [providerId, value] of Object.entries(raw)) {
-    if (!STORABLE_PROVIDER_IDS.has(providerId)) continue;
-    if (typeof value !== "string") continue;
-    const secret = value.trim();
-    if (secret.length === 0) continue;
-    out[providerId] = secret;
+function readRawSettingsFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
   }
-  return out;
 }
-function loadCredentials(homeDir2) {
-  return projectApiKeys(loadAccountStore(homeDir2));
-}
-function saveCredentials(creds, homeDir2) {
-  const store = loadAccountStore(homeDir2);
-  const desired = normalizeCredentials(creds);
-  return saveAccountStore(replaceApiKeyLayer(store, desired), homeDir2);
+function projectSettingsExist(projectDir = process.cwd()) {
+  const raw = readRawSettingsFile(projectSettingsFilePath(projectDir));
+  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
 }
-function projectApiKeys(store) {
-  const out = {};
-  for (const providerId of Object.keys(store.providers)) {
-    const record = getActiveAccount(store, providerId);
-    if (record?.kind === "api_key") out[providerId] = record.secret;
+function strictValueAt(raw, key) {
+  const value = rawValue(raw, key);
+  if (value === void 0) return void 0;
+  if (key === "onboardingCompleted" || key === "diagnosticReportingPrompted") {
+    return typeof value === "boolean" ? value : void 0;
   }
-  return out;
+  if (value === false && (key === "diagnosticReporting" || key === "updatePolicy")) {
+    return "off";
+  }
+  if (key === "theme") {
+    return typeof value === "string" && isKnownTheme(value) ? value : void 0;
+  }
+  if (key === "keybindings") {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? sanitizeKeybindingOverrides(value) : void 0;
+  }
+  if (key === "modelPreference") {
+    return normalizeModelPreference(value);
+  }
+  const def = DEF_BY_KEY.get(key);
+  if (def?.kind === "boolean") {
+    return typeof value === "boolean" ? value : void 0;
+  }
+  const choices = def?.choices ?? [];
+  return typeof value === "string" && choices.includes(value) ? value : void 0;
+}
+function isOperatorSetting(key) {
+  return key === "onboardingCompleted" || key === "analyticsLevel" || key === "diagnosticReporting" || key === "diagnosticReportingPrompted" || key === "updatePolicy" || key === "allowDevSourceUpdates" || key === "executionProfile" || key === "modelPreference";
 }
-function replaceApiKeyLayer(store, desired) {
-  const providers = {};
-  for (const [providerId, entry] of Object.entries(store.providers)) {
-    const kept = {};
-    for (const [accountId, record] of Object.entries(entry.accounts)) {
-      if (record.kind !== "api_key") kept[accountId] = record;
+function resolveLayeredSettings(globalRaw, projectRaw) {
+  const settings = {};
+  const sources = {};
+  for (const key of Object.keys(DEFAULT_SETTINGS)) {
+    const projectValue = isOperatorSetting(key) ? void 0 : strictValueAt(projectRaw, key);
+    if (projectValue !== void 0) {
+      settings[key] = projectValue;
+      sources[key] = "project";
+      continue;
     }
-    const keptIds = Object.keys(kept);
-    if (keptIds.length === 0) continue;
-    const active = entry.activeAccountId !== void 0 && kept[entry.activeAccountId] !== void 0 ? entry.activeAccountId : keptIds[0];
-    providers[providerId] = { activeAccountId: active, accounts: kept };
-  }
-  for (const [providerId, secret] of Object.entries(desired)) {
-    const existing = providers[providerId];
-    const accounts = existing ? { ...existing.accounts } : {};
-    accounts[DEFAULT_ACCOUNT_ID] = { kind: "api_key", secret };
-    providers[providerId] = { activeAccountId: DEFAULT_ACCOUNT_ID, accounts };
-  }
-  return { version: STORE_VERSION, providers };
-}
-function credentialEnvPatch(creds, env) {
-  const stored = normalizeCredentials(creds);
-  const patch = {};
-  for (const info of PROVIDERS) {
-    const secret = stored[info.id];
-    if (secret === void 0) continue;
-    if (info.envVars.some((name) => hasCredential2(env[name]))) continue;
-    const target = info.envVars[0];
-    if (target === void 0) continue;
-    patch[target] = secret;
-  }
-  return patch;
-}
-var MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
-var TAIL = 4;
-var PREFIX = 6;
-var MIN_LENGTH_FOR_TAIL = 12;
-var MIN_LENGTH_FOR_PREFIX = 20;
-function redactSecret(secret) {
-  const value = typeof secret === "string" ? secret.trim() : "";
-  if (value.length < MIN_LENGTH_FOR_TAIL) return MASK;
-  const tail = value.slice(-TAIL);
-  if (value.length < MIN_LENGTH_FOR_PREFIX) return `${MASK}${tail}`;
-  return `${value.slice(0, PREFIX)}\u2026${tail}`;
-}
-var STORE_VERSION = 2;
-var DEFAULT_ACCOUNT_ID = "default";
-var KNOWN_PROVIDER_IDS = new Set(PROVIDERS.map((provider) => provider.id));
-function emptyStore() {
-  return { version: STORE_VERSION, providers: {} };
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSafeKey(key) {
-  return key.length > 0 && key !== "__proto__" && key !== "constructor" && key !== "prototype";
-}
-function trimmedString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function normalizeTokens(raw) {
-  if (!isPlainObject(raw)) return void 0;
-  const tokens = {};
-  const accessToken = trimmedString(raw.accessToken);
-  const refreshToken = trimmedString(raw.refreshToken);
-  if (accessToken !== void 0) tokens.accessToken = accessToken;
-  if (refreshToken !== void 0) tokens.refreshToken = refreshToken;
-  if (tokens.accessToken === void 0 && tokens.refreshToken === void 0) return void 0;
-  if (typeof raw.expiresAt === "number" && Number.isFinite(raw.expiresAt)) tokens.expiresAt = raw.expiresAt;
-  const tokenType = trimmedString(raw.tokenType);
-  if (tokenType !== void 0) tokens.tokenType = tokenType;
-  const scope = trimmedString(raw.scope);
-  if (scope !== void 0) tokens.scope = scope;
-  return tokens;
-}
-function normalizeIdentity(raw) {
-  if (!isPlainObject(raw)) return void 0;
-  const identity = {};
-  const label = trimmedString(raw.label);
-  const accountId = trimmedString(raw.accountId);
-  const email = trimmedString(raw.email);
-  if (label !== void 0) identity.label = label;
-  if (accountId !== void 0) identity.accountId = accountId;
-  if (email !== void 0) identity.email = email;
-  return Object.keys(identity).length > 0 ? identity : void 0;
-}
-function normalizeRecord(providerId, raw) {
-  if (!isPlainObject(raw)) return void 0;
-  if (raw.kind === "api_key") {
-    if (!providerSupportsMethod(providerId, "api-key")) return void 0;
-    const secret = trimmedString(raw.secret);
-    return secret === void 0 ? void 0 : { kind: "api_key", secret };
-  }
-  if (raw.kind === "oauth") {
-    if (!providerSupportsMethod(providerId, "oauth")) return void 0;
-    const tokens = normalizeTokens(raw.tokens);
-    if (tokens === void 0) return void 0;
-    const identity = normalizeIdentity(raw.identity);
-    return identity === void 0 ? { kind: "oauth", tokens } : { kind: "oauth", tokens, identity };
-  }
-  return void 0;
-}
-function normalizeProviderAccounts(providerId, raw) {
-  if (!isPlainObject(raw)) return void 0;
-  const accountsRaw = isPlainObject(raw.accounts) ? raw.accounts : {};
-  const accounts = {};
-  for (const [accountId, recordRaw] of Object.entries(accountsRaw)) {
-    if (!isSafeKey(accountId)) continue;
-    const record = normalizeRecord(providerId, recordRaw);
-    if (record !== void 0) accounts[accountId] = record;
-  }
-  const ids = Object.keys(accounts);
-  if (ids.length === 0) return void 0;
-  const active = typeof raw.activeAccountId === "string" && accounts[raw.activeAccountId] !== void 0 ? raw.activeAccountId : ids[0];
-  return { activeAccountId: active, accounts };
-}
-function normalizeAccountStore(raw) {
-  if (!isPlainObject(raw)) return emptyStore();
-  const looksV2 = isPlainObject(raw.providers) || raw.version !== void 0;
-  const store = emptyStore();
-  if (looksV2) {
-    const providersRaw = isPlainObject(raw.providers) ? raw.providers : {};
-    for (const [providerId, entry] of Object.entries(providersRaw)) {
-      if (!isSafeKey(providerId) || !KNOWN_PROVIDER_IDS.has(providerId)) continue;
-      const accounts = normalizeProviderAccounts(providerId, entry);
-      if (accounts !== void 0) store.providers[providerId] = accounts;
+    const globalValue = strictValueAt(globalRaw, key);
+    if (globalValue !== void 0) {
+      settings[key] = globalValue;
+      sources[key] = "global";
+      continue;
     }
-    return store;
+    settings[key] = DEFAULT_SETTINGS[key];
+    sources[key] = "default";
   }
-  for (const [providerId, secret] of Object.entries(normalizeCredentials(raw))) {
-    store.providers[providerId] = {
-      activeAccountId: DEFAULT_ACCOUNT_ID,
-      accounts: { [DEFAULT_ACCOUNT_ID]: { kind: "api_key", secret } }
-    };
+  return { settings, sources };
+}
+function loadLayeredSettings(opts = {}) {
+  syncThemeChoices(opts.homeDir);
+  const globalRaw = readRawSettingsFile(settingsFilePath(opts.homeDir));
+  const projectRaw = readRawSettingsFile(projectSettingsFilePath(opts.projectDir));
+  return resolveLayeredSettings(globalRaw, projectRaw);
+}
+function rawValue(raw, key) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const value = raw[key];
+  if (key === "analyticsLevel" && value !== void 0) {
+    return value === "usage" || value === "commands" || value === "full" ? "usage" : "off";
   }
-  return store;
+  return key === "transcriptStyle" && value === "messenger" ? "bubble" : value;
 }
-function loadAccountStore(homeDir2) {
-  try {
-    const text = readFileSync4(credentialsFilePath(homeDir2), "utf8");
-    return normalizeAccountStore(JSON.parse(text));
-  } catch {
-    return emptyStore();
+function booleanAt(raw, key) {
+  const value = rawValue(raw, key);
+  return typeof value === "boolean" ? value : DEFAULT_SETTINGS[key];
+}
+function enumAt(raw, key) {
+  const def = DEF_BY_KEY.get(key);
+  const value = rawValue(raw, key);
+  const choices = def?.choices ?? [];
+  return typeof value === "string" && choices.includes(value) ? value : DEFAULT_SETTINGS[key];
+}
+function themeAt(raw) {
+  const value = rawValue(raw, "theme");
+  return typeof value === "string" && isKnownTheme(value) ? value : DEFAULT_SETTINGS.theme;
+}
+function keybindingsAt(raw) {
+  return sanitizeKeybindingOverrides(rawValue(raw, "keybindings"));
+}
+function normalizeModelPreference(raw) {
+  if (raw === null) return null;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const value = raw;
+  if (typeof value.providerId !== "string" || !value.providerId.trim() || typeof value.model !== "string" || !value.model.trim() || typeof value.connectionIdentity !== "string" || !/^[a-f0-9]{64}$/.test(value.connectionIdentity)) return void 0;
+  return { providerId: value.providerId, model: value.model, connectionIdentity: value.connectionIdentity };
+}
+function normalizeSettings(raw) {
+  return {
+    showStatusBar: booleanAt(raw, "showStatusBar"),
+    showComposerHints: booleanAt(raw, "showComposerHints"),
+    composerSuggestions: booleanAt(raw, "composerSuggestions"),
+    mouseSupport: booleanAt(raw, "mouseSupport"),
+    showLogo: booleanAt(raw, "showLogo"),
+    showRuntimeNotices: booleanAt(raw, "showRuntimeNotices"),
+    showTurnSummary: booleanAt(raw, "showTurnSummary"),
+    showSubagents: booleanAt(raw, "showSubagents"),
+    showTimestamps: booleanAt(raw, "showTimestamps"),
+    showObjective: booleanAt(raw, "showObjective"),
+    showScope: booleanAt(raw, "showScope"),
+    density: enumAt(raw, "density"),
+    composerStyle: enumAt(raw, "composerStyle"),
+    busyInputMode: enumAt(raw, "busyInputMode"),
+    onboardingCompleted: booleanAt(raw, "onboardingCompleted"),
+    executionProfile: enumAt(raw, "executionProfile"),
+    allowSubagentPeerMessaging: booleanAt(raw, "allowSubagentPeerMessaging"),
+    allowSubagentOperatorMessaging: booleanAt(raw, "allowSubagentOperatorMessaging"),
+    transcriptStyle: enumAt(raw, "transcriptStyle"),
+    roleLabelStyle: enumAt(raw, "roleLabelStyle"),
+    toolCardStyle: enumAt(raw, "toolCardStyle"),
+    richToolCards: booleanAt(raw, "richToolCards"),
+    transcriptDetail: enumAt(raw, "transcriptDetail"),
+    autoCompaction: booleanAt(raw, "autoCompaction"),
+    compactionThreshold: enumAt(raw, "compactionThreshold"),
+    theme: themeAt(raw),
+    allowModelSelfExtension: booleanAt(raw, "allowModelSelfExtension"),
+    allowDevSourceUpdates: booleanAt(raw, "allowDevSourceUpdates"),
+    autoEvolveFinderLenses: booleanAt(raw, "autoEvolveFinderLenses"),
+    autoPromoteFinderLenses: booleanAt(raw, "autoPromoteFinderLenses"),
+    showTokenUsage: booleanAt(raw, "showTokenUsage"),
+    showCost: booleanAt(raw, "showCost"),
+    showContextMeter: booleanAt(raw, "showContextMeter"),
+    modelDisplay: enumAt(raw, "modelDisplay"),
+    elapsedTimer: enumAt(raw, "elapsedTimer"),
+    logoAnimation: enumAt(raw, "logoAnimation"),
+    reduceMotion: booleanAt(raw, "reduceMotion"),
+    analyticsLevel: enumAt(raw, "analyticsLevel"),
+    diagnosticReporting: strictValueAt(raw, "diagnosticReporting") ?? DEFAULT_SETTINGS.diagnosticReporting,
+    diagnosticReportingPrompted: booleanAt(raw, "diagnosticReportingPrompted"),
+    updatePolicy: strictValueAt(raw, "updatePolicy") ?? DEFAULT_SETTINGS.updatePolicy,
+    symbolPreset: enumAt(raw, "symbolPreset"),
+    rosterSort: enumAt(raw, "rosterSort"),
+    leaderKey: enumAt(raw, "leaderKey"),
+    keybindings: keybindingsAt(raw),
+    modelPreference: normalizeModelPreference(rawValue(raw, "modelPreference")) ?? null
+  };
+}
+function loadSettings(homeDir, projectDir) {
+  return loadLayeredSettings({ homeDir, projectDir }).settings;
+}
+function loadGlobalSettings(homeDir, options = {}) {
+  syncThemeChoices(homeDir);
+  const raw = readRawSettingsFile(settingsFilePath(homeDir));
+  if (options.requireExecutionProfile && strictValueAt(raw, "executionProfile") === void 0) {
+    throw new Error("Configured workbench execution profile is missing or invalid. Run 0 workbench setup or 0 workbench disable to make an explicit operator choice; host fallback is refused.");
   }
+  return normalizeSettings(raw);
 }
-function saveAccountStore(store, homeDir2) {
+function saveSettings(settings, homeDir) {
+  const path = settingsFilePath(homeDir);
+  const temporary = `${path}.${randomUUID2()}.tmp`;
   try {
-    const path = credentialsFilePath(homeDir2);
-    const dir = dirname3(path);
-    mkdirSync3(dir, { recursive: true, mode: DIR_MODE });
-    chmodSync(dir, DIR_MODE);
-    writeFileSync3(path, `${JSON.stringify(normalizeAccountStore(store), null, 2)}
-`, {
-      encoding: "utf8",
-      mode: FILE_MODE
-    });
-    chmodSync(path, FILE_MODE);
+    mkdirSync2(dirname3(path), { recursive: true });
+    writeFileSync2(temporary, `${JSON.stringify(normalizeSettings(settings), null, 2)}
+`, { encoding: "utf8", flag: "wx", mode: 384 });
+    renameSync(temporary, path);
     return true;
   } catch {
     return false;
+  } finally {
+    try {
+      rmSync2(temporary, { force: true });
+    } catch {
+    }
   }
 }
-function getActiveAccount(store, providerId) {
-  const entry = store.providers[providerId];
-  if (entry === void 0) return void 0;
-  const id = entry.activeAccountId;
-  if (id !== void 0 && entry.accounts[id] !== void 0) return entry.accounts[id];
-  const first = Object.keys(entry.accounts)[0];
-  return first === void 0 ? void 0 : entry.accounts[first];
-}
-function chooseAccountId(record, requested) {
-  if (requested !== void 0 && isSafeKey(requested)) return requested;
-  if (record.kind === "oauth" && record.identity?.accountId !== void 0 && isSafeKey(record.identity.accountId)) {
-    return record.identity.accountId;
-  }
-  if (record.kind === "api_key") return DEFAULT_ACCOUNT_ID;
-  return `account-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function addAccount(store, providerId, record, options) {
-  if (!KNOWN_PROVIDER_IDS.has(providerId)) {
-    throw new Error(`unknown provider "${providerId}"`);
-  }
-  const method = record.kind === "api_key" ? "api-key" : "oauth";
-  if (!providerSupportsMethod(providerId, method)) {
-    throw new Error(`provider "${providerId}" does not support ${record.kind} accounts`);
-  }
-  const accountId = chooseAccountId(record, options?.accountId);
-  const existing = store.providers[providerId];
-  const accounts = { ...existing?.accounts ?? {} };
-  accounts[accountId] = record;
-  const makeActive = options?.makeActive ?? true;
-  const activeAccountId = makeActive ? accountId : existing?.activeAccountId !== void 0 && accounts[existing.activeAccountId] !== void 0 ? existing.activeAccountId : accountId;
-  return {
-    store: { version: STORE_VERSION, providers: { ...store.providers, [providerId]: { activeAccountId, accounts } } },
-    accountId
-  };
+function sanitizeOverrides(raw) {
+  const out = {};
+  for (const key of Object.keys(DEFAULT_SETTINGS)) {
+    if (isOperatorSetting(key)) continue;
+    const value = strictValueAt(raw, key);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
 }
-function accountEnvPatch(store, env) {
-  const normalized = normalizeAccountStore(store);
-  const patch = {};
-  for (const info of PROVIDERS) {
-    const record = getActiveAccount(normalized, info.id);
-    if (record === void 0) continue;
-    if (info.envVars.some((name) => hasCredential2(env[name]))) continue;
-    if (record.kind === "api_key") {
-      const target = info.envVars[0];
-      if (target !== void 0) patch[target] = record.secret;
-      continue;
-    }
-    const accessVar = info.envVars[0];
-    if (accessVar !== void 0 && record.tokens.accessToken !== void 0) {
-      patch[accessVar] = record.tokens.accessToken;
-    }
-    if (record.tokens.refreshToken !== void 0) {
-      const refreshVar = info.envVars.find((name) => /REFRESH/i.test(name));
-      if (refreshVar !== void 0) patch[refreshVar] = record.tokens.refreshToken;
-    }
+function readProjectOverrides(projectDir) {
+  return sanitizeOverrides(readRawSettingsFile(projectSettingsFilePath(projectDir)));
+}
+function saveProjectOverrides(patch, projectDir) {
+  try {
+    const path = projectSettingsFilePath(projectDir);
+    mkdirSync2(dirname3(path), { recursive: true });
+    writeFileSync2(path, `${JSON.stringify(sanitizeOverrides(patch), null, 2)}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
   }
-  return patch;
 }
 
 // packages/cli/src/tui/feedback.ts
-import { appendFileSync, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-function feedbackFilePath(homeDir2) {
-  return join6(homeDir2 ?? homedir2(), ".0", "feedback.md");
+import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { dirname as dirname4, join as join7 } from "node:path";
+import { homedir } from "node:os";
+function feedbackFilePath(homeDir) {
+  return join7(homeDir ?? homedir(), ".0", "feedback.md");
 }
 function formatFeedbackEntry(entry) {
   const context = [
@@ -2781,10 +2824,10 @@ function formatFeedbackEntry(entry) {
   return `${lines.join("\n")}
 `;
 }
-function appendFeedback(entry, homeDir2) {
-  const path = feedbackFilePath(homeDir2);
+function appendFeedback(entry, homeDir) {
+  const path = feedbackFilePath(homeDir);
   try {
-    mkdirSync4(dirname4(path), { recursive: true });
+    mkdirSync3(dirname4(path), { recursive: true });
     appendFileSync(path, formatFeedbackEntry(entry), "utf8");
     return { ok: true, path };
   } catch (error) {
@@ -2808,6 +2851,7 @@ function parseFeedbackCommand(raw) {
 }
 var DEFAULT_FEEDBACK_URL = "";
 var FEEDBACK_URL_ENV = "ZERO_FEEDBACK_URL";
+var SENTRY_DSN_ENV = "ZERO_SENTRY_DSN";
 var CLOUD_FEEDBACK_PATH = "/api/cli-feedback";
 function defaultCloudCredentials(env) {
   try {
@@ -2833,6 +2877,24 @@ function cloudFeedbackUrl(host) {
     return null;
   }
 }
+function resolveSentryTarget(dsn) {
+  try {
+    const parsed = new URL(dsn);
+    const key = parsed.username;
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    const project = segments.pop();
+    if (parsed.protocol !== "https:" || parsed.password || parsed.search || parsed.hash || !/^[A-Za-z0-9_-]+$/.test(key) || !project || !/^\d+$/.test(project) || segments.some((segment) => !/^[A-Za-z0-9_-]+$/.test(segment))) return { url: "" };
+    parsed.username = "";
+    parsed.pathname = `/${[...segments, "api", project, "envelope"].join("/")}/`;
+    return { url: parsed.toString(), sentryKey: key };
+  } catch {
+    return { url: "" };
+  }
+}
+function resolveSubmissionTarget(payload, env, options) {
+  const dsn = env[SENTRY_DSN_ENV]?.trim();
+  return payload.diagnostic && dsn ? resolveSentryTarget(dsn) : resolveFeedbackTarget(env, options);
+}
 function resolveFeedbackTarget(env = process.env, options = {}) {
   const configured = env[FEEDBACK_URL_ENV]?.trim();
   if (configured) return { url: configured };
@@ -2852,11 +2914,11 @@ function isOptOutSet(value) {
   if (normalized === "") return false;
   return normalized !== "0" && normalized !== "false" && normalized !== "no";
 }
-function submissionBlockedReason(env = process.env, options = {}) {
+function submissionBlockedReason(env = process.env, options = {}, payload) {
   for (const name of FEEDBACK_OPT_OUT_ENV) {
     if (isOptOutSet(env[name])) return "opt-out";
   }
-  return targetBlockedReason(resolveFeedbackTarget(env, options));
+  return targetBlockedReason(payload ? resolveSubmissionTarget(payload, env, options) : resolveFeedbackTarget(env, options));
 }
 function targetBlockedReason(target) {
   if (target === null) return "no-endpoint";
@@ -2866,7 +2928,7 @@ function targetBlockedReason(target) {
   } catch {
     return "insecure-endpoint";
   }
-  if (parsed.protocol !== "https:") return "insecure-endpoint";
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.hash) return "insecure-endpoint";
   return null;
 }
 function describeSkip(reason) {
@@ -2876,7 +2938,9 @@ function describeSkip(reason) {
     case "no-endpoint":
       return `No feedback endpoint configured (set ${FEEDBACK_URL_ENV}). Saved locally only.`;
     case "insecure-endpoint":
-      return `Refusing a non-HTTPS ${FEEDBACK_URL_ENV}. Saved locally only.`;
+      return "Refusing an invalid or non-HTTPS telemetry endpoint. Saved locally only.";
+    case "no-consent":
+      return "Problem report requires confirmation or an automatic-reporting preference. Saved locally only.";
   }
 }
 var SECRET_RULES = [
@@ -2924,30 +2988,38 @@ function serializePayload(payload) {
 }
 function requestHeaders(target, redactAuthorization = false) {
   const headers = { "content-type": "application/json" };
+  if (target.sentryKey) {
+    headers["content-type"] = "application/x-sentry-envelope";
+    headers["x-sentry-auth"] = `Sentry sentry_version=7,sentry_key=${redactAuthorization ? "<redacted>" : target.sentryKey},sentry_client=0-cli/${VERSION}`;
+  }
   if (target.authorization) {
     headers.authorization = redactAuthorization ? "Bearer <redacted>" : target.authorization;
   }
   return headers;
 }
 function buildSubmitPreview(payload, env = process.env, options = {}) {
-  if (submissionBlockedReason(env, options) !== null) return null;
-  const target = resolveFeedbackTarget(env, options);
-  if (target === null) return null;
+  if (FEEDBACK_OPT_OUT_ENV.some((name) => isOptOutSet(env[name]))) return null;
+  const target = resolveSubmissionTarget(payload, env, options);
+  if (target === null || targetBlockedReason(target) !== null) return null;
   return {
     url: target.url,
-    body: serializePayload(payload),
+    body: serializeSubmission(payload, target, env),
     headers: requestHeaders(target, true),
-    warnings: scanForSecrets(payload.message)
+    warnings: target.sentryKey ? [] : scanForSecrets(payload.message)
   };
 }
 async function submitFeedback(payload, env = process.env, opts = {}) {
-  const blocked = submissionBlockedReason(env, opts);
-  if (blocked !== null) return { ok: false, skipped: blocked, error: describeSkip(blocked) };
-  const target = resolveFeedbackTarget(env, opts);
+  if (FEEDBACK_OPT_OUT_ENV.some((name) => isOptOutSet(env[name]))) {
+    return { ok: false, skipped: "opt-out", error: describeSkip("opt-out") };
+  }
+  if (payload.diagnostic && opts.diagnosticConsent?.confirmed !== true && opts.diagnosticConsent?.policy !== "automatic") {
+    return { ok: false, skipped: "no-consent", error: describeSkip("no-consent") };
+  }
+  const target = resolveSubmissionTarget(payload, env, opts);
   const targetBlocked = targetBlockedReason(target);
   if (targetBlocked !== null) return { ok: false, skipped: targetBlocked, error: describeSkip(targetBlocked) };
   if (target === null) return { ok: false, skipped: "no-endpoint", error: describeSkip("no-endpoint") };
-  const body = serializePayload(payload);
+  const body = serializeSubmission(payload, target, env);
   if (Buffer.byteLength(body, "utf8") > MAX_BODY_BYTES) {
     return { ok: false, error: `Message too large to submit (limit ${MAX_BODY_BYTES} bytes).` };
   }
@@ -2957,7 +3029,7 @@ async function submitFeedback(payload, env = process.env, opts = {}) {
     if (target.url !== reviewed.url || body !== reviewed.body || Object.keys(currentHeaders).length !== Object.keys(reviewed.headers).length || !Object.keys(currentHeaders).every((k) => currentHeaders[k] === reviewed.headers[k])) {
       return {
         ok: false,
-        error: "Reviewed feedback destination has changed. Preview the updated submission before sending again."
+        error: "Reviewed telemetry destination has changed. Preview the updated submission before sending again."
       };
     }
   }
@@ -2965,10 +3037,10 @@ async function submitFeedback(payload, env = process.env, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? FEEDBACK_TIMEOUT_MS;
   const controller = new AbortController();
   let timer;
-  const timeout = new Promise((resolve) => {
+  const timeout = new Promise((resolve2) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve({ ok: false, error: `Feedback submission timed out after ${timeoutMs}ms.` });
+      resolve2({ ok: false, error: `Feedback submission timed out after ${timeoutMs}ms.` });
     }, timeoutMs);
     timer.unref?.();
   });
@@ -2982,8 +3054,8 @@ async function submitFeedback(payload, env = process.env, opts = {}) {
         redirect: "error"
       });
       return response.ok ? { ok: true, status: response.status } : { ok: false, status: response.status, error: `Endpoint returned ${response.status}.` };
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    } catch {
+      return { ok: false, error: "Feedback submission failed." };
     }
   })();
   try {
@@ -3031,7 +3103,7 @@ function diagnosticVersion(raw) {
   if (typeof raw !== "string" || raw.length > 128) return "unknown";
   return /^v?(\d{1,6}\.\d{1,6}\.\d{1,6})(?:[-+][a-zA-Z0-9.+-]+)?$/.exec(raw)?.[1] ?? "unknown";
 }
-function buildDiagnosticFeedback(info, env = process.env) {
+function buildDiagnosticFeedback(info) {
   const kind = info.kind === "tool" ? "tool" : info.kind === "runtime" ? "runtime" : "unknown";
   const platform = DIAGNOSTIC_PLATFORMS.has(info.platform) ? info.platform : "unknown";
   const arch = DIAGNOSTIC_ARCHS.has(info.arch) ? info.arch : "unknown";
@@ -3039,90 +3111,251 @@ function buildDiagnosticFeedback(info, env = process.env) {
   const runtimeVersion = diagnosticVersion(info.runtimeVersion);
   const version = diagnosticVersion(info.version);
   const timestamp = typeof info.timestamp === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(info.timestamp) && Number.isFinite(Date.parse(info.timestamp)) ? info.timestamp : (/* @__PURE__ */ new Date()).toISOString();
-  let message = `Diagnostic: ${kind} error \u2014 ${platform}/${arch} on ${runtime} ${runtimeVersion}
+  const category = diagnosticError(info.error);
+  const message = `Diagnostic: ${kind} error \u2014 ${platform}/${arch} on ${runtime} ${runtimeVersion}
 Version: ${version}
-Error: ${diagnosticError(info.error)}`;
-  if (diagnosticDetailAllowed(env)) {
-    const detail = redactDiagnosticDetail(buildDiagnosticDetailText(info));
-    if (detail) message = capUtf8Bytes(`${message}
-
-${detail}`, MAX_DIAGNOSTIC_DETAIL_MESSAGE_BYTES);
-  }
-  return { message, timestamp, version };
-}
-var MAX_DIAGNOSTIC_DETAIL_MESSAGE_BYTES = 8192;
-var MAX_DIAGNOSTIC_DETAIL_CHARS = 6e3;
-function diagnosticDetailAllowed(env) {
-  const level = (env["ZERO_ANALYTICS_LEVEL"] ?? "").trim().toLowerCase();
-  return level === "commands" || level === "full";
+Error: ${category}`;
+  return {
+    message,
+    timestamp,
+    version,
+    diagnostic: {
+      eventId: randomUUID3().replaceAll("-", ""),
+      kind,
+      category,
+      platform,
+      arch,
+      runtime,
+      runtimeVersion,
+      frames: diagnosticFrames(info.error)
+    }
+  };
 }
-function buildDiagnosticDetailText(info) {
-  const parts = [];
-  if (info.toolName) parts.push(`Tool: ${info.toolName}`);
-  const err = info.error;
-  if (err instanceof Error) {
-    parts.push(`${err.name}: ${err.message || "(no message)"}`);
-    if (typeof err.stack === "string" && err.stack.trim()) parts.push(err.stack.trim());
-  } else {
-    const text = diagnosticErrorText(err);
-    if (text) parts.push(text);
-  }
-  const exitOutput = typeof info.exitOutput === "string" ? info.exitOutput.trim() : "";
-  if (exitOutput && !parts.some((p) => p.includes(exitOutput))) parts.push(exitOutput);
-  let detail = parts.join("\n").trim();
-  if (detail.length > MAX_DIAGNOSTIC_DETAIL_CHARS) detail = detail.slice(0, MAX_DIAGNOSTIC_DETAIL_CHARS - 1) + "\u2026";
-  return detail;
-}
-var DETAIL_REDACTIONS = [
-  { re: /-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----[\s\S]*?-----END (?:[A-Z0-9 ]+ )?PRIVATE KEY-----/g, to: "\u2039redacted:private-key\u203A" },
-  { re: /\bsk-[A-Za-z0-9_-]{16,}/g, to: "\u2039redacted:key\u203A" },
-  { re: /\bgh[pousr]_[A-Za-z0-9]{20,}/g, to: "\u2039redacted:gh-token\u203A" },
-  { re: /\b(?:AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{16}\b/g, to: "\u2039redacted:aws-key\u203A" },
-  { re: /\bAIza[0-9A-Za-z_-]{35}\b/g, to: "\u2039redacted:gcp-key\u203A" },
-  { re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, to: "\u2039redacted:slack-token\u203A" },
-  { re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g, to: "\u2039redacted:jwt\u203A" },
-  { re: /authorization\s*[:=]\s*(?:bearer|basic|token|digest)\s+\S+/gi, to: "authorization: \u2039redacted\u203A" },
-  { re: /\b((?:pass(?:word|wd)?|api[_-]?key|secret|token|credentials?)\s*[:=]\s*)\S{6,}/gi, to: "$1\u2039redacted\u203A" },
-  // Connection strings: keep the scheme/host shape, drop the inline credentials.
-  // MUST run before the email rule so `user:pass@host` is not mis-read as an
-  // email (which would swallow the host too).
-  { re: /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi, to: "$1\u2039redacted\u203A@" },
-  { re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, to: "\u2039redacted:email\u203A" },
-  // Home-dir usernames in file paths — keep the path shape, anonymise the user.
-  { re: /(\/home\/)[^/\s]+/g, to: "$1\u2039user\u203A" },
-  { re: /(\/Users\/)[^/\s]+/g, to: "$1\u2039user\u203A" },
-  { re: /([A-Za-z]:\\Users\\)[^\\\s]+/g, to: "$1\u2039user\u203A" }
-];
-function redactDiagnosticDetail(text) {
-  if (typeof text !== "string" || text.length === 0) return "";
+function diagnosticFrames(error) {
   try {
-    let out = text;
-    for (const { re, to } of DETAIL_REDACTIONS) out = out.replace(re, to);
-    return out;
+    if (!(error instanceof Error) || typeof error.stack !== "string") return [];
+    const frames = [];
+    for (const line of error.stack.slice(0, 16384).split("\n").slice(1, 33)) {
+      const match = /(?:^|[/\\])(packages[/\\](?:cli|core|shared)[/\\](?:src|dist)[/\\][A-Za-z0-9_./\\-]+\.[cm]?[jt]sx?):(\d{1,7}):(\d{1,7})\)?$/.exec(line.trim());
+      if (!match || match[1].split(/[/\\]/).some((part) => part === "..")) continue;
+      const lineno = Number(match[2]);
+      const colno = Number(match[3]);
+      if (lineno > 0 && colno > 0) {
+        frames.push({ filename: `app:///${match[1].replaceAll("\\", "/")}`, lineno, colno });
+      }
+    }
+    return frames.reverse();
   } catch {
-    return "";
-  }
+    return [];
+  }
+}
+function serializeSubmission(payload, target, env) {
+  if (!target.sentryKey || !payload.diagnostic) return serializePayload(payload);
+  const diagnostic = payload.diagnostic;
+  const cliVersion = VERSION;
+  const commit = /^[0-9a-f]{40}$/i.test("531d93617a529a487a9d94e6c20886903ffc40ec") ? "531d93617a529a487a9d94e6c20886903ffc40ec".toLowerCase() : void 0;
+  const environment = env["NODE_ENV"] === "development" ? "development" : env["NODE_ENV"] === "production" || true ? "production" : "development";
+  const event = JSON.stringify({
+    event_id: diagnostic.eventId,
+    timestamp: Date.parse(payload.timestamp) / 1e3,
+    platform: "node",
+    level: "error",
+    logger: "0.cli",
+    release: `0-cli@${cliVersion}${commit ? `+${commit}` : ""}`,
+    environment,
+    tags: {
+      cli_version: cliVersion,
+      ...commit ? { build_commit: commit } : {},
+      kind: diagnostic.kind,
+      platform: diagnostic.platform,
+      arch: diagnostic.arch,
+      runtime: diagnostic.runtime
+    },
+    contexts: { runtime: { name: diagnostic.runtime, version: diagnostic.runtimeVersion } },
+    exception: {
+      values: [{
+        type: "CLIError",
+        value: diagnostic.category,
+        ...diagnostic.frames.length ? { stacktrace: { frames: diagnostic.frames } } : {}
+      }]
+    }
+  });
+  return `${JSON.stringify({ event_id: diagnostic.eventId })}
+${JSON.stringify({ type: "event", length: Buffer.byteLength(event, "utf8") })}
+${event}
+`;
 }
-function capUtf8Bytes(text, maxBytes) {
-  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-  let lo = 0, hi = text.length;
-  while (lo < hi) {
-    const mid = Math.ceil((lo + hi) / 2);
-    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes - 1) lo = mid;
-    else hi = mid - 1;
+
+// packages/cli/src/workbench.ts
+var WORKBENCH_INNER_ARGUMENT = "--workbench-inner";
+function workbenchConfigPath(home = process.env.HOME || homedir2()) {
+  return join8(homeStateDir(home), "workbench.json");
+}
+function defaultWorkbenchStateRoot(home = process.env.HOME || homedir2()) {
+  return join8(homeStateDir(home), "workbench");
+}
+function positiveInteger(value, maximum) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= maximum;
+}
+function isPinnedWorkbenchImageReference(value) {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9._:/-]*@sha256:[a-f0-9]{64}$/.test(value) && !value.slice(0, value.indexOf("@")).slice(value.lastIndexOf("/") + 1).includes(":");
+}
+function normalizeWorkbenchConfig(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error("Invalid workbench operator choices.");
+  const config = raw;
+  if (config.github === true) throw new Error("GitHub credential forwarding is not supported by the isolated workbench. Revoke the GitHub grant before launch.");
+  if (Array.isArray(config.providers) && config.providers.some((provider) => provider !== "chatgpt-codex")) throw new Error("The isolated workbench currently supports only host-brokered chatgpt-codex grants.");
+  const approvedImages = [];
+  if (config.approvedImages !== void 0) {
+    if (!Array.isArray(config.approvedImages)) throw new Error("Invalid workbench sandbox image catalog.");
+    const references = /* @__PURE__ */ new Set();
+    for (const rawImage of config.approvedImages) {
+      if (typeof rawImage !== "object" || rawImage === null || Array.isArray(rawImage)) throw new Error("Invalid workbench sandbox image catalog.");
+      const image = rawImage;
+      if (!isPinnedWorkbenchImageReference(image.reference) || typeof image.archive !== "string" || !isAbsolute2(image.archive) || typeof image.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(image.digest) || references.has(image.reference)) throw new Error("Sandbox image grants require unique immutable repository@sha256 references and approved local archives.");
+      references.add(image.reference);
+      approvedImages.push({ reference: image.reference, archive: image.archive, digest: image.digest });
+    }
   }
-  return text.slice(0, lo) + "\u2026";
+  if (config.schemaVersion !== 1 || typeof config.image !== "string" || !isAbsolute2(config.image) || typeof config.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(config.imageDigest) || typeof config.stateRoot !== "string" || !isAbsolute2(config.stateRoot) || config.workspaceRoot !== void 0 && (typeof config.workspaceRoot !== "string" || !isAbsolute2(config.workspaceRoot)) || !Array.isArray(config.providers) || config.providers.some((id) => typeof id !== "string" || !PROVIDERS.some((provider) => provider.id === id)) || typeof config.github !== "boolean" || !positiveInteger(config.cpus, 64) || !positiveInteger(config.memoryMb, 262144) || !positiveInteger(config.storageGb, 1024)) {
+    throw new Error("Invalid workbench operator choices.");
+  }
+  return {
+    schemaVersion: 1,
+    image: config.image,
+    imageDigest: config.imageDigest,
+    stateRoot: config.stateRoot,
+    ...config.workspaceRoot === void 0 ? {} : { workspaceRoot: config.workspaceRoot },
+    providers: [...new Set(config.providers)],
+    github: config.github,
+    cpus: config.cpus,
+    memoryMb: config.memoryMb,
+    storageGb: config.storageGb,
+    ...approvedImages.length ? { approvedImages } : {}
+  };
 }
-function diagnosticErrorText(error) {
-  if (typeof error === "string") return error.trim();
-  if (error instanceof Error) return (error.message || error.name || "Error").trim();
-  if (error === null || error === void 0) return "";
+function loadWorkbenchConfig(home) {
+  const file = workbenchConfigPath(home);
+  if (!existsSync2(file)) return void 0;
   try {
-    const text = String(error).trim();
-    return text === "[object Object]" ? "" : text;
-  } catch {
-    return "";
+    const stat = lstatSync2(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 63) !== 0 || stat.uid !== process.getuid?.()) {
+      throw new Error("Workbench configuration must be an operator-owned, private regular file (mode 0600).");
+    }
+    return normalizeWorkbenchConfig(JSON.parse(readFileSync3(file, "utf8")));
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Workbench configuration must")) throw error;
+    throw new Error(`Unreadable or invalid workbench configuration at ${file}. Repair the operator choices before setup or launch; no profile fallback is allowed.`);
+  }
+}
+function saveWorkbenchConfig(config, home) {
+  const path = workbenchConfigPath(home);
+  mkdirSync4(dirname5(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync3(temporary, `${JSON.stringify(normalizeWorkbenchConfig(config), null, 2)}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+  renameSync2(temporary, path);
+  chmodSync(path, 384);
+}
+function resolveWorkbenchGuestSettings(settings, env = process.env) {
+  const privacy = { [ANALYTICS_LEVEL_ENV]: env[ANALYTICS_LEVEL_ENV] ?? settings.analyticsLevel };
+  for (const name of FEEDBACK_OPT_OUT_ENV) privacy[name] = env[name];
+  const environmentLevel = resolveAnalyticsLevel(privacy);
+  return normalizeSettings({
+    ...settings,
+    executionProfile: "local",
+    updatePolicy: "off",
+    analyticsLevel: levelAtLeast(environmentLevel, settings.analyticsLevel) ? settings.analyticsLevel : environmentLevel,
+    diagnosticReporting: submissionBlockedReason(privacy, { allowCloud: false }) === "opt-out" ? "off" : settings.diagnosticReporting
+  });
+}
+function workbenchNetworkEnabled(env = process.env) {
+  return submissionBlockedReason({ ZERO_OFFLINE: env.ZERO_OFFLINE }, { allowCloud: false }) !== "opt-out";
+}
+async function launchConfiguredWorkbench(args) {
+  const home = process.env.HOME || homedir2();
+  if (args[0] === WORKBENCH_INNER_ARGUMENT) {
+    if (process.platform !== "linux" || !isAdmittedSmolvmWorkbench()) {
+      throw new Error("Missing authenticated SmolVM broker admission; refusing internal invocation.");
+    }
+    process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+    return void 0;
+  }
+  if (process.platform === "linux" && isAdmittedSmolvmWorkbench()) return void 0;
+  if (["workbench", "config", "web", "dashboard", "console", "tui", "doctor", "help", "--help", "-h", "--version", "-v"].includes(args[0] ?? "") || args.length === 0) return void 0;
+  const hostSettings = loadGlobalSettings(home, { requireExecutionProfile: existsSync2(workbenchConfigPath(home)) });
+  if (hostSettings.executionProfile !== "smolvm") return void 0;
+  const config = loadWorkbenchConfig(home);
+  if (!config) throw new Error("SmolVM profile is selected but no workbench is configured. Run 0 workbench setup --image <approved-archive>.");
+  const workspaceRoot = realpathSync3(config.workspaceRoot ?? process.cwd());
+  if (!lstatSync2(workspaceRoot).isDirectory()) throw new Error("The configured workbench workspace is not a directory.");
+  const status = await getSmolvmWorkbenchStatus({ stateRoot: config.stateRoot, image: config.image });
+  if (!status.platformSupported || !status.runtimeReady || !status.imageApproved) {
+    throw new Error(status.error ?? "SmolVM runtime or approved image is unavailable. Run 0 workbench setup; host fallback is refused.");
+  }
+  const modelIndex = args.findIndex((argument) => argument === "--model" || argument === "-m");
+  const modelArgument = modelIndex >= 0 ? args[modelIndex + 1] : args.find((argument) => argument.startsWith("--model="))?.slice("--model=".length);
+  const runtime = createConsoleRuntime({ model: modelArgument });
+  const providerId = runtime.resolvedProvider();
+  if (providerId !== "chatgpt-codex" || !config.providers.includes(providerId)) throw new Error("Isolated CLI execution requires an explicitly granted brokered chatgpt-codex provider. Host fallback is refused.");
+  const model = runtime.resolvedModel();
+  const routing = runtime.modelSelection();
+  const broker = createWorkbenchProviderBroker({
+    provider: providerId,
+    models: [.../* @__PURE__ */ new Set([model, ...Object.values(routing.agentModels).filter((value) => value !== "auto")])],
+    resolveCredentials: runtime.workbenchCredentialResolver()
+  });
+  const network = workbenchNetworkEnabled();
+  const controller = new AbortController();
+  let signalCode;
+  const interrupt = () => {
+    signalCode = 130;
+    controller.abort();
+  };
+  const terminate = () => {
+    signalCode = 143;
+    controller.abort();
+  };
+  const hangup = () => {
+    signalCode = 129;
+    controller.abort();
+  };
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", terminate);
+  process.once("SIGHUP", hangup);
+  let result;
+  try {
+    result = await runWorkbenchCli({
+      workbench: config,
+      selection: { provider: providerId, model, ...routing },
+      provider: { ...broker.grant, request: broker.request, close: broker.close },
+      assets: currentWorkbenchAssets(),
+      guestSettings: resolveWorkbenchGuestSettings(hostSettings),
+      network,
+      args: mapWorkbenchCliArguments(args, workspaceRoot),
+      signal: controller.signal,
+      onStdout: (data) => process.stdout.write(data),
+      onStderr: (data) => process.stderr.write(data)
+    });
+  } finally {
+    await broker.close();
+    process.removeListener("SIGINT", interrupt);
+    process.removeListener("SIGTERM", terminate);
+    process.removeListener("SIGHUP", hangup);
   }
+  if (result.cleanupFailed) {
+    process.stderr.write("[0] SmolVM cleanup could not be proven. Workbench admission/state is retained; host execution is refused.\n");
+    return 125;
+  }
+  if (result.artifacts) process.stderr.write(`[0] Guest workspace and results saved at ${result.artifacts.directory}
+`);
+  if (result.error) process.stderr.write(`[0] ${result.error}
+`);
+  if (result.timedOut) return 124;
+  return signalCode ?? result.exitCode ?? 125;
+}
+function selectWorkbenchProfile(profile, home) {
+  if (!saveSettings({ ...loadGlobalSettings(home), executionProfile: profile }, home)) throw new Error("Could not persist the operator execution profile.");
 }
 
 export {
@@ -3150,13 +3383,18 @@ export {
   isSafeThemeId,
   reloadInstalledThemes,
   installedThemeEntries,
+  allThemeNames,
   isKnownTheme,
   writeInstalledTheme,
   removeInstalledTheme,
+  syncThemeChoices,
   SETTING_DEFS,
   DEFAULT_SETTINGS,
   settingsFilePath,
   projectSettingsFilePath,
+  projectSettingsExist,
+  isOperatorSetting,
+  resolveLayeredSettings,
   loadLayeredSettings,
   normalizeSettings,
   loadSettings,
@@ -3165,42 +3403,33 @@ export {
   sanitizeOverrides,
   readProjectOverrides,
   saveProjectOverrides,
-  getSettings,
-  getSettingSources,
-  updateSetting,
-  resetSettings,
-  previewSetting,
-  subscribeSettings,
-  reloadSettings,
-  configureSettingsStore,
-  useSettings,
-  maybeLoadCodexAuth,
-  presentationEventBus,
-  createPresentationEmitter,
-  consolePresentationOutput,
-  installConsolePresentationBridge,
-  installProcessPresentationStreamBridge,
-  suspendProcessPresentationStreamBridge,
-  resumeProcessPresentationStreamBridge,
-  processPresentationOutput,
-  writePresentationLine,
+  currentWorkbenchAssets,
+  WORKBENCH_FRAME_BYTES,
+  WORKBENCH_MAX_PENDING,
+  encodeWorkbenchFrame,
+  WorkbenchFrameReader,
+  installWorkbenchPlugins,
+  validateGuestServicePluginConnections,
+  servicePluginSecretRedactor,
+  createWorkbenchConsoleSession,
   PROVIDERS,
+  providerSupportsMethod,
   providerStates,
   isProviderConfigured,
-  loadCredentials,
-  saveCredentials,
-  credentialEnvPatch,
-  redactSecret,
-  loadAccountStore,
-  saveAccountStore,
-  addAccount,
-  accountEnvPatch,
   appendFeedback,
   parseFeedbackCommand,
-  FEEDBACK_OPT_OUT_ENV,
   submissionBlockedReason,
   describeSkip,
   buildSubmitPreview,
   submitFeedback,
-  buildDiagnosticFeedback
+  buildDiagnosticFeedback,
+  workbenchConfigPath,
+  defaultWorkbenchStateRoot,
+  isPinnedWorkbenchImageReference,
+  loadWorkbenchConfig,
+  saveWorkbenchConfig,
+  resolveWorkbenchGuestSettings,
+  workbenchNetworkEnabled,
+  launchConfiguredWorkbench,
+  selectWorkbenchProfile
 };