0sec-cli 0.22.4 → 0.24.0

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

@@ -2,14 +2,18 @@
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
+  DEFAULT_MAX_TOOL_ITERATIONS,
   createConsoleRuntime,
   createWorkbenchProviderBroker,
   runSmolvmWorkbench,
   snapshotSmolvmWorkspace
-} from "./chunk-OAS5SAVZ.js";
+} from "./chunk-V5I5GAQH.js";
+import {
+  getReleaseChannel
+} from "./chunk-4TUR47H5.js";
 import {
   TOOL_DEFINITIONS
-} from "./chunk-H6Q2QAIY.js";
+} from "./chunk-A3EKBUEM.js";
 import {
   ANALYTICS_LEVEL_ENV,
   getSmolvmWorkbenchStatus,
@@ -17,7 +21,7 @@ import {
   levelAtLeast,
   loadCloudCredentials,
   resolveAnalyticsLevel
-} from "./chunk-2WWAPKAW.js";
+} from "./chunk-BIJPMYFA.js";
 import {
   ScopePolicy,
   aggregateCapabilities,
@@ -30,17 +34,69 @@ import {
   readInstalledPlugin,
   reconcile,
   writeEnablement
-} from "./chunk-C6JPA32H.js";
+} from "./chunk-RBOMXUYL.js";
 import {
+  BackendIdSchema,
   DEFAULT_ALLOW_MODEL_SELF_EXTENSION,
   SERVICE_PLUGIN_CATALOG,
   VERSION,
   findingSchema,
   homeStateDir
-} from "./chunk-6KFB6AYN.js";
+} from "./chunk-RZR2XXAK.js";
+
+// packages/cli/src/backend-client-mode.ts
+function remoteBackendClientId(args) {
+  if (!["workflow", "runs", "sessions", "mcp-server"].includes(args[0] ?? "")) return void 0;
+  const engineUrls = [];
+  const tokenEnvs = [];
+  const selections = [];
+  const valueFlags = /* @__PURE__ */ new Set(["--template", "--revision", "--target", "--workspace", "--scope", "--model", "--inputs", "--time-cap", "--cost-cap", "--db-path", "--format", "--backends-config", "--tools", "--scan-id", "--timeout", "--rate-limit", "--engagement-profile", "--session", "--config", "--response", "--after", "--branch-from-entry"]);
+  for (let index = 1; index < args.length; index++) {
+    const argument = args[index];
+    if (argument === "--") break;
+    if (argument === "--engine-url") {
+      engineUrls.push(args[++index]);
+      continue;
+    }
+    if (argument.startsWith("--engine-url=")) {
+      engineUrls.push(argument.slice(13));
+      continue;
+    }
+    if (argument === "--engine-token-env") {
+      tokenEnvs.push(args[++index]);
+      continue;
+    }
+    if (argument.startsWith("--engine-token-env=")) {
+      tokenEnvs.push(argument.slice(19));
+      continue;
+    }
+    if (argument === "--backend") {
+      selections.push(args[++index]);
+      continue;
+    }
+    if (argument.startsWith("--backend=")) {
+      selections.push(argument.slice(10));
+      continue;
+    }
+    if (valueFlags.has(argument)) index++;
+  }
+  if (engineUrls.length || tokenEnvs.length) {
+    if (selections.length || engineUrls.length !== 1 || tokenEnvs.length !== 1) throw new Error("Select either one --backend or one --engine-url with --engine-token-env.");
+    if (!engineUrls[0] || engineUrls[0].length > 4096 || !tokenEnvs[0] || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(tokenEnvs[0])) throw new Error("Invalid direct engine attachment options.");
+    const url = new URL(engineUrls[0]);
+    const loopback = url.hostname === "localhost" || url.hostname === "[::1]" || /^127\.(?:\d{1,3}\.){2}\d{1,3}$/.test(url.hostname);
+    if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) throw new Error("Engine URL must be credential-free HTTPS or loopback HTTP, without query or fragment.");
+    return "attached-engine";
+  }
+  if (!selections.length) return void 0;
+  if (selections.length !== 1) throw new Error("Select exactly one registered remote backend.");
+  const selected = BackendIdSchema.parse(selections[0]);
+  if (selected === "local") throw new Error("--backend local is not a remote selection. Omit --backend to preserve configured local execution.");
+  return selected;
+}
 
 // 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 { chmodSync, existsSync as existsSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, realpathSync as realpathSync4, 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";
 
@@ -48,7 +104,7 @@ import { dirname as dirname5, isAbsolute as isAbsolute2, join as join8 } from "n
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-function currentWorkbenchAssets(moduleUrl = import.meta.url) {
+function currentWorkbenchAssets(moduleUrl = import.meta.url, executablePath = process.execPath) {
   let directory = dirname(fileURLToPath(moduleUrl));
   for (let depth = 0; depth < 5; depth++) {
     for (const candidate of [directory, join(directory, "dist")]) {
@@ -59,13 +115,67 @@ function currentWorkbenchAssets(moduleUrl = import.meta.url) {
     if (parent === directory) break;
     directory = parent;
   }
+  if (moduleUrl.includes("/$bunfs/")) {
+    const candidate = join(dirname(executablePath), "..", "lib", "workbench-cli");
+    const entry = join(candidate, "0.js");
+    if (existsSync(entry) && lstatSync(entry).isFile() && !lstatSync(entry).isSymbolicLink()) return { cliDist: realpathSync(candidate) };
+  }
   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";
+import { createHash } from "node:crypto";
+import { constants, openSync, closeSync, fstatSync, lstatSync as lstatSync2, readSync, realpathSync as realpathSync2 } from "node:fs";
 var WORKBENCH_FRAME_BYTES = 8 * 1024 * 1024;
 var WORKBENCH_MAX_PENDING = 64;
+var WORKBENCH_SOURCE_CONTEXT_LIMIT = 8;
+function validateWorkbenchSourceLesson(value, workspace, scopePath) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid source lesson");
+  const record = value;
+  if (Object.keys(record).some((key) => !["title", "summary", "sourceLinks"].includes(key))) throw new Error("Unexpected source lesson fields");
+  const { title, summary } = record;
+  if (typeof title !== "string" || !title.trim() || title.length > 200 || typeof summary !== "string" || !summary.trim() || summary.length > 2e3) throw new Error("Invalid source lesson prose");
+  const text = title + "\n" + summary;
+  if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(text) || /-----BEGIN .*PRIVATE KEY-----|\b(?:sk-[a-zA-Z0-9_-]{16,}|ghp_[a-zA-Z0-9]{20,}|github_pat_[a-zA-Z0-9_]{20,}|Bearer\s+[a-zA-Z0-9_.-]{16,})|(?:password|api[_ -]?key|access[_ -]?token|secret)\s*[:=]\s*["']?[^\s"']{8,}/i.test(text)) throw new Error("Source lesson may contain credentials");
+  if (Array.isArray(record.sourceLinks) && record.sourceLinks.some((link) => !link || typeof link !== "object" || Object.keys(link).some((key) => !["path", "hash"].includes(key)))) throw new Error("Unexpected source lesson link fields");
+  return { title: title.trim(), summary: summary.trim(), ...validateWorkbenchSourceContext(record, workspace, scopePath) };
+}
+function validateWorkbenchSourceContext(value, workspace, scopePath) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid workbench source context");
+  const links = value.sourceLinks;
+  if (!Array.isArray(links) || !links.length || links.length > 16) throw new Error("Invalid workbench source links");
+  const root = realpathSync2(workspace);
+  const scope = realpathSync2(scopePath);
+  if (scope !== root && !scope.startsWith(root + sep)) throw new Error("Workbench source scope is outside workspace");
+  const sourceLinks = links.map((link) => {
+    if (!link || typeof link !== "object" || Array.isArray(link)) throw new Error("Invalid workbench source link");
+    const { path, hash } = link;
+    if (typeof path !== "string" || !path || path.length > 1024 || path.includes("\0") || path.includes("\\") || isAbsolute(path) || path.split("/").some((part) => !part || part === "." || part === "..") || typeof hash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(hash)) throw new Error("Invalid workbench source path or hash");
+    const full = resolve(root, path);
+    if (full !== scope && !full.startsWith(scope + sep)) throw new Error("Workbench source is outside approved local scope");
+    let cursor = root;
+    for (const component of path.split("/")) {
+      cursor = resolve(cursor, component);
+      if (lstatSync2(cursor).isSymbolicLink()) throw new Error("Workbench source symlink refused");
+    }
+    const fd = openSync(full, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+      const stat = fstatSync(fd);
+      if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1048576) throw new Error("Invalid workbench source file");
+      const bytes = Buffer.alloc(1048577);
+      let size = 0;
+      let read;
+      while (size < bytes.length && (read = readSync(fd, bytes, size, bytes.length - size, size)) > 0) size += read;
+      const after = fstatSync(fd);
+      if (size > 1048576 || stat.size !== size || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs || stat.ctimeMs !== after.ctimeMs || realpathSync2(full) !== full || `sha256:${createHash("sha256").update(bytes.subarray(0, size)).digest("hex")}` !== hash) throw new Error("Workbench source changed or digest mismatch");
+    } finally {
+      closeSync(fd);
+    }
+    return { path, hash };
+  });
+  return { sourceLinks };
+}
 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");
@@ -137,7 +247,7 @@ function serializeWorkbenchConfig(config, workspace) {
     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"]) {
+  for (const key of ["role", "tools", "codebaseLearning", "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;
@@ -161,7 +271,7 @@ function serializeWorkbenchConfig(config, workspace) {
 }
 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 pathFlags = /* @__PURE__ */ new Set(["--scope", "--db-path", "--workspace", "--workspace-root", "--cwd", "--output", "-o", "--config", "--inputs"]);
   const result = [...args];
   for (let index = 0; index < result.length; index++) {
     const argument = result[index];
@@ -180,9 +290,9 @@ function mapWorkbenchCliArguments(args, workspace) {
 
 // packages/cli/src/workbench-console-session.ts
 import { randomUUID } from "node:crypto";
-import { realpathSync as realpathSync2 } from "node:fs";
+import { realpathSync as realpathSync3, statSync } from "node:fs";
 import { mkdir, mkdtemp as mkdtemp2, realpath as realpath2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join3, sep as sep2 } from "node:path";
 
 // packages/cli/src/workbench-plugins.ts
 import { lstat, mkdtemp, realpath, rm } from "node:fs/promises";
@@ -278,7 +388,7 @@ function servicePluginSecretRedactor(connections) {
 
 // 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"]);
+var DECISIONS = /* @__PURE__ */ new Set(["requestScope", "requestLocalScope", "approveTool", "escalateScopedAudit", "askOperator", "historyList", "historyRead", "sourceLessons"]);
 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");
@@ -298,7 +408,7 @@ var Controller = class {
     this.init = init;
     this.cli = cli;
     validateOptions(options);
-    this.workspace = realpathSync2(options.workbench.workspaceRoot ?? process.cwd());
+    this.workspace = realpathSync3(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;
@@ -349,7 +459,7 @@ var Controller = class {
   async start() {
     if (this.started) return this.ready;
     this.started = true;
-    this.status("pending", "Starting isolated workbench");
+    this.status("pending", "Preparing workspace");
     let stagedPlugins;
     this.lifetime = setTimeout(() => this.abort.abort(new Error("Workbench lifetime expired")), this.options.lifetimeMs ?? 30 * 6e4);
     this.lifetime.unref();
@@ -359,7 +469,7 @@ var Controller = class {
       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 connections = this.cli ? [] : (await import("./service-plugins-BGS6QKSZ.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);
@@ -367,6 +477,7 @@ var Controller = class {
         image: this.options.workbench.image,
         stateRoot: this.options.workbench.stateRoot,
         workspaceRoot: this.workspace,
+        onStartupProgress: (message) => this.status("pending", message),
         command: launch.command,
         environment: { ZERO_PROVIDER: "chatgpt-codex", ZERO_NO_TELEMETRY: "1", DO_NOT_TRACK: "1" },
         network: this.options.network,
@@ -504,18 +615,25 @@ var Controller = class {
     }
     return result;
   }
-  async close() {
+  async close(beforeRelease) {
     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.request("close"), new Promise((_, reject) => setTimeout(() => reject(new Error("Workbench close acknowledgement timed out")), 1e3))]);
+      await beforeRelease?.();
+      this.write({ type: "release" });
+      this.input?.end();
       await Promise.race([this.done?.then(() => {
         exited = true;
       }), new Promise((resolve2) => setTimeout(resolve2, 1e3))]);
-    } catch {
+    } catch (error) {
+      this.abort.abort();
+      const result = await this.done;
+      if (result?.cleanupFailed) throw new Error(result.error ?? "Workbench teardown could not be confirmed");
+      if (beforeRelease) await beforeRelease();
     } finally {
       if (!exited) this.abort.abort();
       const result = await this.done;
@@ -524,17 +642,42 @@ var Controller = class {
   }
 };
 function createWorkbenchConsoleSession(options) {
-  const workspace = realpathSync2(options.workbench.workspaceRoot ?? options.config.workspaceRoot ?? process.cwd());
+  const workspace = realpathSync3(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 sourceLearningEnabled = config.codebaseLearning === true && config.role !== "verify" && !/^(1|true)$/i.test(process.env.ZERO_DISABLE_HUNT_MEMORY ?? "");
+  if (sourceLearningEnabled && options.readSourceLessons) callbacks.push("sourceLessons");
+  const scopeEnforcement = getScopeEnforcementState(workspace, options.pluginHomeDir);
   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 explicitYoloSourceGrant = !!options.workbench.workspaceRoot && config.autonomyMode === "yolo";
+  let sourceScopePath = config.initialCheckpoint?.localScopePath ?? (!scopeEnforcement.enabled || explicitYoloSourceGrant ? workspace : void 0);
+  const authorizedSourceRoot = (guestPath) => {
+    if (!sourceScopePath || typeof guestPath !== "string") return void 0;
+    try {
+      const requested = realpathSync3(hostWorkspacePath(guestPath, workspace));
+      const approved = realpathSync3(sourceScopePath);
+      if (!statSync(requested).isDirectory()) return void 0;
+      if (requested === approved || explicitYoloSourceGrant && (requested === workspace || requested.startsWith(workspace + sep2))) return requested;
+    } catch {
+    }
+    return void 0;
+  };
+  const sourceArtifacts = /* @__PURE__ */ new Set();
+  let sourceFrames = 0;
+  let sourcePersistence = Promise.resolve();
+  const flushSourceContext = async () => {
+    try {
+      await sourcePersistence;
+    } catch {
+      throw new Error("Workbench source context persistence failed");
+    }
+  };
   let autonomyMode = config.autonomyMode ?? "standard";
   let systemPrompt = config.systemPrompt ?? "";
   let tools = config.tools ?? [];
@@ -556,6 +699,20 @@ function createWorkbenchConsoleSession(options) {
     });
   };
   controller.decision = async (name, args) => {
+    if (name === "sourceLessons") {
+      if (!sourceLearningEnabled || !sourceScopePath || !options.readSourceLessons || /^(1|true)$/i.test(process.env.ZERO_DISABLE_HUNT_MEMORY ?? "") || args.length !== 1 || typeof args[0] !== "string") return [];
+      const requested = authorizedSourceRoot(args[0]);
+      if (!requested) return [];
+      await flushSourceContext();
+      const notes = await options.readSourceLessons({ workspaceRoot: workspace, scopePath: requested });
+      return notes.slice(0, 6).flatMap((note) => {
+        try {
+          return [validateWorkbenchSourceLesson(note, workspace, requested)];
+        } catch {
+          return [];
+        }
+      });
+    }
     if (name === "historyList") return config.conversationHistory.list(...args);
     if (name === "historyRead") return config.conversationHistory.read(...args);
     const callback = config[name];
@@ -566,7 +723,9 @@ function createWorkbenchConsoleSession(options) {
       const value = await callback(request);
       if (!value) return null;
       const resolution = value;
-      return { scopePath: guestWorkspacePath(resolution.scopePath, workspace) };
+      const guestPath = guestWorkspacePath(resolution.scopePath, workspace);
+      sourceScopePath = hostWorkspacePath(guestPath, workspace);
+      return { scopePath: guestPath };
     }
     if (name === "requestScope") {
       const request = args[0];
@@ -578,7 +737,40 @@ function createWorkbenchConsoleSession(options) {
     return callback(...args);
   };
   controller.receive = (frame) => {
-    if (frame.type === "state") {
+    if (frame.type === "source-lesson") {
+      if (++sourceFrames > 128) throw new Error("Workbench source export limit reached");
+      if (!sourceLearningEnabled || !options.onSourceLesson || !sourceScopePath || /^(1|true)$/i.test(process.env.ZERO_DISABLE_HUNT_MEMORY ?? "")) return;
+      const lessonScope = frame.scopePath === void 0 ? sourceScopePath : authorizedSourceRoot(frame.scopePath);
+      if (!lessonScope) return;
+      let lesson;
+      try {
+        lesson = validateWorkbenchSourceLesson(frame.lesson, workspace, lessonScope);
+      } catch {
+        return;
+      }
+      const key = JSON.stringify({ scopePath: lessonScope, lesson });
+      if (sourceArtifacts.has(key)) return;
+      sourceArtifacts.add(key);
+      const scopePath = lessonScope;
+      sourcePersistence = sourcePersistence.then(() => options.onSourceLesson(lesson, { workspaceRoot: workspace, scopePath, scanId: config.scanId, runId: controller.runId }));
+      void sourcePersistence.catch(() => {
+      });
+    } else if (frame.type === "source-context") {
+      if (++sourceFrames > 128) throw new Error("Workbench source context export limit reached");
+      if (!sourceLearningEnabled || !options.onSourceContext || !sourceScopePath || /^(1|true)$/i.test(process.env.ZERO_DISABLE_HUNT_MEMORY ?? "")) return;
+      let artifact;
+      try {
+        artifact = validateWorkbenchSourceContext(frame.artifact, workspace, sourceScopePath);
+      } catch {
+        return;
+      }
+      const key = JSON.stringify(artifact);
+      if (sourceArtifacts.has(key)) return;
+      sourceArtifacts.add(key);
+      sourcePersistence = sourcePersistence.then(() => options.onSourceContext(artifact, { workspaceRoot: workspace, scanId: config.scanId, runId: controller.runId }));
+      void sourcePersistence.catch(() => {
+      });
+    } else 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;
@@ -628,6 +820,10 @@ function createWorkbenchConsoleSession(options) {
     scopeEnforcement,
     setAutonomyMode(mode) {
       autonomyMode = mode;
+      if (mode === "yolo" && options.workbench.workspaceRoot) {
+        explicitYoloSourceGrant = true;
+        sourceScopePath ??= workspace;
+      }
       queue("autonomy", mode);
     },
     configureEngagement(selection) {
@@ -638,7 +834,7 @@ function createWorkbenchConsoleSession(options) {
       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");
+      if (realpathSync3(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");
@@ -656,24 +852,62 @@ function createWorkbenchConsoleSession(options) {
     async send(text, callbacks2, sendOptions) {
       if (active) throw new Error("Workbench turn already active");
       active = true;
-      render = callbacks2;
+      let partialText = "";
+      const partialTools = [];
+      const partialUsage = { inputTokens: 0, outputTokens: 0 };
+      let usageReport;
+      render = {
+        ...callbacks2,
+        onAssistantDelta: (text2) => {
+          partialText += text2;
+          callbacks2?.onAssistantDelta?.(text2);
+        },
+        onToolResult: (call, result) => {
+          partialTools.push({ call, result });
+          callbacks2?.onToolResult?.(call, result);
+        },
+        onUsage: (usage) => {
+          partialUsage.inputTokens += usage.inputTokens;
+          partialUsage.outputTokens += usage.outputTokens;
+          usageReport = usage;
+          callbacks2?.onUsage?.(usage);
+        }
+      };
+      const messageCountBeforeTurn = messages.length;
       let cancelTimer;
       const cancel = () => {
+        if (controller.execution.status === "pending") {
+          controller.abort.abort(new Error("Operator cancelled workbench startup"));
+          return;
+        }
         try {
           controller.write({ type: "cancel" });
         } catch {
         }
-        cancelTimer = setTimeout(() => controller.abort.abort(new Error("Operator cancelled workbench turn")), 2e3);
+        cancelTimer ??= setTimeout(() => controller.abort.abort(new Error("Operator cancelled workbench turn")), 2e3);
       };
       sendOptions?.signal?.addEventListener("abort", cancel, { once: true });
       try {
+        if (sendOptions?.signal?.aborted) cancel();
         await Promise.all(deferred.splice(0));
         await controller.start();
-        if (sendOptions?.signal?.aborted) cancel();
+        sendOptions?.signal?.throwIfAborted();
         controller.status("running");
         engineWorkStarted = true;
         lastOutcome = await controller.request("send", { text, generateTitle: sendOptions?.generateTitle });
+        await flushSourceContext();
         return lastOutcome;
+      } catch (error) {
+        if (sendOptions?.signal?.aborted) {
+          const result = await controller.done;
+          if ((!result || !result.cleanupFailed) && controller.abort.signal.aborted) {
+            controller.status("stopped");
+            if (messages.length === messageCountBeforeTurn) messages.push({ role: "user", content: [{ type: "text", text }] });
+            if (partialText && messages.at(-1)?.role !== "assistant") messages.push({ role: "assistant", content: [{ type: "text", text: partialText }] });
+            return lastOutcome = { assistantText: partialText, toolCalls: partialTools, usage: partialUsage, budget: { tokensUsed: usageReport?.turnTokensUsed ?? partialUsage.inputTokens + partialUsage.outputTokens, tokenBudget: usageReport?.turnTokenBudget ?? options.config.maxTurnTokens ?? Infinity, iterations: usageReport?.iterations ?? 0, maxToolIterations: usageReport?.maxToolIterations ?? options.config.maxToolIterations ?? DEFAULT_MAX_TOOL_ITERATIONS }, stopReason: "cancelled" };
+          }
+        }
+        throw error;
       } finally {
         clearTimeout(cancelTimer);
         active = false;
@@ -699,7 +933,8 @@ function createWorkbenchConsoleSession(options) {
     },
     cleanup() {
       return cleanupPromise ??= (async () => {
-        await controller.close();
+        await controller.close(flushSourceContext);
+        await flushSourceContext();
         if (engineWorkStarted && controller.done) await options.onFindings?.(findings, { outcome: lastOutcome });
       })();
     }
@@ -813,6 +1048,13 @@ var PROVIDER_DEFS = [
     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: "cline",
+    label: "Cline / ClinePass",
+    methods: ["api-key"],
+    envVars: ["CLINE_API_KEY"],
+    hint: "set CLINE_API_KEY from app.cline.bot Settings > API Keys; choose cline-pass/* for your active ClinePass plan (endpoint override: CLINE_BASE_URL)"
+  },
   {
     id: "opencode",
     label: "OpenCode Zen",
@@ -3153,8 +3395,9 @@ 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 commit = /^[0-9a-f]{40}$/i.test("9503df38cef03a732fa8d03df7d2c2a7bbe67a2e") ? "9503df38cef03a732fa8d03df7d2c2a7bbe67a2e".toLowerCase() : void 0;
+  const releaseChannel = getReleaseChannel(env);
+  const environment = releaseChannel === "beta" ? "production" : "development";
   const event = JSON.stringify({
     event_id: diagnostic.eventId,
     timestamp: Date.parse(payload.timestamp) / 1e3,
@@ -3165,6 +3408,7 @@ function serializeSubmission(payload, target, env) {
     environment,
     tags: {
       cli_version: cliVersion,
+      release_channel: releaseChannel,
       ...commit ? { build_commit: commit } : {},
       kind: diagnostic.kind,
       platform: diagnostic.platform,
@@ -3238,7 +3482,7 @@ function loadWorkbenchConfig(home) {
   const file = workbenchConfigPath(home);
   if (!existsSync2(file)) return void 0;
   try {
-    const stat = lstatSync2(file);
+    const stat = lstatSync3(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).");
     }
@@ -3282,13 +3526,17 @@ async function launchConfiguredWorkbench(args) {
     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;
+  if (["workbench", "config", "web", "dashboard", "console", "chat", "team", "tui", "watch", "doctor", "help", "--help", "-h", "--version", "-v"].includes(args[0] ?? "") || args.length === 0) return void 0;
+  if (remoteBackendClientId(args)) return void 0;
   const hostSettings = loadGlobalSettings(home, { requireExecutionProfile: existsSync2(workbenchConfigPath(home)) });
   if (hostSettings.executionProfile !== "smolvm") return void 0;
+  if (args[0] === "mcp-server") {
+    throw new Error("MCP requires bidirectional stdio, which the SmolVM CLI bridge does not support. The selected SmolVM profile is unchanged; host fallback is refused. Use `0 workflow` commands in SmolVM. MCP currently requires explicitly selected host-local execution; only the operator should choose `0 workbench disable` if host execution is intended.");
+  }
   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 workspaceRoot = realpathSync4(config.workspaceRoot ?? process.cwd());
+  if (!lstatSync3(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.");
@@ -3406,12 +3654,15 @@ export {
   currentWorkbenchAssets,
   WORKBENCH_FRAME_BYTES,
   WORKBENCH_MAX_PENDING,
+  WORKBENCH_SOURCE_CONTEXT_LIMIT,
+  validateWorkbenchSourceLesson,
   encodeWorkbenchFrame,
   WorkbenchFrameReader,
   installWorkbenchPlugins,
   validateGuestServicePluginConnections,
   servicePluginSecretRedactor,
   createWorkbenchConsoleSession,
+  remoteBackendClientId,
   PROVIDERS,
   providerSupportsMethod,
   providerStates,