rscot-agent 1.2.3 → 1.7.47

package/dist/agent-runtime.js

@@ -0,0 +1,3833 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var path8 = __toESM(require("node:path"));
+var crypto2 = __toESM(require("node:crypto"));
+var fs10 = __toESM(require("node:fs/promises"));
+
+// src/apiClient.ts
+var ApiClient = class {
+  constructor(settings, apiKey) {
+    this.settings = settings;
+    this.apiKey = apiKey;
+  }
+  headers() {
+    const h = {
+      "Content-Type": "application/json"
+    };
+    const t = this.settings.authBearer;
+    if (t) {
+      h["Authorization"] = `Bearer ${t}`;
+      h["X-CWA-Token"] = t;
+    }
+    return h;
+  }
+  async turn(req, opts) {
+    const body = {
+      ...req,
+      api_key: this.apiKey,
+      provider: this.settings.provider,
+      model: this.settings.model || void 0,
+      base_url: this.settings.baseUrl || void 0,
+      temperature: this.settings.temperature,
+      stack_hint: req.stack_hint ?? (this.settings.stackHint || void 0)
+    };
+    const clean = {};
+    for (const [k, v] of Object.entries(body)) {
+      if (v !== void 0 && v !== null && v !== "") clean[k] = v;
+    }
+    if (!clean.messages || clean.messages.length === 0) {
+      throw new Error("apiClient.turn called with empty messages");
+    }
+    const url = `${this.settings.backendUrl}/code-workspace/turn`;
+    const signal = opts?.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : void 0;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(clean),
+      signal
+    });
+    if (!res.ok) {
+      let detail = "";
+      try {
+        detail = (await res.json())?.detail || "";
+      } catch {
+        detail = await res.text();
+      }
+      throw new Error(`Backend ${res.status}: ${detail || res.statusText}`);
+    }
+    return await res.json();
+  }
+  async health() {
+    const res = await fetch(`${this.settings.backendUrl}/code-workspace/health`, {
+      headers: this.headers()
+    });
+    if (!res.ok) throw new Error(`health ${res.status}`);
+    return res.json();
+  }
+  async stacks() {
+    const res = await fetch(`${this.settings.backendUrl}/code-workspace/stacks`, {
+      headers: this.headers()
+    });
+    if (!res.ok) throw new Error(`stacks ${res.status}`);
+    return res.json();
+  }
+  /**
+   * Day 21 streaming sibling of turn(). Yields one StreamEvent at a time
+   * until the terminal event (done / message / tool_call / blocked / error).
+   *
+   * Event shape:
+   *   {type: "delta",     content?: string, reasoning?: string}
+   *   {type: "status",    status: "thinking", role: "architect"|"editor", model: string}
+   *   {type: "assistant", assistant_message: any}   // assembled, sent right before terminal
+   *   {type: "tool_call" | "blocked" | "message" | "done", ...same as non-stream}
+   *   {type: "error",     message: string, detail?: string}
+   */
+  async *turnStream(req, signal) {
+    const body = {
+      ...req,
+      api_key: this.apiKey,
+      provider: this.settings.provider,
+      model: this.settings.model || void 0,
+      base_url: this.settings.baseUrl || void 0,
+      temperature: this.settings.temperature,
+      stack_hint: req.stack_hint ?? (this.settings.stackHint || void 0)
+    };
+    const clean = {};
+    for (const [k, v] of Object.entries(body)) {
+      if (v !== void 0 && v !== null && v !== "") clean[k] = v;
+    }
+    if (!clean.messages || clean.messages.length === 0) {
+      throw new Error("turnStream() called with empty messages");
+    }
+    const url = `${this.settings.backendUrl}/code-workspace/turn-stream`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(clean),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      let detail = "";
+      try {
+        detail = (await res.json())?.detail || "";
+      } catch {
+        detail = await res.text();
+      }
+      throw new Error(`Backend ${res.status}: ${detail || res.statusText}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let blockEnd;
+      while ((blockEnd = buf.indexOf("\n\n")) !== -1) {
+        const block = buf.slice(0, blockEnd);
+        buf = buf.slice(blockEnd + 2);
+        const ev = parseSseBlock(block);
+        if (ev) yield ev;
+      }
+    }
+  }
+};
+function parseSseBlock(block) {
+  let event = "message";
+  let data = "";
+  for (const line of block.split("\n")) {
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) data = (data ? data + "\n" : "") + line.slice(5).trim();
+  }
+  if (!data) return null;
+  try {
+    const parsed = JSON.parse(data);
+    return { type: event, ...parsed };
+  } catch {
+    return null;
+  }
+}
+
+// src/priorContext.ts
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const w of a) {
+    if (b.has(w)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...a, ...b])).size;
+  return intersection / union;
+}
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().split(/\W+/).filter((w) => w.length >= 4)
+  );
+}
+async function buildPriorContext(store, prompt2, maxResults = 3) {
+  const sessions = await store.listAll();
+  if (sessions.length === 0) return "";
+  const promptWords = tokenize(prompt2);
+  if (promptWords.size === 0) return "";
+  const scored = [];
+  for (const s of sessions) {
+    const summaryWords = tokenize(s.summary);
+    if (summaryWords.size === 0) continue;
+    const sim = jaccard(promptWords, summaryWords);
+    const bonus = s.completed ? 0.1 : 0;
+    const score = sim + bonus;
+    if (score >= 0.05) {
+      scored.push({
+        created_at: s.created_at,
+        messages_count: s.messages_count,
+        summary: s.summary,
+        score
+      });
+    }
+  }
+  if (scored.length === 0) return "";
+  scored.sort((a, b) => {
+    const diff = b.score - a.score;
+    if (diff !== 0) return diff;
+    return b.created_at.localeCompare(a.created_at);
+  });
+  const top = scored.slice(0, maxResults);
+  if (top.length === 0) return "";
+  const lines = [
+    "## Prior sessions in this workspace (for your context)",
+    ""
+  ];
+  for (let i = 0; i < top.length; i++) {
+    const s = top[i];
+    lines.push(
+      `${i + 1}. ${s.created_at}, ${s.messages_count} msgs \u2014 ${s.summary}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/conversationStore.ts
+var fs = __toESM(require("node:fs/promises"));
+var path = __toESM(require("node:path"));
+var crypto = __toESM(require("node:crypto"));
+var ConversationStore = class {
+  dir;
+  convDir;
+  current = null;
+  constructor(workspaceRoot3) {
+    this.dir = path.join(workspaceRoot3, ".rscot");
+    this.convDir = path.join(this.dir, "conversations");
+  }
+  async ensureDir() {
+    await fs.mkdir(this.convDir, { recursive: true });
+    const gi = path.join(this.dir, ".gitignore");
+    try {
+      await fs.access(gi);
+    } catch {
+      await fs.writeFile(gi, "# Auto-generated by Rscot Agent\n*\n", "utf-8");
+    }
+  }
+  /** Start a fresh session. Returns the session id. */
+  async startNew(opts) {
+    await this.ensureDir();
+    const id = crypto.randomBytes(4).toString("hex");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.current = {
+      session_id: id,
+      created_at: now,
+      last_updated: now,
+      workspace: opts.workspaceRoot,
+      stack_hint: opts.stackHint || "",
+      messages: [],
+      summary: (opts.firstPrompt || "").slice(0, 80),
+      completed: false,
+      files_changed: [],
+      pinned: false,
+      archived: false
+    };
+    await this.flush();
+    await fs.writeFile(path.join(this.dir, "last_session_id"), id, "utf-8");
+    return id;
+  }
+  /** Load a session by id and make it `current`. Returns null if missing. */
+  async loadById(sessionId) {
+    try {
+      const candidates = await fs.readdir(this.convDir);
+      const match = candidates.find((f) => f.endsWith(`_${sessionId}.json`));
+      if (!match) return null;
+      const raw = await fs.readFile(path.join(this.convDir, match), "utf-8");
+      const session = this.applyDefaults(JSON.parse(raw));
+      this.current = session;
+      await fs.writeFile(path.join(this.dir, "last_session_id"), sessionId, "utf-8").catch(() => void 0);
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  /** Resume the most recent saved session, returning its messages + meta.
+   *  Returns null if no prior session exists. */
+  async resumeLatest() {
+    try {
+      const idTxt = (await fs.readFile(path.join(this.dir, "last_session_id"), "utf-8")).trim();
+      if (!idTxt) return null;
+      const candidates = await fs.readdir(this.convDir);
+      const match = candidates.find((f) => f.endsWith(`_${idTxt}.json`));
+      if (!match) return null;
+      const raw = await fs.readFile(path.join(this.convDir, match), "utf-8");
+      const session = this.applyDefaults(JSON.parse(raw));
+      this.current = session;
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  /** Append a message + bump last_updated. Caller should call after every
+   *  POST /turn returns. */
+  async appendMessage(msg) {
+    if (!this.current) return;
+    this.current.messages.push(msg);
+    this.current.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.flush();
+  }
+  /** Mark the session as completed (after `done` is received). */
+  async markComplete(filesChanged) {
+    if (!this.current) return;
+    this.current.completed = true;
+    this.current.files_changed = filesChanged || [];
+    this.current.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.flush();
+  }
+  getCurrentId() {
+    return this.current?.session_id ?? null;
+  }
+  getMessages() {
+    return this.current?.messages ?? [];
+  }
+  /** List all stored sessions (most recent first) for a session-picker UI. */
+  async listAll() {
+    try {
+      await fs.access(this.convDir);
+    } catch {
+      return [];
+    }
+    const files = await fs.readdir(this.convDir);
+    const out = [];
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      try {
+        const raw = await fs.readFile(path.join(this.convDir, f), "utf-8");
+        const s = this.applyDefaults(JSON.parse(raw));
+        out.push({
+          session_id: s.session_id,
+          created_at: s.created_at,
+          summary: s.summary,
+          completed: s.completed,
+          messages_count: s.messages.length,
+          pinned: s.pinned ?? false,
+          archived: s.archived ?? false
+        });
+      } catch {
+      }
+    }
+    out.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    return out;
+  }
+  // ── Backward-compat defaults ─────────────────────────────────────
+  /** Ensure old session files missing new fields get safe defaults. */
+  applyDefaults(s) {
+    if (s.pinned === void 0) s.pinned = false;
+    if (s.archived === void 0) s.archived = false;
+    return s;
+  }
+  /** Read a session by id directly (no side-effects on `current`). */
+  async readSessionById(sessionId) {
+    const filename = await this.findFilenameById(sessionId);
+    if (!filename) return null;
+    const raw = await fs.readFile(path.join(this.convDir, filename), "utf-8");
+    return { session: this.applyDefaults(JSON.parse(raw)), filename };
+  }
+  // ── A03+U01: Delete & Rename ──────────────────────────────────────
+  /** Delete a session file by id. If the deleted session is the current
+   *  one, clear the in-memory current and the last_session_id pointer. */
+  async delete(sessionId) {
+    const filename = await this.findFilenameById(sessionId);
+    if (!filename) throw new Error(`Session not found: ${sessionId}`);
+    await fs.unlink(path.join(this.convDir, filename));
+    if (this.current?.session_id === sessionId) {
+      this.current = null;
+      const lastIdPath = path.join(this.dir, "last_session_id");
+      try {
+        await fs.unlink(lastIdPath);
+      } catch {
+      }
+    }
+  }
+  /** Rename (re-title) a session by id. Updates the `summary` field. */
+  async rename(sessionId, newTitle) {
+    const filename = await this.findFilenameById(sessionId);
+    if (!filename) throw new Error(`Session not found: ${sessionId}`);
+    const filePath = path.join(this.convDir, filename);
+    const raw = await fs.readFile(filePath, "utf-8");
+    const session = JSON.parse(raw);
+    session.summary = newTitle.slice(0, 80);
+    session.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
+    if (this.current?.session_id === sessionId) {
+      this.current.summary = session.summary;
+      this.current.last_updated = session.last_updated;
+    }
+  }
+  // ── U03: Search ─────────────────────────────────────────────────────
+  /** Full-text search across all conversation messages.
+   *  Scans every session file; returns up to 50 results sorted by created_at desc.
+   *  Each result includes an 80-char snippet around the first match. */
+  async search(query) {
+    const lower = query.toLowerCase();
+    const all = await this.listAll();
+    const results = [];
+    for (const entry of all) {
+      const found = await this.readSessionById(entry.session_id);
+      if (!found) continue;
+      const { session } = found;
+      for (let i = 0; i < session.messages.length; i++) {
+        const content = session.messages[i].content || "";
+        const idx = content.toLowerCase().indexOf(lower);
+        if (idx !== -1) {
+          const start = Math.max(0, idx - 40);
+          const end = Math.min(content.length, idx + query.length + 40);
+          let snippet = content.slice(start, end);
+          if (start > 0) snippet = "\u2026" + snippet;
+          if (end < content.length) snippet = snippet + "\u2026";
+          results.push({
+            sessionId: session.session_id,
+            summary: session.summary,
+            matchedSnippet: snippet,
+            matchedTurnIndex: i,
+            createdAt: session.created_at
+          });
+          break;
+        }
+      }
+    }
+    results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return results.slice(0, 50).map(({ createdAt: _, ...rest }) => rest);
+  }
+  // ── U04: Export ──────────────────────────────────────────────────────
+  /** Export a conversation as a human-readable Markdown string. */
+  async exportAsMarkdown(sessionId) {
+    const found = await this.readSessionById(sessionId);
+    if (!found) throw new Error(`Session not found: ${sessionId}`);
+    const { session } = found;
+    const lines = [];
+    lines.push(`# ${session.summary || "Untitled Session"}`);
+    lines.push("");
+    lines.push(`**Session ID:** ${session.session_id}`);
+    lines.push(`**Created:** ${session.created_at}`);
+    lines.push(`**Last updated:** ${session.last_updated}`);
+    lines.push(`**Messages:** ${session.messages.length}`);
+    lines.push(`**Completed:** ${session.completed}`);
+    lines.push("");
+    for (const msg of session.messages) {
+      const role = msg.role === "user" ? "User" : "Assistant";
+      lines.push(`## ${role}:`);
+      lines.push("");
+      lines.push(msg.content || "");
+      lines.push("");
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        for (const tc of msg.tool_calls) {
+          lines.push(`### Tool call: ${tc.name}`);
+          lines.push("```");
+          lines.push(`args: ${JSON.stringify(tc.args, null, 2)}`);
+          if (tc.result !== void 0) {
+            lines.push(`result: ${JSON.stringify(tc.result, null, 2)}`);
+          }
+          lines.push("```");
+          lines.push("");
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /** Export a conversation as raw JSON. */
+  async exportAsJson(sessionId) {
+    const found = await this.readSessionById(sessionId);
+    if (!found) throw new Error(`Session not found: ${sessionId}`);
+    return JSON.stringify(found.session, null, 2);
+  }
+  // ── U05: Fork ────────────────────────────────────────────────────────
+  /** Fork (branch) a session at a specific turn index.
+   *  Returns the new session id. */
+  async fork(sourceId, upToTurnIndex, newSummary) {
+    const found = await this.readSessionById(sourceId);
+    if (!found) throw new Error(`Session not found: ${sourceId}`);
+    const { session } = found;
+    const newId = crypto.randomBytes(4).toString("hex");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const slicedMessages = session.messages.slice(0, upToTurnIndex + 1);
+    const newSession = {
+      session_id: newId,
+      created_at: now,
+      last_updated: now,
+      workspace: session.workspace,
+      stack_hint: session.stack_hint,
+      messages: slicedMessages,
+      summary: newSummary ?? session.summary,
+      completed: false,
+      files_changed: [],
+      pinned: false,
+      archived: false
+    };
+    await this.ensureDir();
+    const stamp = now.replace(/[:.]/g, "-").replace(/Z$/, "Z");
+    const filename = `${stamp}_${newId}.json`;
+    await fs.writeFile(
+      path.join(this.convDir, filename),
+      JSON.stringify(newSession, null, 2),
+      "utf-8"
+    );
+    return newId;
+  }
+  // ── U06: Pin / Archive ────────────────────────────────────────────────
+  /** Set the pinned flag on a session. */
+  async setPinned(sessionId, pinned) {
+    await this.setFlag(sessionId, "pinned", pinned);
+  }
+  /** Set the archived flag on a session. */
+  async setArchived(sessionId, archived) {
+    await this.setFlag(sessionId, "archived", archived);
+  }
+  /** Generic helper to set a boolean flag on a session and persist. */
+  async setFlag(sessionId, field, value) {
+    const filename = await this.findFilenameById(sessionId);
+    if (!filename) throw new Error(`Session not found: ${sessionId}`);
+    const filePath = path.join(this.convDir, filename);
+    const raw = await fs.readFile(filePath, "utf-8");
+    const session = this.applyDefaults(JSON.parse(raw));
+    session[field] = value;
+    session.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
+    if (this.current?.session_id === sessionId) {
+      this.current[field] = value;
+      this.current.last_updated = session.last_updated;
+    }
+  }
+  /** Resolve a session id to the on-disk filename. Returns null if not found. */
+  async findFilenameById(sessionId) {
+    try {
+      const candidates = await fs.readdir(this.convDir);
+      const match = candidates.find((f) => f.endsWith(`_${sessionId}.json`));
+      return match ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async flush() {
+    if (!this.current) return;
+    const stamp = this.current.created_at.replace(/[:.]/g, "-").replace(/Z$/, "Z");
+    const filename = `${stamp}_${this.current.session_id}.json`;
+    await fs.writeFile(
+      path.join(this.convDir, filename),
+      JSON.stringify(this.current, null, 2),
+      "utf-8"
+    );
+  }
+};
+
+// src/executors/filesystem.ts
+var fs2 = __toESM(require("node:fs/promises"));
+var path3 = __toESM(require("node:path"));
+
+// src/workspace.ts
+var path2 = __toESM(require("node:path"));
+var NoWorkspaceError = class extends Error {
+  constructor() {
+    super("No workspace folder is open. Open a folder before invoking the agent.");
+  }
+};
+var PathScopeError = class extends Error {
+  constructor(reason) {
+    super(`Path scope violation: ${reason}`);
+  }
+};
+var _override;
+function setWorkspaceRoot(absPath) {
+  _override = path2.resolve(absPath);
+}
+function workspaceRoot() {
+  if (_override) return _override;
+  let vscode;
+  try {
+    vscode = require("vscode");
+  } catch {
+    throw new NoWorkspaceError();
+  }
+  const folders = vscode.workspace.workspaceFolders;
+  if (!folders || folders.length === 0) throw new NoWorkspaceError();
+  return folders[0].uri.fsPath;
+}
+function resolveInWorkspace(givenPath, opts) {
+  const root = workspaceRoot();
+  if (!givenPath || typeof givenPath !== "string") {
+    throw new PathScopeError("empty path");
+  }
+  const cleaned = givenPath.trim();
+  const extras = (opts?.readableExtras || []).map((e) => path2.resolve(e));
+  if (path2.isAbsolute(cleaned)) {
+    const resolved2 = path2.resolve(cleaned);
+    if (isInside(root, resolved2)) return resolved2;
+    for (const ex of extras) {
+      if (isInside(ex, resolved2)) return resolved2;
+    }
+    throw new PathScopeError(
+      `absolute path ${JSON.stringify(cleaned)} outside workspace` + (extras.length ? ` (and not under any mounted folder: ${extras.join(", ")})` : "")
+    );
+  }
+  const resolved = path2.resolve(root, cleaned);
+  if (!isInside(root, resolved)) {
+    throw new PathScopeError(`relative path ${JSON.stringify(cleaned)} escapes workspace via '..'`);
+  }
+  return resolved;
+}
+function isInside(root, candidate) {
+  const r = path2.resolve(root);
+  const c = path2.resolve(candidate);
+  if (c === r) return true;
+  const rel = path2.relative(r, c);
+  return !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function toWorkspaceRel(abs) {
+  const root = workspaceRoot();
+  const r = path2.resolve(abs);
+  const rel = path2.relative(root, r);
+  if (rel && !rel.startsWith("..") && !path2.isAbsolute(rel)) {
+    return rel.split(path2.sep).join("/");
+  }
+  return r.split(path2.sep).join("/");
+}
+
+// src/executors/filesystem.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  ".pytest_cache"
+]);
+async function listDir(args, mountedFolders) {
+  const max_depth = Math.max(1, Math.min(args.max_depth ?? 4, 10));
+  const extras = mountedFolders ? Array.from(mountedFolders) : [];
+  const root = resolveInWorkspace(args.path || ".", { readableExtras: extras });
+  const entries = [];
+  let truncated = false;
+  async function walk(dir, depth) {
+    if (depth > max_depth) return;
+    let items;
+    try {
+      items = await fs2.readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      return;
+    }
+    for (const it of items) {
+      if (entries.length >= 500) {
+        truncated = true;
+        return;
+      }
+      if (it.isDirectory() && SKIP_DIRS.has(it.name)) continue;
+      const full = path3.join(dir, it.name);
+      const rel = toWorkspaceRel(full);
+      if (it.isDirectory()) {
+        entries.push({ path: rel, size_bytes: null, is_dir: true });
+        await walk(full, depth + 1);
+      } else if (it.isFile()) {
+        let size = 0;
+        try {
+          size = (await fs2.stat(full)).size;
+        } catch {
+        }
+        entries.push({ path: rel, size_bytes: size, is_dir: false });
+      }
+    }
+  }
+  await walk(root, 1);
+  return {
+    path: toWorkspaceRel(root) || ".",
+    entries,
+    truncated
+  };
+}
+var MAX_FILE_BYTES = 200 * 1024;
+var BINARY_EXT = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".tiff",
+  ".webp",
+  ".ico",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".so",
+  ".dll",
+  ".dylib",
+  ".exe",
+  ".bin",
+  ".o",
+  ".a",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".webm",
+  ".wav",
+  ".class",
+  ".jar",
+  ".pyc",
+  ".pyo"
+]);
+async function readFile3(args, mountedFolders) {
+  const extras = mountedFolders ? Array.from(mountedFolders) : [];
+  const abs = resolveInWorkspace(args.path, { readableExtras: extras });
+  const ext = path3.extname(abs).toLowerCase();
+  if (BINARY_EXT.has(ext)) {
+    return { error: "binary file refused", path: args.path, extension: ext };
+  }
+  let stat5;
+  try {
+    stat5 = await fs2.stat(abs);
+  } catch (err) {
+    return { error: `${err.code || "ENOENT"}: ${err.message}`, path: args.path };
+  }
+  if (stat5.size > MAX_FILE_BYTES && (args.start_line == null || args.end_line == null)) {
+    return {
+      error: `file too large (${stat5.size} bytes > ${MAX_FILE_BYTES}); specify start_line + end_line`,
+      path: args.path,
+      size_bytes: stat5.size
+    };
+  }
+  const content = await fs2.readFile(abs, "utf-8");
+  const lines = content.split(/\r?\n/);
+  if (args.start_line || args.end_line) {
+    const s = Math.max(1, args.start_line || 1);
+    const e = Math.min(lines.length, args.end_line || lines.length);
+    const sliced = lines.slice(s - 1, e).join("\n");
+    return {
+      path: args.path,
+      content: sliced,
+      encoding: "utf-8",
+      total_lines: lines.length,
+      returned_lines: [s, e]
+    };
+  }
+  return {
+    path: args.path,
+    content,
+    encoding: "utf-8",
+    total_lines: lines.length,
+    returned_lines: [1, lines.length]
+  };
+}
+async function writeFile3(args, rb) {
+  const abs = resolveInWorkspace(args.path);
+  await fs2.mkdir(path3.dirname(abs), { recursive: true });
+  let previousSize = null;
+  let created = true;
+  try {
+    const s = await fs2.stat(abs);
+    previousSize = s.size;
+    created = false;
+  } catch {
+  }
+  const rollback_token = await rb.snapshot(abs);
+  await fs2.writeFile(abs, args.content, "utf-8");
+  return {
+    path: args.path,
+    bytes_written: Buffer.byteLength(args.content, "utf-8"),
+    previous_size_bytes: previousSize,
+    created,
+    rollback_token
+  };
+}
+async function editFile(args, rb) {
+  const abs = resolveInWorkspace(args.path);
+  const expected = args.expect_count ?? 1;
+  if (typeof args.search !== "string" || args.search.length === 0) {
+    return { error: "empty_search", path: args.path };
+  }
+  let content;
+  try {
+    content = await fs2.readFile(abs, "utf-8");
+  } catch (err) {
+    return { error: err.code || "ENOENT", path: args.path, message: err.message };
+  }
+  let count = 0;
+  let idx = 0;
+  while ((idx = content.indexOf(args.search, idx)) !== -1) {
+    count++;
+    idx += args.search.length;
+  }
+  if (count !== expected) {
+    const result = {
+      error: "match_count_mismatch",
+      path: args.path,
+      expected_count: expected,
+      actual_count: count,
+      hint: count === 0 ? "search string not found \u2014 see closest_match for the most-similar block actually in the file, then adjust your 'search' to match exactly OR use apply_diff for context-aware patching" : `found ${count} matches but expected ${expected}. Either widen 'search' for uniqueness, or pass expect_count=${count} if all should be replaced.`
+    };
+    if (count === 0) {
+      const cm = _findClosestMatch(content, args.search);
+      if (cm) result.closest_match = cm;
+    }
+    return result;
+  }
+  const rollback_token = await rb.snapshot(abs);
+  const next = content.split(args.search).join(args.replace);
+  await fs2.writeFile(abs, next, "utf-8");
+  return {
+    path: args.path,
+    applied: true,
+    matches_replaced: count,
+    rollback_token
+  };
+}
+function _findClosestMatch(content, search) {
+  const searchLines = search.split(/\r?\n/);
+  const fileLines = content.split(/\r?\n/);
+  const N = searchLines.length;
+  if (N === 0 || fileLines.length < N) return null;
+  const firstSearch = searchLines[0].trim();
+  const firstTok = firstSearch.split(/[\s(){}.,;:=]/).filter((t) => t.length > 2);
+  let best = null;
+  for (let i = 0; i <= fileLines.length - N; i++) {
+    const candidateFirst = fileLines[i];
+    if (firstTok.length > 0 && !firstTok.some((t) => candidateFirst.includes(t))) {
+      continue;
+    }
+    let exact = 0;
+    let charSim = 0;
+    for (let j = 0; j < N; j++) {
+      const a = searchLines[j], b = fileLines[i + j];
+      if (a === b) {
+        exact++;
+        charSim += 1;
+        continue;
+      }
+      charSim += _diceCoefficient(a, b);
+    }
+    const score = (exact * 1 + charSim) / (2 * N);
+    if (!best || score > best.score) {
+      best = { start: i, score };
+    }
+  }
+  if (!best || best.score < 0.25) return null;
+  const actualLines = fileLines.slice(best.start, best.start + N);
+  return {
+    start_line: best.start + 1,
+    // 1-indexed
+    end_line: best.start + N,
+    similarity: Math.round(best.score * 100),
+    actual: actualLines.join("\n")
+  };
+}
+function _diceCoefficient(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+  const bigrams = (s) => {
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < s.length - 1; i++) {
+      const g = s.slice(i, i + 2);
+      out.set(g, (out.get(g) || 0) + 1);
+    }
+    return out;
+  };
+  const A = bigrams(a), B = bigrams(b);
+  let intersection = 0;
+  for (const [g, ca] of A) {
+    const cb = B.get(g) || 0;
+    intersection += Math.min(ca, cb);
+  }
+  return 2 * intersection / (a.length - 1 + b.length - 1);
+}
+async function glob(args, mountedFolders) {
+  const extras = mountedFolders ? Array.from(mountedFolders) : [];
+  const root = resolveInWorkspace(args.path || ".", { readableExtras: extras });
+  const max = Math.max(1, Math.min(args.max_results ?? 200, 2e3));
+  const re = globToRegExp(args.pattern);
+  const matches = [];
+  let truncated = false;
+  async function walk(dir) {
+    if (matches.length >= max) {
+      truncated = true;
+      return;
+    }
+    let items;
+    try {
+      items = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const it of items) {
+      if (matches.length >= max) {
+        truncated = true;
+        return;
+      }
+      if (it.isDirectory() && SKIP_DIRS.has(it.name)) continue;
+      const full = path3.join(dir, it.name);
+      const rel = toWorkspaceRel(full);
+      if (it.isFile() && re.test(rel)) matches.push(rel);
+      if (it.isDirectory()) await walk(full);
+    }
+  }
+  await walk(root);
+  return { pattern: args.pattern, matches, truncated };
+}
+function globToRegExp(pattern) {
+  let re = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          re += "(?:.*/)?";
+          i += 3;
+        } else {
+          re += ".*";
+          i += 2;
+        }
+      } else {
+        re += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i++;
+    } else if (c === ".") {
+      re += "\\.";
+      i++;
+    } else if (c === "+") {
+      re += "\\+";
+      i++;
+    } else if (c === "(" || c === ")" || c === "|" || c === "$" || c === "^") {
+      re += "\\" + c;
+      i++;
+    } else if (c === "[") {
+      const close = pattern.indexOf("]", i);
+      if (close === -1) {
+        re += "\\[";
+        i++;
+      } else {
+        re += pattern.slice(i, close + 1);
+        i = close + 1;
+      }
+    } else if (c === "{") {
+      const close = pattern.indexOf("}", i);
+      if (close === -1) {
+        re += "\\{";
+        i++;
+      } else {
+        const alts = pattern.slice(i + 1, close).split(",");
+        re += "(" + alts.map((a) => globToRegExp(a).source.slice(1, -1)).join("|") + ")";
+        i = close + 1;
+      }
+    } else {
+      re += c;
+      i++;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+async function grep(args, mountedFolders) {
+  const extras = mountedFolders ? Array.from(mountedFolders) : [];
+  const root = resolveInWorkspace(args.path || ".", { readableExtras: extras });
+  const isRegex = args.regex !== false;
+  const fileGlob = args.file_glob || "**/*";
+  const max = Math.max(1, Math.min(args.max_matches ?? 200, 2e3));
+  let re;
+  try {
+    re = isRegex ? new RegExp(args.pattern) : new RegExp(args.pattern.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"));
+  } catch (err) {
+    return { error: "invalid_regex", message: err.message, pattern: args.pattern };
+  }
+  const fileRe = globToRegExp(fileGlob);
+  const hits = [];
+  let truncated = false;
+  let filesScanned = 0;
+  async function walk(dir) {
+    if (hits.length >= max) {
+      truncated = true;
+      return;
+    }
+    let items;
+    try {
+      items = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const it of items) {
+      if (hits.length >= max) {
+        truncated = true;
+        return;
+      }
+      if (it.isDirectory() && SKIP_DIRS.has(it.name)) {
+        continue;
+      }
+      const full = path3.join(dir, it.name);
+      if (it.isDirectory()) {
+        await walk(full);
+        continue;
+      }
+      if (!it.isFile()) continue;
+      const rel = toWorkspaceRel(full);
+      if (!fileRe.test(rel)) continue;
+      const ext = path3.extname(full).toLowerCase();
+      if (BINARY_EXT.has(ext)) continue;
+      let stat5;
+      try {
+        stat5 = await fs2.stat(full);
+      } catch {
+        continue;
+      }
+      if (stat5.size > 1e6) continue;
+      filesScanned++;
+      let content;
+      try {
+        content = await fs2.readFile(full, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i])) {
+          hits.push({ path: rel, line: i + 1, content: lines[i].slice(0, 400) });
+          if (hits.length >= max) {
+            truncated = true;
+            return;
+          }
+        }
+      }
+    }
+  }
+  await walk(root);
+  return { pattern: args.pattern, hits, truncated, files_scanned: filesScanned };
+}
+
+// src/executors/shell.ts
+var import_node_child_process2 = require("node:child_process");
+
+// src/processRegistry.ts
+var import_node_child_process = require("node:child_process");
+var LONG_RUNNING_PATTERNS = [
+  /^uvicorn\b/,
+  /^gunicorn\b/,
+  /^flask\s+run\b/,
+  /^next\s+dev\b/,
+  /^vite\b/,
+  /\bnpm\s+run\s+dev\b/,
+  /\byarn\s+dev\b/,
+  /\bpnpm\s+dev\b/,
+  /^cargo\s+run\b/,
+  /^go\s+run\b/,
+  /^python\s+-m\s+http\.server\b/,
+  /^flutter\s+run\b/,
+  /&\s*$/,
+  // backgrounded
+  /^nohup\b/
+];
+function isLongRunning(command) {
+  const t = command.trim();
+  return LONG_RUNNING_PATTERNS.some((re) => re.test(t));
+}
+function extractPortBindings(command) {
+  const ports = [];
+  const reFlag = /(?:--?port[=\s]+|:)(\d{2,5})\b/g;
+  let m;
+  while ((m = reFlag.exec(command)) !== null) {
+    const p = parseInt(m[1], 10);
+    if (p >= 1024 && p <= 65535) ports.push(p);
+  }
+  return [...new Set(ports)];
+}
+function _treeKill(proc, sig) {
+  const pid = proc.pid;
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    (0, import_node_child_process.spawnSync)("taskkill", ["/F", "/T", "/PID", String(pid)], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+  } else {
+    try {
+      process.kill(-pid, sig);
+    } catch {
+      proc.kill(sig);
+    }
+  }
+}
+var ProcessRegistry = class {
+  procs = /* @__PURE__ */ new Map();
+  finished = [];
+  // exited procs, kept for include_finished
+  register(proc, command) {
+    const info = {
+      pid: proc.pid,
+      command,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      portBindings: extractPortBindings(command),
+      proc
+    };
+    this.procs.set(proc.pid, info);
+    proc.on("exit", (code) => {
+      info.status = "exited";
+      info.exitCode = code ?? -1;
+      this.procs.delete(proc.pid);
+      this.finished.push(info);
+      if (this.finished.length > 30) this.finished.shift();
+    });
+    return info;
+  }
+  list(includeFinished = false) {
+    const live = Array.from(this.procs.values()).map(strip);
+    if (!includeFinished) return live;
+    return [...live, ...this.finished.map(strip)];
+  }
+  owns(pid) {
+    return this.procs.has(pid);
+  }
+  async signal(pid, sig) {
+    const info = this.procs.get(pid);
+    if (!info) {
+      return { killed: false, pid, reason: "PID not owned by this agent session" };
+    }
+    try {
+      _treeKill(info.proc, sig);
+    } catch (err) {
+      return { killed: false, pid, reason: err?.message || String(err) };
+    }
+    const exited = await new Promise((resolve3) => {
+      const timer = setTimeout(() => resolve3(false), 5e3);
+      info.proc.once("exit", () => {
+        clearTimeout(timer);
+        resolve3(true);
+      });
+    });
+    if (!exited && sig === "SIGTERM") {
+      await new Promise((r) => setTimeout(r, 2e3));
+      try {
+        _treeKill(info.proc, "SIGKILL");
+      } catch {
+      }
+    }
+    return { killed: true, pid, exitCode: info.exitCode };
+  }
+  /** Called from extension.deactivate() — best-effort kill all alive procs. */
+  async cleanupAll() {
+    const pids = Array.from(this.procs.keys());
+    for (const pid of pids) {
+      const info = this.procs.get(pid);
+      if (!info) continue;
+      try {
+        _treeKill(info.proc, "SIGTERM");
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+    for (const pid of pids) {
+      const info = this.procs.get(pid);
+      if (!info) continue;
+      try {
+        _treeKill(info.proc, "SIGKILL");
+      } catch {
+      }
+    }
+    return pids.length;
+  }
+  get size() {
+    return this.procs.size;
+  }
+};
+function strip(info) {
+  const { proc, ...rest } = info;
+  return rest;
+}
+
+// src/executors/shell.ts
+function normalizeWindowsCommand(cmd) {
+  if (process.platform !== "win32") return cmd;
+  const m = /^(\s*)python3?(\.exe)?\s+-c\s+"((?:\\.|[^"])*)"(.*)$/.exec(cmd);
+  if (!m) return cmd;
+  let code = m[3];
+  const tail = m[4] || "";
+  code = code.replace(/\\"/g, '"');
+  if (code.includes("'")) {
+    return cmd;
+  }
+  return `py -c '${code}'${tail}`;
+}
+async function runCommand(args, registry, signal) {
+  const cmd = normalizeWindowsCommand(args.command);
+  const timeoutMs = Math.min(Math.max(args.timeout_s ?? 60, 1), 120) * 1e3;
+  const cwd = args.cwd ? resolveInWorkspace(args.cwd) : workspaceRoot();
+  if (signal?.aborted) {
+    return {
+      command: cmd,
+      exit_code: -1,
+      stdout: "",
+      stderr: "",
+      duration_ms: 0,
+      timed_out: false,
+      spawned_pid: null,
+      error: "aborted"
+    };
+  }
+  const longRunning = isLongRunning(cmd);
+  const isWin = process.platform === "win32";
+  const proc = isWin ? (0, import_node_child_process2.spawn)("cmd.exe", ["/c", cmd], { cwd }) : (0, import_node_child_process2.spawn)("/bin/sh", ["-c", cmd], { cwd });
+  if (signal) {
+    const onAbort = () => {
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  if (longRunning) {
+    registry.register(proc, cmd);
+    proc.unref();
+    return {
+      command: cmd,
+      exit_code: -1,
+      stdout: "",
+      stderr: "[long-running process spawned in background]",
+      duration_ms: 0,
+      timed_out: false,
+      spawned_pid: proc.pid ?? null
+    };
+  }
+  const t0 = Date.now();
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  proc.stdout?.setEncoding("utf-8");
+  proc.stderr?.setEncoding("utf-8");
+  proc.stdout?.on("data", (chunk) => {
+    stdout += chunk;
+    if (stdout.length > 256e3) stdout = stdout.slice(0, 256e3) + "\n[truncated]";
+  });
+  proc.stderr?.on("data", (chunk) => {
+    stderr += chunk;
+    if (stderr.length > 128e3) stderr = stderr.slice(0, 128e3) + "\n[truncated]";
+  });
+  const exitCode = await new Promise((resolve3) => {
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }, 1e3);
+    }, timeoutMs);
+    proc.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve3(code ?? -1);
+    });
+    proc.on("error", () => {
+      clearTimeout(timer);
+      resolve3(-1);
+    });
+  });
+  return {
+    command: cmd,
+    exit_code: exitCode,
+    stdout,
+    stderr,
+    duration_ms: Date.now() - t0,
+    timed_out: timedOut,
+    spawned_pid: null
+  };
+}
+
+// src/executors/localPlane.ts
+var os = __toESM(require("node:os"));
+var net = __toESM(require("node:net"));
+var import_node_child_process3 = require("node:child_process");
+var RUNTIME_PROBES = [
+  // Day 13 P3 fix: probe `py` (Python Launcher) FIRST on Windows so the
+  // Microsoft Store stub for `python` doesn't get reported as installed.
+  { key: "python", candidates: ["py", "python3", "python"] },
+  { key: "node", candidates: ["node"] },
+  { key: "go", candidates: ["go"] },
+  { key: "rust", candidates: ["rustc"] },
+  { key: "java", candidates: ["java"] },
+  { key: "dotnet", candidates: ["dotnet"] },
+  { key: "ruby", candidates: ["ruby"] },
+  { key: "deno", candidates: ["deno"] }
+];
+var TOOL_PROBES = ["git", "docker", "uv", "pnpm", "yarn", "npm", "make", "rg", "gh", "kubectl"];
+async function probeVersion(cmd, args = ["--version"]) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process3.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    } catch {
+      return resolve3(null);
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => {
+      out += c;
+    });
+    proc.stderr?.on("data", (c) => {
+      err += c;
+    });
+    proc.on("error", () => resolve3(null));
+    proc.on("exit", (code) => {
+      if (code !== 0) return resolve3(null);
+      const txt = (out + err).trim().split(/\r?\n/)[0] || "";
+      if (!txt || /microsoft store|ms-windows-store/i.test(txt)) {
+        return resolve3(null);
+      }
+      resolve3(txt);
+    });
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+      resolve3(null);
+    }, 2500);
+  });
+}
+function osName() {
+  const p = os.platform();
+  if (p === "linux") return "Linux";
+  if (p === "darwin") return "Darwin";
+  if (p === "win32") return "Windows";
+  return p;
+}
+async function systemInfo(args) {
+  const level = args.level ?? "brief";
+  const cpus2 = os.cpus() || [];
+  const total = os.totalmem();
+  const free = os.freemem();
+  const base = {
+    os: { name: osName(), release: os.release(), arch: os.arch() },
+    cpu: {
+      cores_logical: cpus2.length,
+      cores_physical: Math.max(1, Math.floor(cpus2.length / 2))
+    },
+    memory: {
+      total_mb: Math.round(total / 1024 / 1024),
+      available_mb: Math.round(free / 1024 / 1024)
+    },
+    runtimes_present: [],
+    tools_present: []
+  };
+  const runtimeResults = {};
+  for (const probe of RUNTIME_PROBES) {
+    const found = [];
+    for (const cmd of probe.candidates) {
+      const ver = await probeVersion(cmd);
+      if (ver) found.push({ installed: true, version: ver, command: cmd });
+    }
+    runtimeResults[probe.key] = found;
+    if (found.length > 0) base.runtimes_present.push(probe.key);
+  }
+  const toolResults = {};
+  for (const cmd of TOOL_PROBES) {
+    const ver = await probeVersion(cmd);
+    toolResults[cmd] = { installed: !!ver, version: ver, command: cmd };
+    if (ver) base.tools_present.push(cmd);
+  }
+  if (level === "brief") return base;
+  const full = {
+    ...base,
+    os: { ...base.os, kernel: os.type() },
+    cpu: { ...base.cpu, model: (cpus2[0]?.model || "").trim() },
+    memory: {
+      ...base.memory,
+      percent_used: Math.round((1 - free / total) * 1e3) / 10
+    },
+    runtimes: runtimeResults,
+    tools: toolResults
+  };
+  return full;
+}
+function listProcesses(args, registry) {
+  const include = args.include_finished ?? false;
+  const procs = registry.list(include);
+  return {
+    processes: procs.map((p) => ({
+      pid: p.pid,
+      command: p.command,
+      started_at: p.startedAt,
+      status: p.status,
+      exit_code: p.exitCode,
+      port_bindings: p.portBindings
+    }))
+  };
+}
+async function tryBind(port, host = "127.0.0.1") {
+  return new Promise((resolve3, reject) => {
+    const server = net.createServer();
+    let settled = false;
+    server.once("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    server.listen(port, host, () => {
+      if (settled) {
+        server.close();
+        return;
+      }
+      const addr = server.address();
+      const p = typeof addr === "object" && addr ? addr.port : port;
+      server.close(() => {
+        if (settled) return;
+        settled = true;
+        resolve3(p);
+      });
+    });
+  });
+}
+async function allocatePort(args) {
+  if (typeof args.prefer === "number") {
+    try {
+      const port = await tryBind(args.prefer);
+      return { port, source: "preferred" };
+    } catch {
+    }
+  }
+  const [start, end] = args.range ?? [8e3, 9e3];
+  for (let p = start; p <= end; p++) {
+    try {
+      const port = await tryBind(p);
+      return { port, source: "random" };
+    } catch {
+      continue;
+    }
+  }
+  return { error: "no_free_port", range: [start, end] };
+}
+async function killProcess(args, registry) {
+  const sig = args.signal ?? "SIGTERM";
+  const r = await registry.signal(args.pid, sig);
+  return {
+    killed: r.killed,
+    pid: r.pid,
+    exit_code: r.exitCode,
+    reason: r.reason
+  };
+}
+async function verifyPackage(args, settings) {
+  const url = `${settings.backendUrl}/code-workspace/verify-package?ecosystem=${encodeURIComponent(args.ecosystem)}&name=${encodeURIComponent(args.name)}`;
+  try {
+    const res = await fetch(url, {
+      headers: { "Authorization": `Bearer ${settings.authBearer}` }
+    });
+    if (!res.ok) {
+      return {
+        exists: null,
+        ecosystem: args.ecosystem,
+        name: args.name,
+        error: `backend ${res.status}: ${await res.text().catch(() => "")}`
+      };
+    }
+    return await res.json();
+  } catch (err) {
+    return {
+      exists: null,
+      ecosystem: args.ecosystem,
+      name: args.name,
+      error: `client fetch failed: ${err?.message || String(err)}`
+    };
+  }
+}
+async function webSearch(args, settings) {
+  const params = new URLSearchParams();
+  params.set("query", args.query);
+  if (args.sources && args.sources.length) params.set("sources", args.sources.join(","));
+  if (args.max_per_source) params.set("max_per_source", String(args.max_per_source));
+  const url = `${settings.backendUrl}/code-workspace/web-search?${params.toString()}`;
+  try {
+    const res = await fetch(url, {
+      headers: { "Authorization": `Bearer ${settings.authBearer}` }
+    });
+    if (!res.ok) {
+      return {
+        error: `backend ${res.status}: ${await res.text().catch(() => "")}`,
+        query: args.query
+      };
+    }
+    return await res.json();
+  } catch (err) {
+    return {
+      error: `client fetch failed: ${err?.message || String(err)}`,
+      query: args.query
+    };
+  }
+}
+async function verifyPackageBatch(args, settings) {
+  const pkgs = Array.isArray(args?.packages) ? args.packages : [];
+  if (!pkgs.length) return { error: "packages array required" };
+  return _backend("POST", "/code-workspace/verify-package-batch", settings, {
+    body: { packages: pkgs }
+  });
+}
+async function _backend(method, path9, settings, opts) {
+  let url = `${settings.backendUrl}${path9}`;
+  if (opts?.query) {
+    const p = new URLSearchParams();
+    for (const [k, v] of Object.entries(opts.query)) {
+      if (v !== void 0 && v !== null) p.set(k, String(v));
+    }
+    const qs = p.toString();
+    if (qs) url += (path9.includes("?") ? "&" : "?") + qs;
+  }
+  const init = {
+    method,
+    headers: {
+      "Authorization": `Bearer ${settings.authBearer}`,
+      "Content-Type": "application/json"
+    }
+  };
+  if (opts?.body !== void 0) init.body = JSON.stringify(opts.body);
+  try {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      let detail = "";
+      try {
+        detail = await res.text();
+      } catch {
+      }
+      return { error: `backend ${res.status}`, detail: detail.slice(0, 400) };
+    }
+    return await res.json();
+  } catch (err) {
+    return { error: `client fetch failed: ${err?.message || String(err)}` };
+  }
+}
+async function gpuInfo(_args, settings) {
+  return _backend("GET", "/code-workspace/gpu-info", settings);
+}
+async function startBackgroundTask(args, settings) {
+  if (!args?.command) return { error: "command required" };
+  return _backend("POST", "/code-workspace/bg-task/start", settings, {
+    body: {
+      command: args.command,
+      cwd: args.cwd || "",
+      label: args.label || "",
+      env_extra: args.env_extra || null
+    }
+  });
+}
+async function checkBackgroundTask(args, settings) {
+  if (!args?.task_id) return { error: "task_id required" };
+  return _backend("GET", "/code-workspace/bg-task/check", settings, {
+    query: { task_id: args.task_id, tail_lines: args.tail_lines }
+  });
+}
+async function listBackgroundTasks(_args, settings) {
+  return _backend("GET", "/code-workspace/bg-task/list", settings);
+}
+async function cancelBackgroundTask(args, settings) {
+  if (!args?.task_id) return { error: "task_id required" };
+  return _backend("POST", "/code-workspace/bg-task/cancel", settings, {
+    body: { task_id: args.task_id, signal: args.signal || "TERM" }
+  });
+}
+
+// src/executors/lint.ts
+var import_node_child_process4 = require("node:child_process");
+var fs3 = __toESM(require("node:fs/promises"));
+var path4 = __toESM(require("node:path"));
+async function fileExists(p) {
+  try {
+    await fs3.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commandExists(cmd) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process4.spawn)(
+        cmd,
+        ["--version"],
+        { stdio: ["ignore", "ignore", "ignore"], windowsHide: true }
+      );
+    } catch {
+      return resolve3(false);
+    }
+    proc.on("error", () => resolve3(false));
+    proc.on("exit", (code) => resolve3(code === 0));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+      resolve3(false);
+    }, 1500);
+  });
+}
+async function readJsonIfExists(p) {
+  try {
+    const t = await fs3.readFile(p, "utf-8");
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+}
+async function detect(root) {
+  if (await fileExists(path4.join(root, "pyproject.toml")) && await commandExists("ruff")) {
+    return {
+      tool: "ruff",
+      bin: "ruff",
+      args: (sub, fix) => fix ? ["check", "--fix", "--output-format=json", sub] : ["check", "--output-format=json", sub]
+    };
+  }
+  const pkgJsonPath = path4.join(root, "package.json");
+  const pkgJson = await readJsonIfExists(pkgJsonPath);
+  const hasBiome = await fileExists(path4.join(root, "biome.json")) || !!(pkgJson?.devDependencies?.["@biomejs/biome"] || pkgJson?.dependencies?.["@biomejs/biome"]);
+  if (hasBiome && (await commandExists("biome") || await commandExists("npx"))) {
+    const useNpx = !await commandExists("biome");
+    return {
+      tool: "biome",
+      bin: useNpx ? "npx" : "biome",
+      args: (sub, fix) => {
+        const base = useNpx ? ["biome"] : [];
+        return [...base, fix ? "check" : "lint", fix ? "--apply" : "--reporter=json", sub];
+      }
+    };
+  }
+  const hasEslint = pkgJson?.devDependencies?.eslint || pkgJson?.dependencies?.eslint;
+  if (hasEslint && (await commandExists("eslint") || await commandExists("npx"))) {
+    const useNpx = !await commandExists("eslint");
+    return {
+      tool: "eslint",
+      bin: useNpx ? "npx" : "eslint",
+      args: (sub, fix) => {
+        const base = useNpx ? ["eslint"] : [];
+        return [...base, "--format=json", ...fix ? ["--fix"] : [], sub];
+      }
+    };
+  }
+  if (await fileExists(path4.join(root, "Cargo.toml")) && await commandExists("cargo")) {
+    return {
+      tool: "clippy",
+      bin: "cargo",
+      args: (_sub, fix) => fix ? ["clippy", "--fix", "--allow-dirty", "--message-format=json"] : ["clippy", "--message-format=json"]
+    };
+  }
+  if (await fileExists(path4.join(root, "go.mod")) && await commandExists("go")) {
+    return {
+      tool: "go-vet",
+      bin: "go",
+      args: (sub, _fix) => ["vet", `./${sub === "." ? "..." : sub + "/..."}`]
+    };
+  }
+  if ((await fileExists(path4.join(root, ".flake8")) || await fileExists(path4.join(root, "setup.cfg"))) && await commandExists("flake8")) {
+    return {
+      tool: "flake8",
+      bin: "flake8",
+      args: (sub, _fix) => ["--format=%(path)s:%(row)d:%(col)d: %(code)s %(text)s", sub]
+    };
+  }
+  return null;
+}
+function parseRuff(stdout, root) {
+  try {
+    const data = JSON.parse(stdout);
+    if (!Array.isArray(data)) return [];
+    return data.map((d) => ({
+      path: toWorkspaceRel(d.filename || ""),
+      line: d.location?.row ?? 0,
+      column: d.location?.column,
+      severity: "error",
+      code: d.code,
+      message: d.message || ""
+    }));
+  } catch {
+    return [];
+  }
+}
+function parseBiome(stdout) {
+  try {
+    const data = JSON.parse(stdout);
+    const diagnostics = data?.diagnostics || [];
+    return diagnostics.map((d) => ({
+      path: d.location?.path?.file?.toString() || "",
+      line: (d.location?.span?.[0] ?? 0) > 0 ? d.location.span[0] : 0,
+      severity: d.severity === "warning" ? "warning" : d.severity === "info" ? "info" : "error",
+      code: d.category,
+      message: d.description || d.message?.text || ""
+    }));
+  } catch {
+    return [];
+  }
+}
+function parseEslint(stdout, root) {
+  try {
+    const data = JSON.parse(stdout);
+    const out = [];
+    for (const f of data || []) {
+      for (const m of f.messages || []) {
+        out.push({
+          path: toWorkspaceRel(f.filePath || ""),
+          line: m.line ?? 0,
+          column: m.column,
+          severity: m.severity === 2 ? "error" : "warning",
+          code: m.ruleId || void 0,
+          message: m.message || ""
+        });
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function parseClippy(stdout) {
+  const out = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.reason !== "compiler-message") continue;
+      const msg = obj.message;
+      if (!msg || msg.level === "help") continue;
+      const span = (msg.spans || []).find((s) => s.is_primary) || msg.spans?.[0];
+      if (!span) continue;
+      out.push({
+        path: span.file_name || "",
+        line: span.line_start ?? 0,
+        column: span.column_start,
+        severity: msg.level === "error" ? "error" : msg.level === "warning" ? "warning" : "info",
+        code: msg.code?.code,
+        message: msg.message || ""
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function parseFlake8(stdout) {
+  const re = /^(.+?):(\d+):(\d+):\s*(\S+)\s+(.+)$/;
+  const out = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const m = re.exec(line.trim());
+    if (m) out.push({
+      path: m[1],
+      line: parseInt(m[2], 10),
+      column: parseInt(m[3], 10),
+      severity: m[4].startsWith("E") ? "error" : "warning",
+      code: m[4],
+      message: m[5]
+    });
+  }
+  return out;
+}
+function parseGoVet(stderr) {
+  const re = /^(.+?):(\d+):(\d+):\s+(.+)$/;
+  const out = [];
+  for (const line of stderr.split(/\r?\n/)) {
+    const m = re.exec(line.trim());
+    if (m) out.push({
+      path: m[1],
+      line: parseInt(m[2], 10),
+      column: parseInt(m[3], 10),
+      severity: "error",
+      message: m[4]
+    });
+  }
+  return out;
+}
+async function runProc(cmd, args, cwd) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process4.spawn)(cmd, args, { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      return resolve3({ stdout: "", stderr: e?.message || "spawn failed", exitCode: -1 });
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => {
+      out += c;
+      if (out.length > 4e5) out = out.slice(0, 4e5) + "\n[truncated]";
+    });
+    proc.stderr?.on("data", (c) => {
+      err += c;
+      if (err.length > 2e5) err = err.slice(0, 2e5) + "\n[truncated]";
+    });
+    proc.on("error", () => resolve3({ stdout: out, stderr: err || "spawn error", exitCode: -1 }));
+    proc.on("exit", (code) => resolve3({ stdout: out, stderr: err, exitCode: code ?? -1 }));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, 12e4);
+  });
+}
+async function runLint(args) {
+  const root = workspaceRoot();
+  const sub = args.path ? toWorkspaceRel(resolveInWorkspace(args.path)) || "." : ".";
+  const fix = args.fix === true;
+  const det = await detect(root);
+  if (!det) {
+    return {
+      tool_used: null,
+      ran_in: sub,
+      issues: [],
+      raw_summary: "no lint setup detected \u2014 scanned for pyproject.toml/package.json/Cargo.toml/go.mod/.flake8",
+      hint: "Project has no detectable linter config. Don't install one without asking the user \u2014 they may have a preference."
+    };
+  }
+  const cmdArgs = det.args(sub, fix);
+  const { stdout, stderr, exitCode } = await runProc(det.bin, cmdArgs, root);
+  let issues = [];
+  switch (det.tool) {
+    case "ruff":
+      issues = parseRuff(stdout, root);
+      break;
+    case "biome":
+      issues = parseBiome(stdout);
+      break;
+    case "eslint":
+      issues = parseEslint(stdout, root);
+      break;
+    case "clippy":
+      issues = parseClippy(stdout);
+      break;
+    case "go-vet":
+      issues = parseGoVet(stderr);
+      break;
+    case "flake8":
+      issues = parseFlake8(stdout);
+      break;
+  }
+  const sevCount = issues.reduce((acc, i) => {
+    acc[i.severity] = (acc[i.severity] ?? 0) + 1;
+    return acc;
+  }, {});
+  const summary = issues.length === 0 ? `${det.tool}: clean (exit ${exitCode})` : `${det.tool}: ${issues.length} issue(s) \u2014 ${JSON.stringify(sevCount)} (exit ${exitCode})`;
+  return {
+    tool_used: det.tool,
+    ran_in: sub,
+    fix_applied: fix,
+    issues: issues.slice(0, 200),
+    // cap to avoid blowing context
+    raw_summary: summary + (issues.length > 200 ? ` (showing first 200 of ${issues.length})` : ""),
+    exit_code: exitCode
+  };
+}
+
+// src/executors/format.ts
+var import_node_child_process5 = require("node:child_process");
+async function runProc2(cmd, args, cwd) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process5.spawn)(cmd, args, { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      return resolve3({ stdout: "", stderr: e?.message || "spawn failed", exitCode: -1 });
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => {
+      out += c;
+      if (out.length > 4e5) out = out.slice(0, 4e5) + "\n[truncated]";
+    });
+    proc.stderr?.on("data", (c) => {
+      err += c;
+      if (err.length > 2e5) err = err.slice(0, 2e5) + "\n[truncated]";
+    });
+    proc.on("error", () => resolve3({ stdout: out, stderr: err || "spawn error", exitCode: -1 }));
+    proc.on("exit", (code) => resolve3({ stdout: out, stderr: err, exitCode: code ?? -1 }));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, 6e4);
+  });
+}
+async function runFormat(args) {
+  const start = performance.now();
+  const root = workspaceRoot();
+  const filePath = args.path ? resolveInWorkspace(args.path) : root;
+  const checkOnly = args.check_only === true;
+  const cmdArgs = checkOnly ? ["format", "--check", filePath] : ["format", filePath];
+  const { stdout, stderr, exitCode } = await runProc2("ruff", cmdArgs, root);
+  const durationMs = Math.round(performance.now() - start);
+  const applied = checkOnly ? false : exitCode === 1 ? true : false;
+  return {
+    tool_used: "ruff",
+    applied,
+    exit_code: exitCode,
+    stdout,
+    stderr,
+    duration_ms: durationMs
+  };
+}
+
+// src/executors/pr.ts
+var import_node_child_process6 = require("node:child_process");
+var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["main", "master", "develop", "prod", "production", "release"]);
+async function run(cmd, args, cwd, timeoutMs = 3e4) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process6.spawn)(cmd, args, { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      return resolve3({ stdout: "", stderr: e?.message || "spawn failed", exitCode: -1 });
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => out += c);
+    proc.stderr?.on("data", (c) => err += c);
+    proc.on("error", () => resolve3({ stdout: out, stderr: err || "spawn error", exitCode: -1 }));
+    proc.on("exit", (code) => resolve3({ stdout: out, stderr: err, exitCode: code ?? -1 }));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, timeoutMs);
+  });
+}
+async function createPR(args) {
+  const root = workspaceRoot();
+  const isRepo = await run("git", ["rev-parse", "--is-inside-work-tree"], root);
+  if (!isRepo.exitCode || isRepo.stdout.trim() !== "true") {
+    return {
+      error: "not_a_git_repo",
+      hint: "Initialize git first (run_command 'git init') and commit something before opening a PR."
+    };
+  }
+  const ghVer = await run("gh", ["--version"], root, 5e3);
+  if (ghVer.exitCode !== 0) {
+    return {
+      error: "gh_not_installed",
+      hint: "Install GitHub CLI: winget install GitHub.cli  (or visit https://cli.github.com). Then run `gh auth login`."
+    };
+  }
+  const ghAuth = await run("gh", ["auth", "status"], root, 5e3);
+  if (ghAuth.exitCode !== 0) {
+    return {
+      error: "gh_not_authenticated",
+      hint: "Run `gh auth login` in a terminal, then retry.",
+      stderr: ghAuth.stderr.slice(0, 400)
+    };
+  }
+  const br = await run("git", ["branch", "--show-current"], root);
+  const branch = br.stdout.trim();
+  if (!branch) {
+    return { error: "detached_head", hint: "Repo is in detached HEAD \u2014 checkout a branch first." };
+  }
+  if (PROTECTED_BRANCHES.has(branch.toLowerCase())) {
+    return {
+      error: "on_protected_branch",
+      branch,
+      hint: `You're on '${branch}'. Create a feature branch first: run_command 'git checkout -b feat/my-change'.`
+    };
+  }
+  const ahead = await run("git", ["status", "--porcelain"], root);
+  const hasUncommitted = ahead.stdout.trim().length > 0;
+  const push = await run("git", ["push", "-u", "origin", branch], root, 6e4);
+  if (push.exitCode !== 0) {
+    return {
+      error: "git_push_failed",
+      branch,
+      stderr: push.stderr.slice(0, 400),
+      hint: "Check remote 'origin' is configured and you can push."
+    };
+  }
+  const base = args.base_branch || "main";
+  const prArgs = [
+    "pr",
+    "create",
+    "--title",
+    args.title,
+    "--body",
+    args.body,
+    "--base",
+    base,
+    "--head",
+    branch
+  ];
+  if (args.draft) prArgs.push("--draft");
+  const created = await run("gh", prArgs, root, 3e4);
+  if (created.exitCode !== 0) {
+    return {
+      error: "gh_pr_create_failed",
+      branch,
+      base_branch: base,
+      stderr: created.stderr.slice(0, 400),
+      stdout: created.stdout.slice(0, 200)
+    };
+  }
+  const url = (created.stdout.match(/https:\/\/github\.com\/[^\s]+/) || [""])[0];
+  const numMatch = url.match(/\/pull\/(\d+)/);
+  return {
+    pr_url: url,
+    pr_number: numMatch ? parseInt(numMatch[1], 10) : null,
+    branch,
+    base_branch: base,
+    draft: !!args.draft,
+    had_uncommitted: hasUncommitted
+  };
+}
+
+// src/executors/selfEval.ts
+var fs4 = __toESM(require("node:fs/promises"));
+var MAX_FILES = 20;
+var MAX_FILE_BYTES2 = 4e4;
+var MAX_TOTAL_BYTES = 2e5;
+async function agentSelfEval(args, settings) {
+  const files = (args.files || []).slice(0, MAX_FILES);
+  const contents = {};
+  let total = 0;
+  let truncated = false;
+  for (const rel of files) {
+    let abs;
+    try {
+      abs = resolveInWorkspace(rel);
+    } catch {
+      contents[rel] = "[error: path out of workspace]";
+      continue;
+    }
+    try {
+      const stat5 = await fs4.stat(abs);
+      if (!stat5.isFile()) {
+        contents[rel] = "[skipped: not a file]";
+        continue;
+      }
+      let text = await fs4.readFile(abs, "utf-8");
+      if (text.length > MAX_FILE_BYTES2) {
+        text = text.slice(0, MAX_FILE_BYTES2) + "\n\u2026[truncated]";
+        truncated = true;
+      }
+      if (total + text.length > MAX_TOTAL_BYTES) {
+        contents[rel] = "[skipped: total payload size limit reached]";
+        truncated = true;
+        continue;
+      }
+      contents[rel] = text;
+      total += text.length;
+    } catch (err) {
+      contents[rel] = `[error reading: ${err?.code || err?.message || "unknown"}]`;
+    }
+  }
+  const url = `${settings.backendUrl}/code-workspace/self-eval`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${settings.authBearer}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        stack_hint: settings.stackHint,
+        files,
+        summary: args.summary,
+        file_contents: contents,
+        // Reuse the workspace LLM creds — grader uses the same backend
+        provider: settings.provider,
+        model: settings.model,
+        base_url: settings.baseUrl
+      })
+    });
+    if (!res.ok) {
+      return { skipped: true, verdict: `backend ${res.status}: ${await res.text().catch(() => "")}` };
+    }
+    const result = await res.json();
+    if (truncated) result.payload_truncated = true;
+    return result;
+  } catch (err) {
+    return { skipped: true, verdict: `client fetch failed: ${err?.message || String(err)}` };
+  }
+}
+
+// src/executors/prComments.ts
+var import_node_child_process7 = require("node:child_process");
+async function gh(args, cwd, timeoutMs = 3e4) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process7.spawn)("gh", args, { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      return resolve3({ ok: false, stdout: "", stderr: e?.message || "spawn failed", exitCode: -1 });
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => out += c);
+    proc.stderr?.on("data", (c) => err += c);
+    proc.on("error", () => resolve3({ ok: false, stdout: out, stderr: err || "spawn error", exitCode: -1 }));
+    proc.on("exit", (code) => resolve3({ ok: code === 0, stdout: out, stderr: err, exitCode: code ?? -1 }));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, timeoutMs);
+  });
+}
+async function ghAvailable(cwd) {
+  const ver = await gh(["--version"], cwd, 5e3);
+  if (!ver.ok) return {
+    ok: false,
+    reason: "gh_not_installed",
+    hint: "Install GitHub CLI: winget install GitHub.cli  (or https://cli.github.com)"
+  };
+  const auth = await gh(["auth", "status"], cwd, 5e3);
+  if (!auth.ok) return {
+    ok: false,
+    reason: "gh_not_authenticated",
+    hint: "Run `gh auth login` in a terminal, then retry."
+  };
+  return { ok: true };
+}
+async function readPRComments(args) {
+  const root = workspaceRoot();
+  const ghCheck = await ghAvailable(root);
+  if (!ghCheck.ok) return ghCheck;
+  const prId = args.pr != null ? String(args.pr) : "";
+  const viewArgs = ["pr", "view"];
+  if (prId) viewArgs.push(prId);
+  viewArgs.push("--json", "number,title,state,url,comments,reviews");
+  const r = await gh(viewArgs, root, 2e4);
+  if (!r.ok) {
+    return {
+      error: "gh_pr_view_failed",
+      stderr: r.stderr.slice(0, 400),
+      hint: prId ? `Check PR #${prId} exists.` : "No PR found for the current branch \u2014 pass `pr` explicitly or open a PR first."
+    };
+  }
+  let data;
+  try {
+    data = JSON.parse(r.stdout);
+  } catch {
+    return { error: "gh_output_not_json", stdout: r.stdout.slice(0, 300) };
+  }
+  const max = Math.min(args.max_comments ?? 50, 200);
+  const flat = [];
+  for (const c of data.comments || []) {
+    flat.push({
+      kind: "issue_comment",
+      author: c.author?.login || "(unknown)",
+      body: c.body || "",
+      created_at: c.createdAt || ""
+    });
+  }
+  for (const rv of data.reviews || []) {
+    flat.push({
+      kind: "review",
+      author: rv.author?.login || "(unknown)",
+      body: rv.body || "",
+      created_at: rv.submittedAt || "",
+      review_id: rv.id,
+      review_state: rv.state
+      // APPROVED / CHANGES_REQUESTED / COMMENTED
+    });
+    for (const ic of rv.comments || []) {
+      flat.push({
+        kind: "review_comment",
+        author: ic.author?.login || rv.author?.login || "(unknown)",
+        body: ic.body || "",
+        created_at: ic.createdAt || rv.submittedAt || "",
+        path: ic.path,
+        line: ic.line ?? ic.originalLine,
+        review_id: rv.id,
+        review_state: rv.state
+      });
+    }
+  }
+  flat.sort((a, b) => (b.created_at || "").localeCompare(a.created_at || ""));
+  return {
+    pr_number: data.number,
+    pr_title: data.title,
+    pr_state: data.state,
+    pr_url: data.url,
+    total_comments: flat.length,
+    comments: flat.slice(0, max),
+    truncated: flat.length > max
+  };
+}
+async function replyPRComment(args) {
+  const root = workspaceRoot();
+  const ghCheck = await ghAvailable(root);
+  if (!ghCheck.ok) return ghCheck;
+  if (!args.body || typeof args.body !== "string" || args.body.trim().length === 0) {
+    return { error: "empty_body", hint: "Provide a non-empty body." };
+  }
+  const prArg = args.pr != null ? String(args.pr) : "";
+  const cmd = ["pr", "comment"];
+  if (prArg) cmd.push(prArg);
+  cmd.push("--body", args.body);
+  const r = await gh(cmd, root, 2e4);
+  if (!r.ok) {
+    return {
+      error: "gh_pr_comment_failed",
+      stderr: r.stderr.slice(0, 400),
+      hint: "Confirm the PR exists and you have write access. For thread replies (not just top-level), use create_pr_review_reply (TBD)."
+    };
+  }
+  const url = (r.stdout.match(/https:\/\/github\.com\/[^\s]+/) || [""])[0];
+  return { posted: true, comment_url: url, pr: prArg || "current-branch" };
+}
+
+// src/executors/applyDiff.ts
+var fs5 = __toESM(require("node:fs/promises"));
+async function applyDiff(args, rb) {
+  const abs = resolveInWorkspace(args.path);
+  const baseResult = {
+    path: args.path,
+    applied: false,
+    hunks_total: 0,
+    hunks_applied: 0,
+    hunks_failed: 0,
+    per_hunk: []
+  };
+  if (typeof args.diff !== "string" || !args.diff.trim()) {
+    return { ...baseResult, hint: "empty diff" };
+  }
+  let content;
+  let isNewFile = false;
+  try {
+    content = await fs5.readFile(abs, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      content = "";
+      isNewFile = true;
+    } else return { ...baseResult, hint: `${err.code}: ${err.message}` };
+  }
+  let hunks;
+  try {
+    hunks = _parseUnifiedDiff(args.diff);
+  } catch (err) {
+    return { ...baseResult, hint: `parse error: ${err.message}` };
+  }
+  baseResult.hunks_total = hunks.length;
+  if (hunks.length === 0) {
+    return { ...baseResult, hint: "no @@ hunk headers found in diff" };
+  }
+  const rollback_token = await rb.snapshot(abs);
+  let lines = content === "" && isNewFile ? [] : content.split(/\r?\n/);
+  const endsWithNewline = content.endsWith("\n") || content.endsWith("\r\n");
+  const sortedHunks = hunks.map((h, i) => ({ h, originalIndex: i })).sort((a, b) => b.h.oldStart - a.h.oldStart);
+  for (const { h, originalIndex } of sortedHunks) {
+    const apply = _applyOneHunk(lines, h);
+    if (apply.applied) {
+      lines = apply.lines;
+      baseResult.per_hunk.push({
+        index: originalIndex,
+        applied: true,
+        method: apply.method
+      });
+      baseResult.hunks_applied++;
+    } else {
+      baseResult.per_hunk.push({
+        index: originalIndex,
+        applied: false,
+        reason: apply.reason,
+        closest_match: apply.closest_match
+      });
+      baseResult.hunks_failed++;
+    }
+  }
+  baseResult.per_hunk.sort((a, b) => a.index - b.index);
+  if (baseResult.hunks_failed === baseResult.hunks_total) {
+    return {
+      ...baseResult,
+      rollback_token,
+      hint: "no hunks could be applied \u2014 read the file and retry with fresh context"
+    };
+  }
+  const next = lines.join("\n") + (endsWithNewline && lines.length > 0 ? "\n" : "");
+  if (isNewFile) {
+    const path9 = await import("node:path");
+    await fs5.mkdir(path9.dirname(abs), { recursive: true });
+  }
+  await fs5.writeFile(abs, next, "utf-8");
+  baseResult.applied = baseResult.hunks_failed === 0;
+  baseResult.rollback_token = rollback_token;
+  if (baseResult.hunks_failed > 0) {
+    baseResult.hint = `${baseResult.hunks_failed}/${baseResult.hunks_total} hunks failed \u2014 file partially patched. Inspect per_hunk + retry the failed ones (or apply_diff a fresh diff against the new state).`;
+  }
+  return baseResult;
+}
+function _parseUnifiedDiff(diff) {
+  const hunks = [];
+  const rawLines = diff.split(/\r?\n/);
+  let i = 0;
+  while (i < rawLines.length && (rawLines[i].startsWith("---") || rawLines[i].startsWith("+++"))) {
+    i++;
+  }
+  const hunkHeader = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/;
+  while (i < rawLines.length) {
+    const m = hunkHeader.exec(rawLines[i]);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const oldStart = parseInt(m[1], 10);
+    i++;
+    const startBody = i;
+    while (i < rawLines.length && !rawLines[i].startsWith("@@")) i++;
+    const body = rawLines.slice(startBody, i);
+    const oldLines = [];
+    const newLines = [];
+    for (const ln of body) {
+      if (ln.startsWith("\\ ")) continue;
+      if (ln.length === 0) {
+        oldLines.push("");
+        newLines.push("");
+      } else if (ln[0] === " ") {
+        oldLines.push(ln.slice(1));
+        newLines.push(ln.slice(1));
+      } else if (ln[0] === "-") {
+        oldLines.push(ln.slice(1));
+      } else if (ln[0] === "+") {
+        newLines.push(ln.slice(1));
+      }
+    }
+    hunks.push({ oldStart, oldLines, newLines, raw: rawLines.slice(startBody - 1, i).join("\n") });
+  }
+  return hunks;
+}
+function _applyOneHunk(lines, h) {
+  const N = h.oldLines.length;
+  if (N === 0) {
+    const at = Math.max(0, Math.min(h.oldStart - 1, lines.length));
+    return {
+      applied: true,
+      method: "exact_at_line",
+      lines: [...lines.slice(0, at), ...h.newLines, ...lines.slice(at)]
+    };
+  }
+  const matchesAt = (start, flex) => {
+    if (start < 0 || start + N > lines.length) return false;
+    for (let j = 0; j < N; j++) {
+      const a = lines[start + j], b = h.oldLines[j];
+      if (flex) {
+        if (a.trim() !== b.trim()) return false;
+      } else {
+        if (a !== b) return false;
+      }
+    }
+    return true;
+  };
+  const exactAt = h.oldStart - 1;
+  if (matchesAt(exactAt, false)) {
+    return {
+      applied: true,
+      method: "exact_at_line",
+      lines: [...lines.slice(0, exactAt), ...h.newLines, ...lines.slice(exactAt + N)]
+    };
+  }
+  for (let i = 0; i <= lines.length - N; i++) {
+    if (matchesAt(i, false)) {
+      return {
+        applied: true,
+        method: "exact_anywhere",
+        lines: [...lines.slice(0, i), ...h.newLines, ...lines.slice(i + N)]
+      };
+    }
+  }
+  for (let i = 0; i <= lines.length - N; i++) {
+    if (matchesAt(i, true)) {
+      return {
+        applied: true,
+        method: "fuzzy_whitespace",
+        lines: [...lines.slice(0, i), ...h.newLines, ...lines.slice(i + N)]
+      };
+    }
+  }
+  let bestScore = -1, bestStart = -1;
+  for (let i = 0; i <= lines.length - N; i++) {
+    let matches = 0;
+    for (let j = 0; j < N; j++) {
+      if (lines[i + j].trim() === h.oldLines[j].trim()) matches++;
+    }
+    if (matches > bestScore) {
+      bestScore = matches;
+      bestStart = i;
+    }
+  }
+  const cm = bestStart >= 0 ? {
+    start_line: bestStart + 1,
+    similarity: Math.round(bestScore / N * 100),
+    actual: lines.slice(bestStart, bestStart + N).join("\n")
+  } : void 0;
+  return {
+    applied: false,
+    reason: `hunk old-block not found (claimed line ${h.oldStart}, ${N} lines)`,
+    closest_match: cm
+  };
+}
+
+// src/executors/extras.ts
+var import_node_child_process8 = require("node:child_process");
+var fs6 = __toESM(require("node:fs/promises"));
+async function git(args, cwd, timeoutMs = 2e4) {
+  return new Promise((resolve3) => {
+    let proc;
+    try {
+      proc = (0, import_node_child_process8.spawn)("git", args, { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      return resolve3({ ok: false, stdout: "", stderr: e?.message || "spawn failed" });
+    }
+    let out = "", err = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (c) => out += c);
+    proc.stderr?.on("data", (c) => err += c);
+    proc.on("error", () => resolve3({ ok: false, stdout: out, stderr: err }));
+    proc.on("exit", (code) => resolve3({ ok: code === 0, stdout: out, stderr: err }));
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {
+      }
+    }, timeoutMs);
+  });
+}
+async function gitDiffSummary(args) {
+  const root = workspaceRoot();
+  const isRepo = await git(["rev-parse", "--is-inside-work-tree"], root, 5e3);
+  if (!isRepo.ok || isRepo.stdout.trim() !== "true") {
+    return {
+      error: "not_a_git_repo",
+      hint: "git init this workspace first, or run from a folder that's tracked."
+    };
+  }
+  const baseArgs = ["diff"];
+  if (args.base) baseArgs.push(args.base);
+  if (args.head) baseArgs.push(args.head);
+  const pathArgs = args.paths && args.paths.length ? ["--", ...args.paths] : [];
+  const stat5 = await git([...baseArgs, "--stat", ...pathArgs], root, 3e4);
+  if (!stat5.ok) {
+    return { error: "git_diff_stat_failed", stderr: stat5.stderr.slice(0, 400) };
+  }
+  const lastLine = stat5.stdout.trim().split(/\r?\n/).pop() || "";
+  const filesM = /(\d+)\s+files?\s+changed/.exec(lastLine);
+  const insM = /(\d+)\s+insertions?\(\+\)/.exec(lastLine);
+  const delM = /(\d+)\s+deletions?\(-\)/.exec(lastLine);
+  const stat_summary = {
+    files_changed: filesM ? parseInt(filesM[1], 10) : 0,
+    lines_added: insM ? parseInt(insM[1], 10) : 0,
+    lines_removed: delM ? parseInt(delM[1], 10) : 0
+  };
+  if (args.stat_only) {
+    return { stat: stat5.stdout, ...stat_summary, raw_diff: null };
+  }
+  const diff = await git([...baseArgs, ...pathArgs], root, 3e4);
+  if (!diff.ok) {
+    return { error: "git_diff_failed", stderr: diff.stderr.slice(0, 400), stat: stat5.stdout, ...stat_summary };
+  }
+  const diffLines = diff.stdout.split(/\r?\n/);
+  const truncated = diffLines.length > 2e4;
+  const raw = truncated ? diffLines.slice(0, 2e4).join("\n") + "\n... [truncated; pass narrower paths]" : diff.stdout;
+  return { stat: stat5.stdout, ...stat_summary, raw_diff: raw, truncated };
+}
+async function readPDF(args, settings) {
+  const abs = resolveInWorkspace(args.path);
+  let bytes;
+  try {
+    bytes = await fs6.readFile(abs);
+  } catch (err) {
+    return { error: err.code || "ENOENT", path: args.path, message: err.message };
+  }
+  if (bytes.length > 50 * 1024 * 1024) {
+    return {
+      error: "file_too_large",
+      size_bytes: bytes.length,
+      hint: "PDF > 50MB; split or convert before reading."
+    };
+  }
+  const b64 = bytes.toString("base64");
+  const url = `${settings.backendUrl}/code-workspace/read-pdf`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${settings.authBearer}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ filename: args.path, content_b64: b64 })
+    });
+    if (!res.ok) {
+      return { error: `backend ${res.status}: ${await res.text().catch(() => "")}` };
+    }
+    const out = await res.json();
+    return { path: args.path, ...out };
+  } catch (err) {
+    return { error: `client fetch failed: ${err?.message || String(err)}`, path: args.path };
+  }
+}
+async function runPythonREPL(args, settings) {
+  const url = `${settings.backendUrl}/code-workspace/python-repl`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${settings.authBearer}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        code: args.code,
+        session_id: args.session_id,
+        timeout_s: args.timeout_s ?? 30
+      })
+    });
+    if (!res.ok) {
+      return { error: `backend ${res.status}: ${await res.text().catch(() => "")}` };
+    }
+    return await res.json();
+  } catch (err) {
+    return { error: `client fetch failed: ${err?.message || String(err)}` };
+  }
+}
+
+// src/executors/mounts.ts
+var fs7 = __toESM(require("node:fs/promises"));
+var path5 = __toESM(require("node:path"));
+var _PROTECTED_PREFIXES = [
+  "/etc",
+  "/usr/bin",
+  "/usr/sbin",
+  "/bin",
+  "/sbin",
+  "/sys",
+  "/proc",
+  "/dev",
+  "C:\\Windows",
+  "C:\\Program Files",
+  "C:\\Program Files (x86)",
+  "C:\\ProgramData"
+];
+function isProtectedHost(abs) {
+  const norm = abs.replace(/\\/g, "/").toLowerCase();
+  for (const p of _PROTECTED_PREFIXES) {
+    const n = p.replace(/\\/g, "/").toLowerCase();
+    if (norm === n || norm.startsWith(n + "/")) return p;
+  }
+  return null;
+}
+async function mountExternalFolder(args, state, opts) {
+  const raw = (args.path || "").trim();
+  if (!raw) return { ok: false, error: "empty path" };
+  const purpose = (args.purpose || "").trim();
+  const abs = path5.resolve(raw);
+  const proto = isProtectedHost(abs);
+  if (proto) {
+    return {
+      ok: false,
+      error: "protected_host_dir",
+      refused: proto,
+      hint: "system directories are never mountable"
+    };
+  }
+  try {
+    const st = await fs7.stat(abs);
+    if (!st.isDirectory()) {
+      return { ok: false, error: "not_a_directory", path: abs };
+    }
+  } catch (err) {
+    return { ok: false, error: "stat_failed", path: abs, message: err?.message || String(err) };
+  }
+  if (state.mountedFolders.has(abs)) {
+    return { ok: true, already_mounted: true, path: abs, mode: "read-only" };
+  }
+  if (!opts?.autoApprove) {
+    let vscode = null;
+    try {
+      vscode = require("vscode");
+    } catch {
+    }
+    if (vscode) {
+      const choice = await vscode.window.showWarningMessage(
+        `Allow the agent READ-ONLY access to:
+${abs}
+
+Purpose: ${purpose || "(none given)"}
+
+Only first mount of each path prompts.`,
+        { modal: true },
+        "Allow",
+        "Deny"
+      );
+      if (choice !== "Allow") {
+        return { ok: false, error: "user_denied", path: abs };
+      }
+    }
+  }
+  state.mountedFolders.add(abs);
+  return {
+    ok: true,
+    mounted: abs,
+    mode: "read-only",
+    purpose,
+    note: "subsequent read_file / list_dir / glob / grep can now target absolute paths under this folder",
+    total_mounted: state.mountedFolders.size
+  };
+}
+
+// src/executors/datasets.ts
+var path6 = __toESM(require("node:path"));
+var fs8 = __toESM(require("node:fs/promises"));
+var import_node_child_process9 = require("node:child_process");
+function sanitize(name) {
+  return name.replace(/[/\\:?"<>|*]/g, "_").replace(/_+/g, "_").slice(0, 80);
+}
+async function which(cmd) {
+  return new Promise((resolve3) => {
+    const probe = (0, import_node_child_process9.spawn)(process.platform === "win32" ? "where" : "which", [cmd], { shell: false });
+    let found = false;
+    probe.stdout?.on("data", () => {
+      found = true;
+    });
+    probe.on("close", (code) => resolve3(found && code === 0));
+    probe.on("error", () => resolve3(false));
+  });
+}
+function defaultDest(source, name) {
+  return `.datasets/${source}-${sanitize(name)}`;
+}
+function buildCommand(source, name, dest, kind) {
+  switch (source) {
+    case "huggingface": {
+      const tier = kind === "model" ? "" : "--repo-type dataset";
+      return {
+        command: `huggingface-cli download ${tier} ${name} --local-dir ${JSON.stringify(dest)} --local-dir-use-symlinks False`,
+        pre_check: "huggingface-cli"
+      };
+    }
+    case "kaggle":
+      return {
+        command: `kaggle datasets download -d ${name} -p ${JSON.stringify(dest)} --unzip`,
+        pre_check: "kaggle"
+      };
+    case "github": {
+      const url = name.startsWith("http") ? name : `https://github.com/${name}.git`;
+      return {
+        command: `git clone --depth=1 ${url} ${JSON.stringify(dest)}`,
+        pre_check: "git"
+      };
+    }
+    case "url": {
+      const filename = name.split("/").pop() || "download";
+      const safe = sanitize(filename);
+      return {
+        command: process.platform === "win32" ? `curl -L -o ${JSON.stringify(path6.join(dest, safe))} ${JSON.stringify(name)}` : `mkdir -p ${JSON.stringify(dest)} && curl -L -o ${JSON.stringify(path6.join(dest, safe))} ${JSON.stringify(name)}`,
+        pre_check: "curl"
+      };
+    }
+  }
+}
+async function downloadDataset(args, settings) {
+  const source = args.source;
+  const name = (args.name_or_url || "").trim();
+  if (!name) return { ok: false, error: "name_or_url is empty" };
+  if (!["huggingface", "kaggle", "github", "url"].includes(source)) {
+    return { ok: false, error: `unknown source ${JSON.stringify(source)}` };
+  }
+  const dest = args.dest_path?.trim() || defaultDest(source, name);
+  let destAbs;
+  try {
+    destAbs = resolveInWorkspace(dest);
+  } catch (err) {
+    return { ok: false, error: "dest_path outside workspace", message: err?.message };
+  }
+  try {
+    await fs8.mkdir(destAbs, { recursive: true });
+  } catch (err) {
+    return { ok: false, error: "mkdir_failed", message: err?.message };
+  }
+  const { command, pre_check } = buildCommand(source, name, destAbs, args.kind);
+  if (pre_check) {
+    const ok = await which(pre_check);
+    if (!ok) {
+      const installHint = {
+        "huggingface-cli": "pip install huggingface_hub",
+        "kaggle": "pip install kaggle  (and put your kaggle.json in ~/.kaggle/)",
+        "git": "install git",
+        "curl": "install curl"
+      }[pre_check] || "install the missing tool";
+      return {
+        ok: false,
+        error: "tool_not_found",
+        missing: pre_check,
+        install_hint: installHint,
+        would_have_run: command
+      };
+    }
+  }
+  const taskRes = await startBackgroundTask(
+    {
+      command,
+      cwd: workspaceRoot(),
+      label: `download:${source}:${sanitize(name).slice(0, 40)}`
+    },
+    settings
+  );
+  return {
+    ok: true,
+    source,
+    name,
+    dest_path: dest,
+    dest_abs: destAbs,
+    command_running: command,
+    task_id: taskRes?.task_id || taskRes?.id || null,
+    note: "download running as background task \u2014 use check_background_task to poll progress",
+    task_info: taskRes
+  };
+}
+
+// src/executors/index.ts
+var WRITES = /* @__PURE__ */ new Set(["write_file", "edit_file", "apply_diff"]);
+var SHELLS = /* @__PURE__ */ new Set(["run_command"]);
+var LOCAL_PLANE_LIFECYCLE = /* @__PURE__ */ new Set(["kill_process"]);
+function needsApproval(name, settings) {
+  if (WRITES.has(name) && !settings.autoApproveWrites) return true;
+  if (SHELLS.has(name) && !settings.autoApproveCommands) return true;
+  if (LOCAL_PLANE_LIFECYCLE.has(name) && !settings.autoApproveCommands) return true;
+  return false;
+}
+async function execute(name, args, ctx) {
+  try {
+    switch (name) {
+      // ── Filesystem ─────────────────────────────────────────────
+      case "list_dir":
+        return await listDir(args, ctx.mountedFolders);
+      case "read_file":
+        return await readFile3(args, ctx.mountedFolders);
+      case "write_file":
+        return await writeFile3(args, ctx.rollback);
+      case "edit_file":
+        return await editFile(args, ctx.rollback);
+      case "apply_diff":
+        return await applyDiff(args, ctx.rollback);
+      case "glob":
+        return await glob(args, ctx.mountedFolders);
+      case "grep":
+        return await grep(args, ctx.mountedFolders);
+      // ── Shell ─────────────────────────────────────────────────
+      case "run_command":
+        return await runCommand(args, ctx.registry, ctx.signal);
+      // ── Local Environment Plane ────────────────────────────────
+      case "system_info":
+        return await systemInfo(args);
+      case "list_processes":
+        return listProcesses(args, ctx.registry);
+      case "allocate_port":
+        return await allocatePort(args);
+      case "kill_process":
+        return await killProcess(args, ctx.registry);
+      case "verify_package":
+        return await verifyPackage(args, ctx.settings);
+      case "verify_package_batch":
+        return await verifyPackageBatch(args, ctx.settings);
+      case "web_search":
+        return await webSearch(args, ctx.settings);
+      case "gpu_info":
+        return await gpuInfo(args, ctx.settings);
+      case "start_background_task":
+        return await startBackgroundTask(args, ctx.settings);
+      case "check_background_task":
+        return await checkBackgroundTask(args, ctx.settings);
+      case "list_background_tasks":
+        return await listBackgroundTasks(args, ctx.settings);
+      case "cancel_background_task":
+        return await cancelBackgroundTask(args, ctx.settings);
+      case "run_lint":
+        return await runLint(args);
+      case "create_pr":
+        return await createPR(args);
+      case "read_pr_comments":
+        return await readPRComments(args);
+      case "format_file":
+        return await runFormat(args);
+      case "reply_pr_comment":
+        return await replyPRComment(args);
+      case "agent_self_eval":
+        return await agentSelfEval(args, ctx.settings);
+      case "git_diff_summary":
+        return await gitDiffSummary(args);
+      case "read_pdf":
+        return await readPDF(args, ctx.settings);
+      case "run_python_repl":
+        return await runPythonREPL(args, ctx.settings);
+      case "mount_external_folder":
+        return await mountExternalFolder(
+          args,
+          { mountedFolders: ctx.mountedFolders },
+          { autoApprove: ctx.settings.autoApproveCommands }
+        );
+      case "download_dataset":
+        return await downloadDataset(args, ctx.settings);
+      // ── Unknown ───────────────────────────────────────────────
+      default:
+        return {
+          error: "unknown_tool",
+          name,
+          note: "Server schema and client dispatcher are out of sync. Update src/executors/index.ts."
+        };
+    }
+  } catch (err) {
+    return {
+      error: err?.code || err?.name || "ExecutorError",
+      message: err?.message || String(err),
+      tool: name
+    };
+  }
+}
+
+// src/gitCheckpoint.ts
+var import_node_child_process10 = require("node:child_process");
+var GitCheckpoint = class {
+  constructor(workspaceRoot3) {
+    this.workspaceRoot = workspaceRoot3;
+  }
+  status = { active: false };
+  /** Paths the agent wrote/edited this session, normalized to workspace-
+   *  relative forward-slash form. Used as the commit add whitelist. */
+  agentPaths = /* @__PURE__ */ new Set();
+  /** Snapshot of `git status --porcelain` at init. Files here that the
+   *  agent does NOT touch are reported as "preserved" at session end. */
+  preExistingDirty = [];
+  /** Probe + initialize. Call once per session, before the first tool call. */
+  async init() {
+    if (!await this.isGitRepo()) {
+      this.status = { active: false, reason: "not a git repository" };
+      return this.status;
+    }
+    const stat5 = await this.run(["status", "--porcelain", "-z"]);
+    if (stat5.success && stat5.stdout) {
+      this.preExistingDirty = stat5.stdout.split("\0").filter((x) => x.length > 3).map((x) => x.slice(3));
+    }
+    const headRes = await this.run(["rev-parse", "HEAD"]);
+    const startSha = headRes.stdout.trim();
+    if (!startSha) {
+      this.status = { active: false, reason: "git rev-parse HEAD failed (empty repo?)" };
+      return this.status;
+    }
+    this.status = { active: true, startedAtSha: startSha };
+    return this.status;
+  }
+  /** Tool-call loop reports each successful write/edit here. Paths are
+   *  normalized to workspace-relative + forward slashes. Safe to call with
+   *  absolute paths, ./-prefixed paths, or backslashes. */
+  recordWrite(p) {
+    if (!this.status.active || !p || typeof p !== "string") return;
+    let rel = p.replace(/\\/g, "/");
+    const ws = this.workspaceRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (rel.startsWith(ws + "/")) rel = rel.slice(ws.length + 1);
+    rel = rel.replace(/^\.\/+/, "");
+    if (rel) this.agentPaths.add(rel);
+  }
+  /** Read-only view of recorded agent paths. */
+  getAgentPaths() {
+    return [...this.agentPaths];
+  }
+  /** Read-only view of files the user had dirty/untracked at init. */
+  getPreExistingDirty() {
+    return [...this.preExistingDirty];
+  }
+  /**
+   * Commit ONLY the paths the agent recorded.
+   * Never uses `git add -A` — user-owned dirty/untracked files are left
+   * exactly where they are.
+   */
+  async commitOnDone(summary) {
+    if (!this.status.active) {
+      return { committed: false, reason: "checkpoint not active" };
+    }
+    const paths = [...this.agentPaths];
+    if (paths.length === 0) {
+      return { committed: false, reason: "no agent writes recorded" };
+    }
+    let unstagedConflicts;
+    const unstagedRes = await this.run(["diff", "--name-only", "--", ...paths]);
+    if (unstagedRes.success) {
+      const names = unstagedRes.stdout.trim().split("\n").filter(Boolean);
+      if (names.length > 0) unstagedConflicts = names;
+    }
+    const addRes = await this.run(["add", "--", ...paths]);
+    if (!addRes.success) {
+      return { committed: false, reason: `git add failed: ${addRes.stderr.trim()}` };
+    }
+    const diff = await this.run(["diff", "--cached", "--name-only"]);
+    if (diff.success && !diff.stdout.trim()) {
+      return { committed: false, reason: "agent writes produced no net change" };
+    }
+    const subject = subjectFromSummary(summary);
+    const body = summary.length > subject.length ? `
+
+${summary}` : "";
+    const commitRes = await this.run([
+      "-c",
+      "user.name=Rscot Agent",
+      "-c",
+      "user.email=agent@code-workspace.local",
+      "commit",
+      "-m",
+      `[rscot] ${subject}${body}`
+    ]);
+    if (!commitRes.success) {
+      return { committed: false, reason: `git commit failed: ${commitRes.stderr.trim()}` };
+    }
+    const sha = (await this.run(["rev-parse", "HEAD"])).stdout.trim();
+    const addedPaths = diff.success ? diff.stdout.trim().split("\n").filter(Boolean) : paths;
+    const agentSet = new Set(paths);
+    const preserved = this.preExistingDirty.filter((p) => !agentSet.has(p));
+    return { committed: true, sha, addedPaths, preserved, unstagedConflicts };
+  }
+  /**
+   * Hard-reset to session start. Destroys agent commit(s) from this session.
+   * Does NOT touch user's working-tree files — they were never moved.
+   */
+  async revertOnFailure() {
+    if (!this.status.active || !this.status.startedAtSha) {
+      return { reverted: false, reason: "checkpoint not active" };
+    }
+    const reset = await this.run(["reset", "--hard", this.status.startedAtSha]);
+    if (!reset.success) {
+      return { reverted: false, reason: `git reset failed: ${reset.stderr.trim()}` };
+    }
+    return { reverted: true };
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  // ── Internals ───────────────────────────────────────────────────────
+  async isGitRepo() {
+    const r = await this.run(["rev-parse", "--is-inside-work-tree"]);
+    return r.success && r.stdout.trim() === "true";
+  }
+  run(args) {
+    return new Promise((resolve3) => {
+      let out = "", err = "";
+      let proc;
+      try {
+        proc = (0, import_node_child_process10.spawn)("git", args, {
+          cwd: this.workspaceRoot,
+          windowsHide: true,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (e) {
+        return resolve3({ success: false, stdout: "", stderr: e?.message || "spawn failed", exitCode: -1 });
+      }
+      proc.stdout?.setEncoding("utf-8");
+      proc.stderr?.setEncoding("utf-8");
+      proc.stdout?.on("data", (c) => {
+        out += c;
+      });
+      proc.stderr?.on("data", (c) => {
+        err += c;
+      });
+      proc.on("error", () => resolve3({ success: false, stdout: out, stderr: err || "spawn error", exitCode: -1 }));
+      proc.on("exit", (code) => resolve3({ success: code === 0, stdout: out, stderr: err, exitCode: code ?? -1 }));
+      setTimeout(() => {
+        try {
+          proc.kill();
+        } catch {
+        }
+      }, 15e3);
+    });
+  }
+};
+function subjectFromSummary(summary) {
+  const first = (summary.split(/\r?\n/)[0] || "").trim() || "agent edits";
+  return first.length > 72 ? first.slice(0, 69) + "..." : first;
+}
+
+// src/rollback.ts
+var fs9 = __toESM(require("node:fs/promises"));
+var path7 = __toESM(require("node:path"));
+function isScratchPath(absOrRel) {
+  const base = path7.basename(absOrRel);
+  return base.startsWith("_") && !base.startsWith("__");
+}
+var RollbackMap = class {
+  entries = [];
+  counter = 0;
+  /** Per-path inflight guard — refuses concurrent snapshot() for the same
+   *  absolute path so an apply-diff racing a rollback can't push a corrupt
+   *  duplicate entry into the map. */
+  inflightPaths = /* @__PURE__ */ new Set();
+  /** True while restoreAll() is draining entries. snapshot()/clear() are
+   *  rejected during this window to keep the reverse-order invariant. */
+  restoreInFlight = false;
+  /** Snapshot a file's current state, return a rollback token. */
+  async snapshot(absPath) {
+    if (this.restoreInFlight) {
+      throw new Error(`rollback in progress \u2014 refusing snapshot of ${absPath}`);
+    }
+    if (this.inflightPaths.has(absPath)) {
+      throw new Error(`snapshot already in flight for ${absPath}`);
+    }
+    this.inflightPaths.add(absPath);
+    try {
+      const token = `rb_${Date.now().toString(36)}_${this.counter++}`;
+      const scratch = isScratchPath(absPath);
+      let prev = null;
+      if (!scratch) {
+        try {
+          prev = await fs9.readFile(absPath, "utf-8");
+        } catch (e) {
+          if (e?.code !== "ENOENT") throw e;
+        }
+      }
+      this.entries.push({
+        token,
+        path: absPath,
+        previousContent: prev,
+        timestamp: Date.now(),
+        scratch
+      });
+      return token;
+    } finally {
+      this.inflightPaths.delete(absPath);
+    }
+  }
+  /** Restore every snapshot in reverse order. Returns count restored.
+   *  Scratch entries (underscore-prefix files, P5) are skipped — leaving
+   *  them around isn't useful and rolling them back wastes IO. */
+  async restoreAll() {
+    if (this.restoreInFlight) {
+      return { restored: 0, skipped_scratch: 0, errors: ["restoreAll already in progress"] };
+    }
+    this.restoreInFlight = true;
+    try {
+      const errors = [];
+      let restored = 0;
+      let skipped_scratch = 0;
+      for (let i = this.entries.length - 1; i >= 0; i--) {
+        const e = this.entries[i];
+        if (e.scratch) {
+          skipped_scratch++;
+          continue;
+        }
+        try {
+          if (e.previousContent === null) {
+            await fs9.unlink(e.path).catch(() => {
+            });
+          } else {
+            await fs9.writeFile(e.path, e.previousContent, "utf-8");
+          }
+          restored++;
+        } catch (err) {
+          errors.push(`${e.path}: ${err?.message || String(err)}`);
+        }
+      }
+      this.entries = [];
+      return { restored, skipped_scratch, errors };
+    } finally {
+      this.restoreInFlight = false;
+    }
+  }
+  list() {
+    return [...this.entries];
+  }
+  /** Drop the map without restoring (used after a successful `done` commit). */
+  clear() {
+    if (this.restoreInFlight) {
+      throw new Error("clear() refused: restoreAll() in progress");
+    }
+    this.entries = [];
+  }
+  get size() {
+    return this.entries.length;
+  }
+};
+
+// src/cli.ts
+var gNoColor = false;
+var gQuiet = false;
+var gJson = false;
+function parseArgs(argv) {
+  const out = {
+    prompt: "",
+    workspace: process.cwd(),
+    backendUrl: process.env.CWA_BACKEND_URL || "http://localhost:8010",
+    authBearer: (() => {
+      if (process.env.CWA_AUTH_BEARER) return process.env.CWA_AUTH_BEARER;
+      try {
+        return crypto2.randomBytes(8).toString("hex");
+      } catch {
+        return "cli";
+      }
+    })(),
+    apiKey: process.env.CWA_API_KEY || "",
+    provider: process.env.CWA_PROVIDER || "deepseek",
+    model: process.env.CWA_MODEL || "",
+    baseUrl: process.env.CWA_BASE_URL || "",
+    stackHint: process.env.CWA_STACK_HINT || "",
+    autoApprove: true,
+    // CLI is interactive-less; default approve
+    maxIters: 40,
+    temperature: 0.2,
+    gitCheckpoint: true,
+    // session-start stash + on-done commit if git repo
+    persist: true,
+    // save to .rscot/conversations/
+    resume: false,
+    // pick up the last saved conversation
+    resumePrefix: "",
+    stream: false,
+    // Day 21 streaming — opt-in via --stream
+    // Wave 5 defaults
+    json: false,
+    quiet: false,
+    noColor: false,
+    dryRun: false,
+    turnTimeout: 120
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => {
+      i++;
+      return argv[i];
+    };
+    switch (a) {
+      case "--workspace":
+        out.workspace = next();
+        break;
+      case "--backend-url":
+        out.backendUrl = next();
+        break;
+      case "--auth-bearer":
+        out.authBearer = next();
+        break;
+      case "--api-key":
+        out.apiKey = next();
+        break;
+      case "--provider":
+        out.provider = next();
+        break;
+      case "--model":
+        out.model = next();
+        break;
+      case "--base-url":
+        out.baseUrl = next();
+        break;
+      case "--stack-hint":
+        out.stackHint = next();
+        break;
+      case "--no-approve":
+        out.autoApprove = false;
+        break;
+      case "--auto-approve":
+        out.autoApprove = true;
+        break;
+      case "--no-git":
+        out.gitCheckpoint = false;
+        break;
+      case "--no-persist":
+        out.persist = false;
+        break;
+      case "--stream":
+        out.stream = true;
+        break;
+      case "--max-iters":
+        out.maxIters = parseInt(next(), 10);
+        break;
+      case "--temperature":
+        out.temperature = parseFloat(next());
+        break;
+      // ── Wave 5 ──────────────────────────────────────────
+      case "--json":
+        out.json = true;
+        break;
+      case "--quiet":
+        out.quiet = true;
+        break;
+      case "--no-color":
+        out.noColor = true;
+        break;
+      case "--dry-run":
+        out.dryRun = true;
+        break;
+      case "--turn-timeout":
+        out.turnTimeout = parseInt(next(), 10);
+        if (out.turnTimeout < 1) {
+          console.error("--turn-timeout must be >= 1");
+          process.exit(2);
+        }
+        break;
+      case "--resume": {
+        out.resume = true;
+        const peek = argv[i + 1];
+        if (peek !== void 0 && !peek.startsWith("--")) {
+          out.resumePrefix = next();
+        }
+        break;
+      }
+      // ── /Wave 5 ─────────────────────────────────────────
+      case "-h":
+      case "--help":
+        printUsage();
+        process.exit(0);
+        break;
+      default:
+        if (a.startsWith("--")) {
+          console.error(`unknown flag: ${a}`);
+          printUsage();
+          process.exit(2);
+        }
+        rest.push(a);
+    }
+  }
+  if (rest.length > 0 && ["list", "delete", "show"].includes(rest[0])) {
+    out.prompt = rest.join(" ").trim();
+    return out;
+  }
+  out.prompt = rest.join(" ").trim();
+  if (!out.prompt) {
+    console.error("missing prompt");
+    printUsage();
+    process.exit(2);
+  }
+  return out;
+}
+function printUsage() {
+  console.error(`Usage: node dist/cli.js [flags] "<prompt>"
+       node dist/cli.js list
+       node dist/cli.js delete <id>
+       node dist/cli.js show <id>
+
+Flags:
+  --workspace <dir>     workspace root (default: cwd)
+  --backend-url <url>   backend (default: http://localhost:8010 or $CWA_BACKEND_URL)
+  --auth-bearer <t>     LAN-gate token (default: "cli" or $CWA_AUTH_BEARER)
+  --api-key <k>         LLM API key (default: empty \u2192 backend uses its env)
+  --provider <id>       LLM provider: deepseek | openai | anthropic | ollama (default: deepseek or $CWA_PROVIDER)
+  --model <name>        Model name (default: backend picks per provider or $CWA_MODEL)
+  --base-url <url>      Override provider base URL (default: backend's known URL or $CWA_BASE_URL)
+  --stack-hint <s>      knowledge layer stack (fastapi/nextjs/flutter/pytorch/rust_cli)
+  --no-approve          require y/N before writes + run_command (default: auto-approve)
+  --no-git              disable git checkpoint (default: enabled if workspace is a git repo)
+  --no-persist          don't save conversation to .rscot/conversations/
+  --resume [<prefix>]   resume last session; with 8+ hex chars, resume by partial id
+  --stream              use SSE streaming endpoint \u2014 assistant text streams live
+  --max-iters <n>       loop iteration cap (default: 40)
+  --temperature <f>     LLM temperature (default: 0.2)
+  --json                suppress all colored output; emit JSON result at end
+  --quiet               suppress tool-result echoes, keep LLM messages + summary
+  --no-color            disable ANSI color output (overrides TTY auto-detect)
+  --dry-run             print tool calls without executing them, then continue
+  --turn-timeout <s>    per-turn timeout in seconds (default: 120)`);
+}
+function color(code, text) {
+  if (gNoColor || !process.stdout.isTTY) return text;
+  return `\x1B[${code}m${text}\x1B[0m`;
+}
+var cDim = (s) => color("2", s);
+var cBold = (s) => color("1", s);
+var cGreen = (s) => color("32", s);
+var cYellow = (s) => color("33", s);
+var cRed = (s) => color("31", s);
+var cCyan = (s) => color("36", s);
+var cMag = (s) => color("35", s);
+function osc8(url, display) {
+  if (gNoColor || !process.stdout.isTTY) return display;
+  return `\x1B]8;;${url}\x07${display}\x1B]8;;\x07`;
+}
+function fileLink(workspace, p, display) {
+  const abs = path8.isAbsolute(p) ? p : path8.join(workspace, p);
+  let urlPath = abs.replace(/\\/g, "/");
+  if (/^[A-Za-z]:\//.test(urlPath)) urlPath = "/" + urlPath;
+  const url = "file://" + urlPath.split("/").map(encodeURIComponent).join("/").replace(/%2F/g, "/");
+  return osc8(url, display || p);
+}
+function logInfo(...args) {
+  if (gQuiet || gJson) return;
+  console.log(...args);
+}
+function logTool(...args) {
+  if (gJson) return;
+  console.log(...args);
+}
+function log(...args) {
+  if (gJson) return;
+  console.log(...args);
+}
+function emitJsonResult(payload) {
+  const obj = {
+    session_id: payload.session_id ?? null,
+    files_changed: payload.files_changed ?? [],
+    summary: payload.summary ?? "",
+    exit_code: payload.exit_code ?? 0
+  };
+  console.log(JSON.stringify(obj));
+}
+async function cmdList(args) {
+  const convStore = new ConversationStore(args.workspace);
+  const list = await convStore.listAll();
+  if (list.length === 0) {
+    logInfo(cDim("No conversations found."));
+    return;
+  }
+  logInfo(cBold(`${list.length} conversation(s):`));
+  for (const s of list) {
+    const status = s.completed ? cGreen("\u2713") : cYellow("\u2026");
+    logInfo(`  ${status} ${s.session_id}  ${cDim(s.created_at.slice(0, 19))}  ${s.summary}  ${cDim(`(${s.messages_count} msgs)`)}`);
+  }
+}
+async function cmdDelete(args) {
+  const parts = args.prompt.split(/\s+/);
+  if (parts.length < 2) {
+    console.error("Usage: node dist/cli.js delete <id>");
+    process.exit(2);
+  }
+  const prefix = parts[1];
+  const convDir = path8.join(args.workspace, ".rscot", "conversations");
+  const found = await findConversationByPrefix(convDir, prefix);
+  if (found.length === 0) {
+    console.error(`No conversation matching id prefix "${prefix}"`);
+    process.exit(1);
+  }
+  if (found.length > 1) {
+    console.error(`Multiple conversations match "${prefix}": ${found.map((f) => f.id).join(", ")}. Provide more chars.`);
+    process.exit(1);
+  }
+  const { filename, id } = found[0];
+  logInfo(`Conversation to delete: ${id}`);
+  process.stdout.write("Are you sure? [y/N] ");
+  const confirmed = await new Promise((resolve3) => {
+    process.stdin.setEncoding("utf-8");
+    const onData = (chunk) => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      resolve3(chunk.trim().toLowerCase().startsWith("y"));
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+  if (!confirmed) {
+    logInfo(cDim("Delete cancelled."));
+    return;
+  }
+  await fs10.unlink(path8.join(convDir, filename));
+  logInfo(cDim(`Deleted ${id}`));
+}
+async function cmdShow(args) {
+  const parts = args.prompt.split(/\s+/);
+  if (parts.length < 2) {
+    console.error("Usage: node dist/cli.js show <id>");
+    process.exit(2);
+  }
+  const prefix = parts[1];
+  const convDir = path8.join(args.workspace, ".rscot", "conversations");
+  const found = await findConversationByPrefix(convDir, prefix);
+  if (found.length === 0) {
+    console.error(`No conversation matching id prefix "${prefix}"`);
+    process.exit(1);
+  }
+  if (found.length > 1) {
+    console.error(`Multiple conversations match "${prefix}": ${found.map((f) => f.id).join(", ")}. Provide more chars.`);
+    process.exit(1);
+  }
+  const raw = await fs10.readFile(path8.join(convDir, found[0].filename), "utf-8");
+  const session = JSON.parse(raw);
+  logInfo(cBold(`Session: ${session.session_id}`));
+  logInfo(cDim(`Created: ${session.created_at}  |  ${session.messages.length} message(s)  |  ${session.completed ? "completed" : "incomplete"}`));
+  logInfo(cDim(`Summary: ${session.summary}`));
+  logInfo("");
+  for (const msg of session.messages) {
+    const role = msg.role.padEnd(12);
+    if (msg.role === "user") {
+      logInfo(cCyan(`user       > ${(msg.content || "").slice(0, 300)}`));
+    } else if (msg.role === "assistant") {
+      const tc = msg.tool_calls;
+      if (tc && tc.length > 0) {
+        logInfo(cGreen(`assistant  > tool_call: ${tc.map((t) => t.function?.name || "?").join(", ")}`));
+      } else {
+        logInfo(cGreen(`assistant  > ${(msg.content || "").slice(0, 300)}`));
+      }
+    } else if (msg.role === "tool") {
+      logInfo(cDim(`tool       > ${(msg.name || msg.tool_call_id || "?").padEnd(12)} ${(msg.content || "").slice(0, 120)}`));
+    } else {
+      logInfo(cDim(`${role} ${(msg.content || "").slice(0, 120)}`));
+    }
+  }
+}
+async function findConversationByPrefix(convDir, prefix) {
+  let files;
+  try {
+    files = await fs10.readdir(convDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const f of files) {
+    if (!f.endsWith(".json")) continue;
+    const lastUnderscore = f.lastIndexOf("_");
+    if (lastUnderscore === -1) continue;
+    const id = f.slice(lastUnderscore + 1, -5);
+    if (id.startsWith(prefix)) {
+      results.push({ filename: f, id });
+    }
+  }
+  return results;
+}
+async function ensureWorkspace(dir) {
+  await fs10.mkdir(dir, { recursive: true });
+  setWorkspaceRoot(dir);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  gNoColor = args.noColor;
+  gQuiet = args.quiet;
+  gJson = args.json;
+  const subcmd = args.prompt.split(/\s+/)[0];
+  if (subcmd === "list") {
+    await cmdList(args);
+    return;
+  }
+  if (subcmd === "delete") {
+    await cmdDelete(args);
+    return;
+  }
+  if (subcmd === "show") {
+    await cmdShow(args);
+    return;
+  }
+  await ensureWorkspace(args.workspace);
+  log(cBold("\u2500\u2500\u2500 Rscot Agent (CLI) \u2500\u2500\u2500"));
+  log(`${cDim("workspace:")}  ${args.workspace}`);
+  log(`${cDim("backend:")}    ${args.backendUrl}`);
+  log(`${cDim("auth:")}     ${args.authBearer.slice(0, 8)}... ${process.env.CWA_AUTH_BEARER ? "(env)" : "(random per-process)"}`);
+  log(`${cDim("provider:")}   ${args.provider}${args.model ? ` \xB7 ${args.model}` : " \xB7 (default model)"}`);
+  log(`${cDim("stack hint:")} ${args.stackHint || "(none)"}`);
+  log(`${cDim("approve:")}    ${args.autoApprove ? "auto" : "prompt"}`);
+  if (args.dryRun) log(`${cYellow("dry-run:")}   enabled`);
+  log(`${cDim("prompt:")}     ${args.prompt}`);
+  log();
+  const settings = {
+    backendUrl: args.backendUrl,
+    authBearer: args.authBearer,
+    provider: args.provider,
+    model: args.model,
+    baseUrl: args.baseUrl,
+    stackHint: args.stackHint,
+    autoApproveWrites: args.autoApprove,
+    autoApproveCommands: args.autoApprove,
+    temperature: args.temperature,
+    accentColor: "#d97757"
+    // CLI has no UI — kept for type completeness
+  };
+  const client = new ApiClient(settings, args.apiKey);
+  const registry = new RollbackMap();
+  const procRegistry = new ProcessRegistry();
+  const cliMountedFolders = /* @__PURE__ */ new Set();
+  const checkpoint = new GitCheckpoint(args.workspace);
+  if (args.gitCheckpoint) {
+    const status = await checkpoint.init();
+    if (status.active) {
+      const dirty = checkpoint.getPreExistingDirty();
+      log(cDim(`git checkpoint: active (start ${status.startedAtSha?.slice(0, 7)}, ${dirty.length} pre-existing dirty/untracked file${dirty.length === 1 ? "" : "s"} preserved)`));
+    } else {
+      log(cDim(`git checkpoint: off (${status.reason || "not active"})`));
+    }
+  }
+  const convStore = new ConversationStore(args.workspace);
+  let history = [];
+  let resumedFrom = null;
+  if (args.resume) {
+    let session = null;
+    if (args.resumePrefix) {
+      if (args.resumePrefix.length < 8) {
+        console.error(`--resume prefix must be 8+ hex chars (got "${args.resumePrefix}")`);
+        process.exit(2);
+      }
+      const convDir = path8.join(args.workspace, ".rscot", "conversations");
+      const found = await findConversationByPrefix(convDir, args.resumePrefix);
+      if (found.length === 0) {
+        console.error(`No conversation matching prefix "${args.resumePrefix}"`);
+        process.exit(1);
+      }
+      if (found.length > 1) {
+        console.error(
+          `Multiple conversations match "${args.resumePrefix}": ${found.map((f) => f.id).join(", ")}. Provide more chars.`
+        );
+        process.exit(1);
+      }
+      session = await convStore.loadById(found[0].id);
+    } else {
+      session = await convStore.resumeLatest();
+    }
+    if (session) {
+      history = [...session.messages, { role: "user", content: args.prompt }];
+      resumedFrom = session.session_id;
+      log(cDim(`resuming session ${session.session_id} (${session.messages.length} prior messages)`));
+    } else {
+      log(cDim("--resume requested but no prior session found \u2014 starting fresh"));
+    }
+  }
+  if (!resumedFrom) {
+    history = [{ role: "user", content: args.prompt }];
+  }
+  if (args.persist) {
+    if (resumedFrom) {
+      await convStore.appendMessage({ role: "user", content: args.prompt });
+    } else {
+      const id = await convStore.startNew({
+        workspaceRoot: args.workspace,
+        stackHint: args.stackHint,
+        firstPrompt: args.prompt
+      });
+      await convStore.appendMessage({ role: "user", content: args.prompt });
+      log(cDim(`session: ${id} (saved to .rscot/conversations/)`));
+    }
+  }
+  const shutdown = async (sig) => {
+    log(cYellow(`
+[cli] ${sig} \u2014 cleaning up ${procRegistry.size} spawned process(es)\u2026`));
+    await procRegistry.cleanupAll();
+    process.exit(130);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  let workspaceSummary;
+  if (!args.resume) {
+    workspaceSummary = await buildPriorContext(convStore, args.prompt);
+    if (workspaceSummary) {
+      log(cDim(`prior context: ${workspaceSummary.split("\n").length - 1} lines`));
+    }
+  }
+  let exitCode = 0;
+  let finalSummary = "";
+  let finalFilesChanged = [];
+  try {
+    for (let iter = 0; iter < args.maxIters; iter++) {
+      logInfo(cDim(`[${String(iter + 1).padStart(2)}] `) + cMag("\u2192 LLM   "));
+      let resp;
+      try {
+        const turnParams = {
+          messages: history,
+          workspace_root: args.workspace,
+          session_id: resumedFrom || convStore.getCurrentId() || void 0
+        };
+        if (iter === 0 && workspaceSummary) turnParams.workspace_summary = workspaceSummary;
+        const timeoutMs = args.turnTimeout * 1e3;
+        resp = args.stream ? await consumeStream(client, turnParams) : await client.turn(turnParams, { timeoutMs });
+      } catch (err) {
+        logInfo(cRed(`\u2717 ${err?.message || String(err)}`));
+        exitCode = 1;
+        break;
+      }
+      if (resp.type === "message") {
+        logInfo(cGreen("\u2190 message"));
+        log("\n" + cCyan("assistant:") + " " + resp.content + "\n");
+        history.push(resp.assistant_message);
+        if (args.persist) await convStore.appendMessage(resp.assistant_message);
+        const isNudge = /^[⏸⏪]/u.test(resp.content.trim());
+        if (isNudge) {
+          logInfo(cDim("     [server nudge \u2014 auto-continuing]"));
+          const followUp = {
+            role: "user",
+            content: "Understood \u2014 proceeding as instructed."
+          };
+          history.push(followUp);
+          if (args.persist) await convStore.appendMessage(followUp);
+          continue;
+        }
+        break;
+      }
+      if (resp.type === "done") {
+        logInfo(cGreen("\u2190 DONE"));
+        finalSummary = resp.summary;
+        finalFilesChanged = resp.files_changed;
+        log("\n" + cBold("Summary: ") + resp.summary);
+        if (resp.files_changed?.length) {
+          log(cBold("Files changed:"));
+          for (const p of resp.files_changed) {
+            log(`  \xB7 ${fileLink(args.workspace, p)}`);
+          }
+        }
+        if (resp.suggested_test_cmd)
+          log(cBold("Suggested test: ") + resp.suggested_test_cmd);
+        history.push(resp.assistant_message);
+        if (args.persist) await convStore.appendMessage(resp.assistant_message);
+        const doneTcId = resp.assistant_message?.tool_calls?.[0]?.id || "call_done";
+        const doneAck = {
+          role: "tool",
+          tool_call_id: doneTcId,
+          name: "done",
+          content: JSON.stringify({
+            acknowledged: true,
+            summary: resp.summary,
+            files_changed: resp.files_changed || []
+          })
+        };
+        history.push(doneAck);
+        if (args.persist) await convStore.appendMessage(doneAck);
+        if (args.persist) await convStore.markComplete(resp.files_changed || []);
+        if (args.gitCheckpoint && checkpoint.getStatus().active) {
+          const r = await checkpoint.commitOnDone(resp.summary);
+          if (r.committed) {
+            log(cDim(`git: committed ${r.sha?.slice(0, 7)} (${r.addedPaths?.length || 0} path${r.addedPaths?.length === 1 ? "" : "s"})`));
+            if (r.preserved && r.preserved.length > 0) {
+              log(cDim(`     ${r.preserved.length} user-owned dirty/untracked file${r.preserved.length === 1 ? "" : "s"} preserved (untouched):`));
+              for (const p of r.preserved.slice(0, 8)) log(cDim(`       \xB7 ${fileLink(args.workspace, p)}`));
+              if (r.preserved.length > 8) log(cDim(`       \u2026 and ${r.preserved.length - 8} more`));
+            }
+            if (r.unstagedConflicts && r.unstagedConflicts.length > 0) {
+              log(cYellow(`\u26A0 ${r.unstagedConflicts.length} file(s) had user-unstaged edits co-committed:`));
+              for (const p of r.unstagedConflicts) log(cYellow(`     \xB7 ${fileLink(args.workspace, p)}`));
+              log(cYellow(`     If unintended, run: git reset HEAD~1; git restore --staged ${r.unstagedConflicts[0]}`));
+            }
+            log(cDim(`     rewind:  git reset --hard ${checkpoint.getStatus().startedAtSha?.slice(0, 7)}`));
+          } else {
+            log(cDim(`git: no commit (${r.reason})`));
+          }
+        }
+        break;
+      }
+      if (resp.type === "blocked") {
+        logInfo(cRed(`\u2190 BLOCKED ${resp.name}`) + cDim(`  (${resp.reason})`));
+        history.push(resp.assistant_message);
+        if (args.persist) await convStore.appendMessage(resp.assistant_message);
+        const blockMsg = {
+          role: "tool",
+          tool_call_id: resp.tool_call_id,
+          name: resp.name,
+          content: JSON.stringify({ blocked: true, reason: resp.reason })
+        };
+        history.push(blockMsg);
+        if (args.persist) await convStore.appendMessage(blockMsg);
+        continue;
+      }
+      if (resp.type === "tool_call" && args.dryRun) {
+        logInfo(cYellow("\u2190 [DRY]") + cDim(` would call ${cBold(resp.name)}  ${JSON.stringify(resp.arguments).slice(0, 200)}`));
+        history.push(resp.assistant_message);
+        if (args.persist) await convStore.appendMessage(resp.assistant_message);
+        const dryResult = {
+          role: "tool",
+          tool_call_id: resp.tool_call_id,
+          name: resp.name,
+          content: JSON.stringify({ dry_run: true, skipped: true })
+        };
+        history.push(dryResult);
+        if (args.persist) await convStore.appendMessage(dryResult);
+        continue;
+      }
+      logInfo(cGreen("\u2190 tool_call ") + cBold(resp.name) + cDim("  " + JSON.stringify(resp.arguments).slice(0, 120)));
+      history.push(resp.assistant_message);
+      if (args.persist) await convStore.appendMessage(resp.assistant_message);
+      if (needsApproval(resp.name, settings)) {
+        const ok = await prompt(`     approve ${resp.name}? [y/N] `);
+        if (!ok) {
+          logInfo(cYellow("     refused"));
+          const refusedMsg = {
+            role: "tool",
+            tool_call_id: resp.tool_call_id,
+            name: resp.name,
+            content: JSON.stringify({ refused_by_user: true })
+          };
+          history.push(refusedMsg);
+          if (args.persist) await convStore.appendMessage(refusedMsg);
+          continue;
+        }
+      }
+      const t0 = Date.now();
+      const result = await execute(resp.name, resp.arguments, {
+        rollback: registry,
+        registry: procRegistry,
+        settings,
+        mountedFolders: cliMountedFolders
+      });
+      const dt = Date.now() - t0;
+      const resultStr = JSON.stringify(result);
+      const isErr = typeof result === "object" && result && result.error;
+      logTool(
+        (isErr ? cRed("    [exec err]") : cDim(`    [exec ${dt}ms]`)) + " " + cDim(resultStr.slice(0, 160) + (resultStr.length > 160 ? "\u2026" : ""))
+      );
+      if (!isErr && args.gitCheckpoint && checkpoint.getStatus().active) {
+        const writeTools = /* @__PURE__ */ new Set([
+          "write_file",
+          "edit_file",
+          "format_file",
+          "apply_diff",
+          "apply_unified_diff",
+          "delete_file",
+          "move_file",
+          "rename_file"
+        ]);
+        if (writeTools.has(resp.name)) {
+          const p = resp.arguments?.path;
+          if (typeof p === "string") checkpoint.recordWrite(p);
+          const dest = resp.arguments?.dest ?? resp.arguments?.new_path ?? resp.arguments?.to;
+          if (typeof dest === "string") checkpoint.recordWrite(dest);
+        }
+      }
+      const toolMsg = {
+        role: "tool",
+        tool_call_id: resp.tool_call_id,
+        name: resp.name,
+        content: resultStr
+      };
+      history.push(toolMsg);
+      if (args.persist) await convStore.appendMessage(toolMsg);
+    }
+  } finally {
+    if (procRegistry.size > 0) {
+      log(cYellow(`
+[cli] cleaning up ${procRegistry.size} spawned process(es) before exit\u2026`));
+      await procRegistry.cleanupAll();
+    }
+  }
+  log(cDim(`
+Writes this session: ${registry.size}`));
+  if (gJson) {
+    const sid = resumedFrom || convStore.getCurrentId();
+    emitJsonResult({
+      session_id: sid,
+      files_changed: finalFilesChanged,
+      summary: finalSummary,
+      exit_code: exitCode
+    });
+  }
+  process.exit(exitCode);
+}
+async function prompt(text) {
+  process.stdout.write(text);
+  return new Promise((resolve3) => {
+    process.stdin.setEncoding("utf-8");
+    const onData = (chunk) => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      resolve3(chunk.trim().toLowerCase().startsWith("y"));
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function consumeStream(client, payload) {
+  let streamedSomeContent = false;
+  logInfo(cMag("\u2190 stream "));
+  for await (const ev of client.turnStream(payload)) {
+    switch (ev.type) {
+      case "delta":
+        if (ev.content) {
+          if (!streamedSomeContent) {
+            logInfo("  " + cCyan("\u2502 "));
+            streamedSomeContent = true;
+          }
+          log(ev.content);
+        }
+        if (ev.reasoning) {
+        }
+        break;
+      case "status":
+        break;
+      case "assistant":
+        break;
+      case "tool_call":
+        if (streamedSomeContent) log("");
+        return {
+          type: "tool_call",
+          tool_call_id: ev.tool_call_id,
+          name: ev.name,
+          arguments: ev.arguments,
+          assistant_message: ev.assistant_message
+        };
+      case "blocked":
+        if (streamedSomeContent) log("");
+        return {
+          type: "blocked",
+          tool_call_id: ev.tool_call_id,
+          name: ev.name,
+          arguments: ev.arguments,
+          reason: ev.reason,
+          severity: ev.severity === "warn" ? "warn" : "block",
+          assistant_message: ev.assistant_message
+        };
+      case "message":
+        if (streamedSomeContent) log("");
+        return {
+          type: "message",
+          content: ev.content,
+          assistant_message: ev.assistant_message
+        };
+      case "done":
+        if (streamedSomeContent) log("");
+        return {
+          type: "done",
+          summary: ev.summary,
+          files_changed: ev.files_changed || [],
+          suggested_test_cmd: ev.suggested_test_cmd || "",
+          assistant_message: ev.assistant_message
+        };
+      case "error":
+        throw new Error(ev.message + (ev.detail ? `: ${ev.detail}` : ""));
+    }
+  }
+  throw new Error("stream ended without a terminal event");
+}
+main().catch((err) => {
+  console.error("[cli] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map