@barnaby.build/barnaby 0.0.128

package/dist-electron/main/index.js

@@ -0,0 +1,3705 @@
+var Tt = Object.defineProperty;
+var $t = (n, t, e) => t in n ? Tt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var P = (n, t, e) => $t(n, typeof t != "symbol" ? t + "" : t, e);
+import { ipcMain as f, app as $, BrowserWindow as L, nativeTheme as Ae, shell as z, dialog as me, Menu as xe, screen as _t } from "electron";
+import { pathToFileURL as Mt, fileURLToPath as It } from "node:url";
+import h from "node:path";
+import d from "node:fs";
+import Q from "node:os";
+import { spawn as I, execFile as Rt } from "node:child_process";
+import { promisify as Ot } from "node:util";
+import { createRequire as Ft } from "node:module";
+import { EventEmitter as ne } from "node:events";
+import Dt from "node:readline";
+class Lt extends ne {
+  constructor() {
+    super(...arguments);
+    P(this, "proc", null);
+    P(this, "rl", null);
+    P(this, "nextId", 1);
+    P(this, "pending", /* @__PURE__ */ new Map());
+    P(this, "threadId", null);
+    P(this, "activeTurnId", null);
+    P(this, "permissionMode", "verify-first");
+    P(this, "allowedCommandPrefixes", []);
+    P(this, "allowedAutoReadPrefixes", []);
+    P(this, "allowedAutoWritePrefixes", []);
+    P(this, "deniedAutoReadPrefixes", []);
+    P(this, "deniedAutoWritePrefixes", []);
+    P(this, "lastStderr", "");
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  isConnected() {
+    return this.proc !== null;
+  }
+  getThreadId() {
+    return this.threadId;
+  }
+  async connect(e) {
+    var a;
+    if (e.provider && e.provider !== "codex")
+      throw new Error(
+        `Provider "${e.provider}" is not implemented yet. Select a Codex model/provider for now.`
+      );
+    this.permissionMode = e.permissionMode ?? "verify-first", this.allowedCommandPrefixes = this.normalizeAllowedCommandPrefixes(e.allowedCommandPrefixes), this.allowedAutoReadPrefixes = this.normalizeAllowedCommandPrefixes(e.allowedAutoReadPrefixes), this.allowedAutoWritePrefixes = this.normalizeAllowedCommandPrefixes(e.allowedAutoWritePrefixes), this.deniedAutoReadPrefixes = this.normalizeAllowedCommandPrefixes(e.deniedAutoReadPrefixes), this.deniedAutoWritePrefixes = this.normalizeAllowedCommandPrefixes(e.deniedAutoWritePrefixes), this.proc && await this.close(), this.emitEvent({ type: "status", status: "starting", message: "Starting codex app-server..." });
+    const r = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "codex app-server"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: !0
+    }) : I("codex", ["app-server"], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc = r, r.on("exit", (c, u) => {
+      const l = c !== null ? `codex app-server exited (${c})` : `codex app-server exited (${u ?? "unknown"})`;
+      this.emitEvent({ type: "status", status: "closed", message: l }), this.cleanupAfterExit();
+    }), r.on("error", (c) => {
+      this.emitEvent({ type: "status", status: "error", message: String((c == null ? void 0 : c.message) ?? c) }), this.cleanupAfterExit();
+    }), r.stderr.setEncoding("utf8"), r.stderr.on("data", (c) => {
+      const u = String(c).trim();
+      this.lastStderr = `${this.lastStderr}
+${u}`.trim().slice(-2e3), u && this.emitEvent({ type: "status", status: "error", message: u });
+    }), r.stdout.setEncoding("utf8");
+    const s = Dt.createInterface({ input: r.stdout });
+    this.rl = s, s.on("line", (c) => this.onLine(c)), await this.sendRequest("initialize", {
+      clientInfo: { name: "agent_orchestrator", title: "Agent Orchestrator", version: "0.0.2" }
+      // Keep full stream; we can ignore what we don't use.
+    }), this.sendNotification("initialized", {});
+    const i = await this.sendRequest("thread/start", {
+      model: e.model,
+      cwd: e.cwd,
+      approvalPolicy: e.approvalPolicy ?? (this.permissionMode === "proceed-always" ? "never" : "on-request"),
+      sandbox: e.sandbox ?? "workspace-write"
+    });
+    this.writeCliConfig(e.cwd);
+    const o = (a = i == null ? void 0 : i.thread) == null ? void 0 : a.id;
+    if (!o || typeof o != "string")
+      throw new Error("codex app-server did not return a thread id");
+    return this.threadId = o, this.emitEvent({ type: "status", status: "ready", message: "Connected" }), { threadId: o };
+  }
+  async sendUserMessage(e) {
+    var o;
+    if (!this.threadId) throw new Error("Not connected (no threadId).");
+    const r = e.trim();
+    if (!r) return;
+    const s = await this.sendRequest("turn/start", {
+      threadId: this.threadId,
+      input: [{ type: "text", text: r }]
+    }), i = (o = s == null ? void 0 : s.turn) == null ? void 0 : o.id;
+    i && typeof i == "string" && (this.activeTurnId = i);
+  }
+  async sendUserMessageWithImages(e, r) {
+    var u;
+    if (!this.threadId) throw new Error("Not connected (no threadId).");
+    const s = e.trim(), i = (r ?? []).filter((l) => typeof l == "string" && l.trim());
+    if (!s && i.length === 0) return;
+    const o = [];
+    s && o.push({ type: "text", text: s });
+    for (const l of i) o.push({ type: "localImage", path: l });
+    const a = await this.sendRequest("turn/start", {
+      threadId: this.threadId,
+      input: o
+    }), c = (u = a == null ? void 0 : a.turn) == null ? void 0 : u.id;
+    c && typeof c == "string" && (this.activeTurnId = c);
+  }
+  async interruptActiveTurn() {
+    !this.threadId || !this.activeTurnId || await this.sendRequest("turn/interrupt", { threadId: this.threadId, turnId: this.activeTurnId });
+  }
+  async close() {
+    if (this.proc) {
+      try {
+        this.proc.stdin.end();
+      } catch {
+      }
+      try {
+        this.proc.kill();
+      } catch {
+      }
+      this.cleanupAfterExit();
+    }
+  }
+  cleanupAfterExit() {
+    var r;
+    (r = this.rl) == null || r.close(), this.rl = null, this.proc = null;
+    const e = this.lastStderr ? ` | stderr: ${this.lastStderr}` : "";
+    this.pending.forEach(
+      ({ reject: s }) => s(
+        new Error(
+          `codex app-server closed. Check codex login/PATH/workspace/model selection${e}`
+        )
+      )
+    ), this.pending.clear(), this.threadId = null, this.activeTurnId = null, this.lastStderr = "";
+  }
+  onLine(e) {
+    var i;
+    const r = e.trim();
+    if (!r) return;
+    let s;
+    try {
+      s = JSON.parse(r);
+    } catch {
+      this.emitEvent({ type: "status", status: "error", message: `Bad JSON from codex: ${r.slice(0, 200)}` });
+      return;
+    }
+    if (typeof s.id == "number" && ("result" in s || "error" in s)) {
+      const o = s.id, a = this.pending.get(o);
+      if (!a) return;
+      this.pending.delete(o), "error" in s && s.error ? a.reject(new Error(((i = s.error) == null ? void 0 : i.message) ?? "Unknown JSON-RPC error")) : a.resolve(s.result);
+      return;
+    }
+    if (typeof s.id == "number" && typeof s.method == "string") {
+      const o = s.id, a = s.method;
+      if (this.emitEvent({ type: "rawNotification", method: a, params: s.params }), a.endsWith("/requestApproval"))
+        if (this.permissionMode === "proceed-always") {
+          const c = this.extractApprovalCommand(s.params), u = this.extractApprovalPath(s.params);
+          if (u) {
+            const l = a.includes("read") ? "read" : "write";
+            this.shouldAutoApprovePath(u, l) ? this.sendResponse(o, { decision: "accept" }) : (this.emitEvent({
+              type: "status",
+              status: "error",
+              message: `Action blocked by allowed command prefixes (${u}). Update workspace prefix allowlist to permit this command.`
+            }), this.sendResponse(o, { decision: "decline" }));
+          } else if (c)
+            if (this.shouldAutoApproveCommand(c))
+              this.sendResponse(o, { decision: "accept" });
+            else {
+              const l = c ? ` (${this.shorten(c, 120)})` : "";
+              this.emitEvent({
+                type: "status",
+                status: "error",
+                message: `Action blocked by allowed command prefixes${l}. Update workspace prefix allowlist to permit this command.`
+              }), this.sendResponse(o, { decision: "decline" });
+            }
+          else
+            this.sendResponse(o, { decision: "decline" });
+        } else
+          this.emitEvent({
+            type: "status",
+            status: "error",
+            message: "Action requires approval. Set permissions to Proceed always to allow writes."
+          }), this.sendResponse(o, { decision: "decline" });
+      else
+        this.sendResponse(o, null);
+      return;
+    }
+    if (typeof s.method == "string") {
+      const o = s.method, a = s.params;
+      this.handleNotification(o, a);
+    }
+  }
+  handleNotification(e, r) {
+    var s, i, o, a;
+    if (e === "item/agentMessage/delta") {
+      const c = typeof (r == null ? void 0 : r.delta) == "string" ? r.delta : typeof (r == null ? void 0 : r.text) == "string" ? r.text : typeof (r == null ? void 0 : r.textDelta) == "string" ? r.textDelta : typeof ((s = r == null ? void 0 : r.delta) == null ? void 0 : s.text) == "string" ? r.delta.text : "";
+      c && this.emitEvent({ type: "assistantDelta", delta: c });
+      return;
+    }
+    if (!(e === "item/completed" && ((i = r == null ? void 0 : r.item) == null ? void 0 : i.type) === "agentMessage")) {
+      if (e === "turn/completed") {
+        this.activeTurnId = null, this.emitEvent({ type: "assistantCompleted" });
+        return;
+      }
+      if (e === "thread/tokenUsage/updated") {
+        this.emitEvent({ type: "usageUpdated", usage: r });
+        return;
+      }
+      if (e === "codex/event/token_count") {
+        const c = (o = r == null ? void 0 : r.rate_limits) == null ? void 0 : o.primary, u = (a = r == null ? void 0 : r.rate_limits) == null ? void 0 : a.secondary;
+        this.emitEvent({
+          type: "usageUpdated",
+          usage: {
+            kind: "rateLimits",
+            primary: c ? {
+              usedPercent: c.used_percent,
+              windowMinutes: c.window_minutes,
+              resetsAt: c.resets_at
+            } : null,
+            secondary: u ? {
+              usedPercent: u.used_percent,
+              windowMinutes: u.window_minutes,
+              resetsAt: u.resets_at
+            } : null
+          }
+        });
+        return;
+      }
+      if (e === "turn/plan/updated") {
+        this.emitEvent({ type: "planUpdated", plan: r });
+        return;
+      }
+      this.emitEvent({ type: "rawNotification", method: e, params: r });
+    }
+  }
+  sendNotification(e, r) {
+    this.writeMessage({ method: e, params: r });
+  }
+  sendResponse(e, r) {
+    this.writeMessage({ id: e, result: r });
+  }
+  sendRequest(e, r) {
+    const s = this.nextId++, i = { id: s, method: e, params: r };
+    return new Promise((o, a) => {
+      this.pending.set(s, { resolve: o, reject: a }), this.writeMessage(i);
+    });
+  }
+  writeMessage(e) {
+    if (!this.proc) throw new Error("codex app-server process not running");
+    this.proc.stdin.write(`${JSON.stringify(e)}
+`);
+  }
+  writeCliConfig(e) {
+    if (this.permissionMode !== "proceed-always") return;
+    const r = h.join(e, ".cursor"), s = h.join(r, "cli.json");
+    if (this.allowedCommandPrefixes.length === 0 && this.allowedAutoReadPrefixes.length === 0 && this.allowedAutoWritePrefixes.length === 0 && this.deniedAutoReadPrefixes.length === 0 && this.deniedAutoWritePrefixes.length === 0) {
+      if (d.existsSync(s))
+        try {
+          d.unlinkSync(s);
+        } catch {
+        }
+      return;
+    }
+    const i = /* @__PURE__ */ new Set();
+    if (this.allowedCommandPrefixes.length === 0)
+      i.add("Shell(npm)"), i.add("Shell(node)"), i.add("Shell(git)");
+    else
+      for (const p of this.allowedCommandPrefixes) {
+        const m = p.trim().split(/\s+/);
+        m[0] && i.add(`Shell(${m[0]})`);
+      }
+    const o = this.allowedAutoReadPrefixes.length > 0 ? this.allowedAutoReadPrefixes.map((p) => `Read(${p}**)`) : ["Read(**)"], a = this.allowedAutoWritePrefixes.length > 0 ? this.allowedAutoWritePrefixes.map((p) => `Write(${p}**)`) : ["Write(**)"], c = this.deniedAutoReadPrefixes.map((p) => `Read(${p}**)`), u = this.deniedAutoWritePrefixes.map((p) => `Write(${p}**)`), l = {
+      permissions: {
+        allow: [
+          ...Array.from(i),
+          ...o,
+          ...a
+        ],
+        deny: [
+          ...c,
+          ...u
+        ]
+      }
+    };
+    try {
+      d.existsSync(r) || d.mkdirSync(r, { recursive: !0 }), d.writeFileSync(
+        s,
+        JSON.stringify(l, null, 2),
+        "utf8"
+      );
+    } catch (p) {
+      this.emitEvent({
+        type: "status",
+        status: "error",
+        message: `Failed to write permission config: ${String(p)}`
+      });
+    }
+  }
+  extractApprovalPath(e) {
+    var s;
+    const r = this.pickString(e, ["path", "file", "filename"]) ?? this.pickString(e == null ? void 0 : e.path, ["path", "file", "filename"]) ?? this.pickString(e == null ? void 0 : e.request, ["path", "file", "filename"]) ?? this.pickString((s = e == null ? void 0 : e.request) == null ? void 0 : s.path, ["path", "file", "filename"]) ?? this.pickString(e == null ? void 0 : e.action, ["path", "file", "filename"]) ?? this.pickString(e == null ? void 0 : e.toolInput, ["path", "file", "filename"]) ?? this.pickString(e == null ? void 0 : e.input, ["path", "file", "filename"]) ?? null;
+    return r || (typeof (e == null ? void 0 : e.path) == "string" && e.path.trim() ? e.path.trim() : null);
+  }
+  shouldAutoApprovePath(e, r) {
+    const s = r === "read" ? this.allowedAutoReadPrefixes : this.allowedAutoWritePrefixes, i = r === "read" ? this.deniedAutoReadPrefixes : this.deniedAutoWritePrefixes;
+    if (s.length === 0 && i.length === 0) return !0;
+    const o = e.trim().replace(/\\/g, "/");
+    for (const a of i)
+      if (o.startsWith(a)) return !1;
+    if (s.length === 0) return !0;
+    for (const a of s)
+      if (o.startsWith(a)) return !0;
+    return !1;
+  }
+  normalizeAllowedCommandPrefixes(e) {
+    if (!Array.isArray(e)) return [];
+    const r = /* @__PURE__ */ new Set(), s = [];
+    for (const i of e) {
+      if (typeof i != "string") continue;
+      const o = i.trim();
+      if (!o) continue;
+      const a = o.toLowerCase();
+      r.has(a) || (r.add(a), s.push(o));
+    }
+    return s.slice(0, 64);
+  }
+  shouldAutoApproveCommand(e) {
+    if (this.allowedCommandPrefixes.length === 0) return !0;
+    if (!e) return !1;
+    const r = e.trim().toLowerCase();
+    return this.allowedCommandPrefixes.some(
+      (s) => r.startsWith(s.toLowerCase())
+    );
+  }
+  extractApprovalCommand(e) {
+    var s;
+    const r = this.pickString(e, ["command", "cmd"]) ?? this.pickString(e == null ? void 0 : e.command, ["command", "cmd", "raw"]) ?? this.pickString(e == null ? void 0 : e.request, ["command", "cmd"]) ?? this.pickString((s = e == null ? void 0 : e.request) == null ? void 0 : s.command, ["command", "cmd", "raw"]) ?? this.pickString(e == null ? void 0 : e.action, ["command", "cmd"]) ?? this.pickString(e == null ? void 0 : e.toolInput, ["command", "cmd"]) ?? this.pickString(e == null ? void 0 : e.input, ["command", "cmd"]) ?? null;
+    return r || (typeof (e == null ? void 0 : e.command) == "string" && e.command.trim() ? e.command.trim() : typeof (e == null ? void 0 : e.cmd) == "string" && e.cmd.trim() ? e.cmd.trim() : null);
+  }
+  pickString(e, r) {
+    if (!e || typeof e != "object") return null;
+    for (const s of r) {
+      const i = e == null ? void 0 : e[s];
+      if (typeof i == "string" && i.trim()) return i.trim();
+    }
+    return null;
+  }
+  shorten(e, r) {
+    return e.length <= r ? e : `${e.slice(0, r)}...`;
+  }
+}
+const Be = 100 * 1024;
+function Y(n, t) {
+  const e = /(?:^|\s)@([\w./-]+(?:\.[\w]+))/g, r = /* @__PURE__ */ new Set(), s = [];
+  let i;
+  for (; (i = e.exec(n)) !== null; ) {
+    const o = i[1];
+    if (r.has(o)) continue;
+    r.add(o);
+    const a = h.isAbsolute(o) ? o : h.resolve(t, o);
+    try {
+      const c = d.statSync(a);
+      if (!c.isFile()) continue;
+      if (c.size > Be) {
+        s.push(`--- ${o} (truncated, ${Math.round(c.size / 1024)} KB) ---
+${d.readFileSync(a, "utf8").slice(0, Be)}
+...`);
+        continue;
+      }
+      const u = d.readFileSync(a, "utf8");
+      s.push(`--- ${o} ---
+${u}`);
+    } catch {
+    }
+  }
+  return s.length > 0 ? `
+
+Referenced file contents:
+
+` + s.join(`
+
+`) : "";
+}
+function ze() {
+  const n = { ...process.env };
+  if (process.platform === "win32") {
+    const t = process.env.APPDATA ? h.join(process.env.APPDATA, "npm") : "";
+    t && n.PATH && !n.PATH.includes(t) && (n.PATH = `${t}${h.delimiter}${n.PATH}`);
+  }
+  return n.GEMINI_SANDBOX = "false", n;
+}
+const fe = class fe extends ne {
+  constructor() {
+    super(...arguments);
+    P(this, "model", "gemini-2.0-flash");
+    P(this, "cwd", process.cwd());
+    P(this, "history", []);
+    P(this, "activeProc", null);
+  }
+  normalizeModelId(e) {
+    return {
+      "gemini-1.5-pro": "pro",
+      "gemini-1.5-flash": "flash",
+      "gemini-2.0-flash": "flash",
+      "gemini-3-pro": "pro",
+      "gemini-pro": "flash",
+      "gemini-1.0-pro": "flash"
+    }[e] ?? e;
+  }
+  isModelNotFoundError(e) {
+    const r = e.toLowerCase();
+    return r.includes("modelnotfound") || r.includes("requested entity was not found") || r.includes("not found") && r.includes("model");
+  }
+  /** Map Gemini CLI exit codes to user-friendly messages (per Gemini CLI docs) */
+  formatGeminiExitError(e, r, s) {
+    const i = s.trim();
+    if (i) {
+      const u = i.split(`
+`).map((l) => l.trim()).filter((l) => l && !fe.STDERR_NOISE.test(l))[0] ?? i.split(`
+`).find((l) => l.trim()) ?? i.split(`
+`)[0];
+      return u.length > 300 ? u.slice(0, 300) + "..." : u;
+    }
+    if (r) return `Gemini CLI was terminated (${r})`;
+    const a = {
+      1: "Gemini CLI failed. Model may be at capacity — try again in a moment or switch to a different model.",
+      41: "Authentication failed. Run `gemini` in a terminal and log in with Google.",
+      42: "Invalid or missing input. Check your prompt or model selection.",
+      44: "Sandbox error. Try without sandbox or check your Docker/Podman setup.",
+      52: "Invalid config. Check your Gemini CLI settings.json.",
+      53: "Session turn limit reached. Start a new session."
+    }[e ?? 0];
+    return a || `Gemini CLI exited with code ${e ?? "unknown"}`;
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  async connect(e) {
+    var i;
+    const r = e.model || "gemini-2.0-flash", s = this.normalizeModelId(r);
+    return this.model = s, this.cwd = e.cwd || process.cwd(), s !== r && this.emitEvent({
+      type: "status",
+      status: "starting",
+      message: `Model ${r} mapped to ${s} for Gemini CLI.`
+    }), this.emitEvent({ type: "status", status: "starting", message: "Connecting to Gemini CLI..." }), await this.assertGeminiCliAvailable(), this.history = (((i = e.initialHistory) == null ? void 0 : i.length) ?? 0) > 0 ? e.initialHistory.slice(-24) : [], this.emitEvent({ type: "status", status: "ready", message: "Connected" }), { threadId: "gemini" };
+  }
+  async sendUserMessageWithImages(e, r) {
+    const s = e.trim(), i = (r ?? []).filter((p) => typeof p == "string" && p.trim());
+    if (!s && i.length === 0) return;
+    const o = i.length > 0 ? `
+
+` + i.map((p) => `@${p}`).join(`
+`) : "", a = s ? s + o : i.map((p) => `@${p}`).join(`
+`), c = Y(a, this.cwd), u = a + c;
+    this.history.push({ role: "user", text: u });
+    const l = this.buildGeminiPrompt(u);
+    await this.runTurn(l);
+  }
+  async sendUserMessage(e) {
+    const r = e.trim();
+    if (!r) return;
+    const s = Y(r, this.cwd), i = r + s;
+    this.history.push({ role: "user", text: i });
+    const o = this.buildGeminiPrompt(i);
+    await this.runTurn(o);
+  }
+  async runTurn(e) {
+    const r = (s) => new Promise((i, o) => {
+      const a = ["-m", s, "--yolo", "--output-format", "stream-json"], c = {
+        cwd: this.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: ze()
+      }, u = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "gemini", ...a], {
+        ...c,
+        windowsHide: !0
+      }) : I("gemini", a, c);
+      this.activeProc = u, u.stdin.write(e), u.stdin.end(), u.stdout.setEncoding("utf8"), u.stderr.setEncoding("utf8");
+      let l = "", p = "", m = !1, g = "";
+      const x = /quota|retrying after|rate.?limit|capacity.*exhausted|reset after|YOLO mode|Loaded cached credentials|All tool calls will be/i, E = /status 429|Retrying with backoff|Attempt \d+ failed(?!.*Max attempts)|No capacity available/i;
+      u.stdout.on("data", (w) => {
+        if (!w) return;
+        g += w;
+        const b = g.split(`
+`);
+        g = b.pop() ?? "";
+        for (const y of b) {
+          const A = y.trim();
+          if (!A) continue;
+          let v;
+          try {
+            v = JSON.parse(A);
+          } catch {
+            if (x.test(A)) continue;
+            const S = A.length > 300 ? A.slice(0, 300) + "..." : A;
+            /Max attempts reached/i.test(A) ? this.emitEvent({ type: "status", status: "error", message: S }) : E.test(A) ? this.emitEvent({ type: "thinking", message: "Rate limited — CLI is retrying..." }) : this.emitEvent({ type: "thinking", message: S });
+            continue;
+          }
+          switch (v.type) {
+            case "message":
+              if ((v.role === "assistant" || v.role === "model") && typeof v.content == "string" && (this.emitEvent({ type: "assistantDelta", delta: v.content }), l += v.content, v.delta)) {
+                const S = v.content.trim();
+                S.length > 0 && S.length < 200 && this.emitEvent({ type: "thinking", message: S });
+              }
+              break;
+            case "tool_use":
+            case "toolUse":
+            case "functionCall": {
+              const S = v.tool_name ?? v.name ?? v.toolName ?? "tool", C = v.parameters ?? v.args ?? v.input ?? {}, R = C.file_path ?? C.command ?? C.dir_path ?? C.pattern ?? C.query ?? C.path ?? C.url ?? "", Ue = `Using ${S}${R ? `: ${R}` : ""}`;
+              this.emitEvent({ type: "thinking", message: Ue });
+              break;
+            }
+            case "tool_result":
+            case "toolResult":
+            case "functionResponse": {
+              const S = v.status === "success" ? "done" : v.status ?? "done", C = typeof v.output == "string" ? v.output : typeof v.result == "string" ? v.result : typeof v.response == "string" ? v.response : "", R = C.length > 160 ? C.slice(0, 160) + "..." : C;
+              this.emitEvent({ type: "thinking", message: R || S });
+              break;
+            }
+            case "thinking":
+            case "thought": {
+              const S = typeof v.content == "string" ? v.content : typeof v.message == "string" ? v.message : typeof v.text == "string" ? v.text : "";
+              if (S) {
+                const C = S.length > 200 ? S.slice(0, 200) + "..." : S;
+                this.emitEvent({ type: "thinking", message: C });
+              }
+              break;
+            }
+            case "result":
+              v.stats && this.emitEvent({ type: "usageUpdated", usage: v.stats });
+              break;
+            case "error": {
+              const S = v.message ?? v.content ?? "Unknown error", C = typeof S == "string" ? S.length > 300 ? S.slice(0, 300) + "..." : S : "Gemini error";
+              if (x.test(C)) break;
+              /status 429|Retrying with backoff|Attempt \d+ failed/i.test(C) ? this.emitEvent({ type: "thinking", message: "Rate limited — CLI is retrying..." }) : this.emitEvent({ type: "status", status: "error", message: C });
+              break;
+            }
+            case "init":
+              break;
+            default: {
+              const S = v.message ?? v.content ?? v.text ?? "";
+              if (typeof S == "string" && S.trim()) {
+                const C = S.length > 200 ? S.slice(0, 200) + "..." : S;
+                this.emitEvent({ type: "thinking", message: `[${v.type}] ${C}` });
+              }
+            }
+          }
+        }
+      }), u.stderr.on("data", (w) => {
+        p += w;
+        const b = w.trim();
+        if (b && !x.test(b)) {
+          const y = b.length > 200 ? b.slice(0, 200) + "..." : b;
+          this.emitEvent({ type: "thinking", message: y });
+        }
+      }), u.on("error", (w) => {
+        m || (m = !0, o(w));
+      }), u.on("exit", (w, b) => {
+        if (this.activeProc = null, g.trim())
+          try {
+            const y = JSON.parse(g.trim());
+            y.type === "message" && y.role === "assistant" && typeof y.content == "string" ? (this.emitEvent({ type: "assistantDelta", delta: y.content }), l += y.content) : y.type === "result" && y.stats && this.emitEvent({ type: "usageUpdated", usage: y.stats });
+          } catch {
+          }
+        m || (m = !0, w === 0 ? i() : o(new Error(this.formatGeminiExitError(w, b, p)))), w === 0 ? (this.history.push({ role: "assistant", text: l.trim() || l }), this.emitEvent({ type: "assistantCompleted" })) : (this.emitEvent({ type: "status", status: "error", message: this.formatGeminiExitError(w, b, p) }), this.emitEvent({ type: "assistantCompleted" }));
+      });
+    });
+    try {
+      await r(this.model);
+    } catch (s) {
+      const i = s instanceof Error ? s.message : String(s);
+      if (this.isModelNotFoundError(i) && this.model !== "gemini-2.0-flash")
+        try {
+          this.emitEvent({
+            type: "status",
+            status: "starting",
+            message: `Model "${this.model}" not found. Retrying with gemini-2.0-flash...`
+          }), this.model = "gemini-2.0-flash", await r(this.model);
+        } catch (o) {
+          const a = o instanceof Error ? o.message : String(o);
+          this.emitEvent({ type: "status", status: "error", message: a }), this.emitEvent({ type: "assistantCompleted" });
+        }
+      else
+        this.emitEvent({ type: "status", status: "error", message: i }), this.emitEvent({ type: "assistantCompleted" });
+    }
+  }
+  async interruptActiveTurn() {
+    if (this.activeProc)
+      try {
+        this.activeProc.kill();
+      } catch {
+      } finally {
+        this.activeProc = null;
+      }
+  }
+  async close() {
+    await this.interruptActiveTurn(), this.history = [];
+  }
+  buildGeminiPrompt(e) {
+    const r = [...this.history].reverse().find((i) => i.role === "assistant");
+    return `${r ? `
+
+For context, your previous response was:
+${r.text.slice(0, 1200)}
+
+` : ""}${e}`;
+  }
+  async assertGeminiCliAvailable() {
+    await new Promise((e, r) => {
+      const s = {
+        cwd: this.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: ze()
+      }, i = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "gemini", "--version"], {
+        ...s,
+        windowsHide: !0
+      }) : I("gemini", ["--version"], s);
+      let o = "";
+      i.stderr.setEncoding("utf8"), i.stderr.on("data", (a) => {
+        o += a;
+      }), i.on("error", (a) => r(a)), i.on("exit", (a) => {
+        a === 0 ? e() : r(new Error(o.trim() || "Gemini CLI not available. Install and login with `gemini`."));
+      });
+    }).catch((e) => {
+      const r = e instanceof Error ? e.message : "Gemini CLI not available. Install and login with `gemini` first.";
+      throw new Error(
+        `${r}
+Use terminal: \`gemini\` and choose "Login with Google" (subscription).`
+      );
+    });
+  }
+};
+P(fe, "STDERR_NOISE", /YOLO mode|Loaded cached credentials|All tool calls will be|^\s*at /i);
+let Pe = fe;
+const Nt = /* @__PURE__ */ new Set([
+  ".git",
+  ".svn",
+  ".hg",
+  ".DS_Store",
+  "node_modules",
+  "dist",
+  "dist-electron",
+  "build",
+  "release",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".barnaby",
+  "target",
+  "vendor",
+  "bower_components",
+  "__pycache__"
+]), Wt = 3, jt = 150;
+function ce(n) {
+  let t = `Current Workspace Structure:
+`, e = 0, r = !1;
+  function s(i, o, a) {
+    if (!(o > Wt || r))
+      try {
+        const c = d.readdirSync(i, { withFileTypes: !0 });
+        c.sort((l, p) => l.isDirectory() !== p.isDirectory() ? l.isDirectory() ? -1 : 1 : l.name.localeCompare(p.name));
+        const u = c.filter((l) => !(l.name.startsWith(".") || l.isDirectory() && Nt.has(l.name)));
+        for (let l = 0; l < u.length; l++) {
+          const p = u[l];
+          if (e++, e > jt) {
+            r || (r = !0, t += `${a}- ... (truncated)
+`);
+            return;
+          }
+          t += `${a}- ${p.name}${p.isDirectory() ? "/" : ""}
+`, p.isDirectory() && s(h.join(i, p.name), o + 1, `${a}  `);
+        }
+      } catch {
+      }
+  }
+  return s(n, 0, ""), r && (t += `
+(Note: File tree truncated for brevity)`), t;
+}
+function qe() {
+  const n = { ...process.env };
+  if (process.platform === "win32") {
+    const t = process.env.APPDATA ? h.join(process.env.APPDATA, "npm") : "";
+    t && n.PATH && !n.PATH.includes(t) && (n.PATH = `${t}${h.delimiter}${n.PATH}`);
+  }
+  return n;
+}
+class Ht extends ne {
+  constructor() {
+    super(...arguments);
+    P(this, "model", "sonnet");
+    P(this, "cwd", process.cwd());
+    P(this, "permissionMode", "verify-first");
+    P(this, "history", []);
+    P(this, "activeProc", null);
+  }
+  normalizeModelId(e) {
+    const r = e.trim().toLowerCase(), s = {
+      "claude-sonnet-4-5-20250929": "sonnet",
+      "claude-opus-4-1-20250805": "opus",
+      "claude-haiku-3-5-20241022": "haiku"
+    };
+    return r ? s[r] ?? r : "sonnet";
+  }
+  isModelNotFoundError(e) {
+    const r = e.toLowerCase();
+    return r.includes("model") && (r.includes("not found") || r.includes("unknown") || r.includes("invalid"));
+  }
+  formatClaudeExitError(e, r, s) {
+    const i = s.trim();
+    return i || (r ? `Claude CLI was terminated (${r})` : `Claude CLI exited with code ${e ?? "unknown"}`);
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  async connect(e) {
+    var i;
+    const r = e.model || "sonnet", s = this.normalizeModelId(r);
+    return this.model = s, this.cwd = e.cwd || process.cwd(), this.permissionMode = e.permissionMode ?? "verify-first", s !== r && this.emitEvent({
+      type: "status",
+      status: "starting",
+      message: `Model ${r} normalized to ${s}.`
+    }), this.emitEvent({ type: "status", status: "starting", message: "Connecting to Claude CLI..." }), await this.assertClaudeCliAvailable(), this.history = (((i = e.initialHistory) == null ? void 0 : i.length) ?? 0) > 0 ? e.initialHistory.slice(-24) : [], this.emitEvent({ type: "status", status: "ready", message: "Connected" }), { threadId: "claude" };
+  }
+  async sendUserMessage(e) {
+    const r = e.trim();
+    if (!r) return;
+    const s = Y(r, this.cwd);
+    this.history.push({ role: "user", text: r + s });
+    const o = `You are a coding assistant running inside Barnaby. I have provided the workspace structure below. I will provide file contents when you ask or when I reference them (e.g. @filename).
+
+${ce(this.cwd)}`, a = this.buildPrompt(), c = this.permissionMode === "proceed-always" ? "acceptEdits" : "default", u = async (l) => {
+      let p = "";
+      return await new Promise((m, g) => {
+        const x = [
+          "--print",
+          "--output-format",
+          "text",
+          "--model",
+          l,
+          "--permission-mode",
+          c,
+          "--append-system-prompt",
+          o
+        ], E = {
+          cwd: this.cwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          env: qe()
+        }, w = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "claude", ...x], {
+          ...E,
+          windowsHide: !0
+        }) : I("claude", x, E);
+        this.activeProc = w, w.stdin.write(a), w.stdin.end(), w.stdout.setEncoding("utf8"), w.stderr.setEncoding("utf8");
+        let b = "";
+        w.stdout.on("data", (y) => {
+          y && (p += y, this.emitEvent({ type: "assistantDelta", delta: y }));
+        }), w.stderr.on("data", (y) => {
+          b += y;
+        }), w.on("error", (y) => g(y)), w.on("exit", (y, A) => {
+          this.activeProc = null, y === 0 ? m(p) : g(new Error(this.formatClaudeExitError(y, A, b)));
+        });
+      }), p;
+    };
+    try {
+      let l = await u(this.model);
+      l.trim(), this.history.push({ role: "assistant", text: l.trim() || l }), this.emitEvent({ type: "assistantCompleted" });
+    } catch (l) {
+      const p = l instanceof Error ? l.message : String(l);
+      if (this.isModelNotFoundError(p) && this.model !== "sonnet")
+        try {
+          this.emitEvent({
+            type: "status",
+            status: "starting",
+            message: `Model "${this.model}" not found. Retrying with sonnet...`
+          }), this.model = "sonnet";
+          const m = await u(this.model);
+          this.history.push({ role: "assistant", text: m.trim() || m }), this.emitEvent({ type: "status", status: "ready", message: `Connected (using ${this.model})` }), this.emitEvent({ type: "assistantCompleted" });
+          return;
+        } catch (m) {
+          const g = m instanceof Error ? m.message : String(m);
+          this.emitEvent({ type: "status", status: "error", message: g }), this.emitEvent({ type: "assistantCompleted" });
+          return;
+        }
+      this.emitEvent({ type: "status", status: "error", message: p }), this.emitEvent({ type: "assistantCompleted" });
+    }
+  }
+  async interruptActiveTurn() {
+    if (this.activeProc)
+      try {
+        this.activeProc.kill();
+      } catch {
+      } finally {
+        this.activeProc = null;
+      }
+  }
+  async close() {
+    await this.interruptActiveTurn(), this.history = [];
+  }
+  buildPrompt() {
+    return [this.history.slice(-12).map((s) => `${s.role === "user" ? "User" : "Assistant"}:
+${s.text}`).join(`
+
+`), "Assistant:"].filter(Boolean).join(`
+
+`);
+  }
+  async assertClaudeCliAvailable() {
+    await new Promise((e, r) => {
+      const s = {
+        cwd: this.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: qe()
+      }, i = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "claude", "--version"], {
+        ...s,
+        windowsHide: !0
+      }) : I("claude", ["--version"], s);
+      let o = "";
+      i.stderr.setEncoding("utf8"), i.stderr.on("data", (a) => {
+        o += a;
+      }), i.on("error", (a) => r(a)), i.on("exit", (a) => {
+        a === 0 ? e() : r(new Error(o.trim() || "Claude CLI not available. Install and login with `claude`."));
+      });
+    }).catch((e) => {
+      const r = e instanceof Error ? e.message : "Claude CLI not available. Install and login with `claude` first.";
+      throw new Error(`${r}
+Use terminal: \`claude\` and complete login, then retry.`);
+    });
+  }
+}
+const Ut = 12e4;
+class Bt extends ne {
+  constructor() {
+    super(...arguments);
+    P(this, "model", "openrouter/auto");
+    P(this, "cwd", process.cwd());
+    P(this, "apiKey", "");
+    P(this, "baseUrl", "https://openrouter.ai/api/v1");
+    P(this, "history", []);
+    P(this, "activeController", null);
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  async connect(e) {
+    var r;
+    if (this.model = (e.model || "openrouter/auto").trim(), this.cwd = e.cwd || process.cwd(), this.apiKey = (e.apiKey || "").trim(), this.baseUrl = (e.baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, ""), this.history = (((r = e.initialHistory) == null ? void 0 : r.length) ?? 0) > 0 ? e.initialHistory.slice(-24) : [], !this.apiKey) throw new Error("OpenRouter API key is missing. Configure it in Settings -> Connectivity.");
+    return this.emitEvent({ type: "status", status: "ready", message: "Connected" }), { threadId: "openrouter" };
+  }
+  async sendUserMessage(e) {
+    var m, g, x;
+    const r = e.trim();
+    if (!r) return;
+    const s = Y(r, this.cwd), i = r + s;
+    this.history.push({ role: "user", text: i });
+    const o = ce(this.cwd), a = `You are a coding assistant running inside Barnaby.
+Workspace root: ${this.cwd}
+
+${o}`, c = this.history.slice(-12), u = [
+      { role: "system", content: a },
+      ...c.map((E) => ({ role: E.role, content: E.text }))
+    ], l = new AbortController();
+    this.activeController = l;
+    const p = setTimeout(() => l.abort("timeout"), Ut);
+    this.emitEvent({ type: "status", status: "starting", message: "Sending request to OpenRouter..." });
+    try {
+      const E = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "HTTP-Referer": "https://barnaby.build",
+          "X-Title": "Barnaby"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: u,
+          temperature: 0.2,
+          stream: !1
+        }),
+        signal: l.signal
+      });
+      if (!E.ok) {
+        const A = await E.text().catch(() => ""), v = A ? ` ${A.slice(0, 400)}` : "";
+        throw new Error(`OpenRouter request failed (${E.status}).${v}`);
+      }
+      const w = await E.json(), b = (x = (g = (m = w == null ? void 0 : w.choices) == null ? void 0 : m[0]) == null ? void 0 : g.message) == null ? void 0 : x.content, y = Array.isArray(b) ? b.map((A) => typeof (A == null ? void 0 : A.text) == "string" ? A.text : "").join("") : typeof b == "string" ? b : "";
+      this.history.push({ role: "assistant", text: y }), w != null && w.usage && this.emitEvent({ type: "usageUpdated", usage: w.usage }), this.emitEvent({ type: "assistantDelta", delta: y }), this.emitEvent({ type: "assistantCompleted" }), this.emitEvent({ type: "status", status: "ready", message: "Connected" });
+    } catch (E) {
+      const w = E instanceof Error ? E.name === "AbortError" ? "OpenRouter request timed out." : E.message : String(E);
+      this.emitEvent({ type: "status", status: "error", message: w }), this.emitEvent({ type: "assistantCompleted" });
+    } finally {
+      clearTimeout(p), this.activeController === l && (this.activeController = null);
+    }
+  }
+  async interruptActiveTurn() {
+    if (this.activeController)
+      try {
+        this.activeController.abort("interrupted");
+      } catch {
+      } finally {
+        this.activeController = null;
+      }
+  }
+  async close() {
+    await this.interruptActiveTurn(), this.history = [];
+  }
+}
+const zt = 12e4, qt = 8, Ke = 14e3, be = 35e4, Je = 60, Ge = 1200, Kt = 4, Jt = 12e4, Gt = 3e5;
+class Vt extends ne {
+  constructor() {
+    super(...arguments);
+    P(this, "model", "gpt-4o");
+    P(this, "cwd", process.cwd());
+    P(this, "apiKey", "");
+    P(this, "baseUrl", "https://api.openai.com/v1");
+    P(this, "permissionMode", "verify-first");
+    P(this, "sandbox", "workspace-write");
+    P(this, "allowedCommandPrefixes", []);
+    P(this, "history", []);
+    P(this, "activeController", null);
+  }
+  emitEvent(e) {
+    this.emit("event", e);
+  }
+  async connect(e) {
+    var r;
+    if (this.model = (e.model || "gpt-4o").trim(), this.cwd = e.cwd || process.cwd(), this.apiKey = (e.apiKey || "").trim(), this.baseUrl = (e.baseUrl || "https://api.openai.com/v1").replace(/\/+$/, ""), this.permissionMode = e.permissionMode === "proceed-always" ? "proceed-always" : "verify-first", this.sandbox = e.sandbox === "read-only" ? "read-only" : "workspace-write", this.allowedCommandPrefixes = Array.isArray(e.allowedCommandPrefixes) ? e.allowedCommandPrefixes.filter((s) => typeof s == "string").map((s) => s.trim()).filter(Boolean) : [], this.history = (((r = e.initialHistory) == null ? void 0 : r.length) ?? 0) > 0 ? e.initialHistory.slice(-24) : [], !this.apiKey) throw new Error("OpenAI API key is missing. Configure it in Settings -> Connectivity.");
+    return this.emitEvent({ type: "status", status: "ready", message: "Connected" }), { threadId: "openai" };
+  }
+  async sendUserMessage(e) {
+    const r = e.trim();
+    if (!r) return;
+    const s = Y(r, this.cwd), i = r + s;
+    await this.sendUserMessageInternal(i, i);
+  }
+  async sendUserMessageWithImages(e, r) {
+    const s = e.trim(), i = (r ?? []).filter((l) => typeof l == "string" && l.trim().length > 0).slice(0, Kt);
+    if (!s && i.length === 0) return;
+    const o = Y(s, this.cwd), a = `${s}${o}`.trim(), c = [];
+    a && c.push({ type: "text", text: a });
+    for (const l of i) {
+      const p = this.pathToDataUrl(l);
+      p && c.push({ type: "image_url", image_url: { url: p } });
+    }
+    if (c.length === 0) return;
+    const u = i.length > 0 ? `
+
+Attached images:
+${i.map((l) => `- ${h.basename(l)}`).join(`
+`)}` : "";
+    await this.sendUserMessageInternal(a + u, c);
+  }
+  async sendUserMessageInternal(e, r) {
+    var l;
+    this.history.push({ role: "user", text: e });
+    const s = ce(this.cwd), i = `You are Barnaby's OpenAI API coding agent.
+Workspace root: ${this.cwd}
+Permission mode: ${this.permissionMode}
+Sandbox mode: ${this.sandbox}
+
+${s}
+
+Rules:
+- If the user asks for code/config changes, implement them directly using tools in this turn whenever possible.
+- Prefer action over deferral: locate files, apply edits, and report what changed.
+- Use tools for repository contents, symbols, behavior, implementation details, and file edits.
+- If the user asks to run build/test/dev commands, use run_shell_command instead of returning a checklist.
+- Never invent file names, symbols, or behavior. If not verified via tool output, say so.
+- Cite concrete evidence in your answer (file path and line numbers when available).
+- Keep working until you have either completed the requested change or can clearly explain the precise blocker.`, o = this.history.slice(-12), a = [
+      { role: "system", content: i },
+      ...o.map((p) => ({ role: p.role, content: p.text }))
+    ];
+    a.length > 0 && ((l = a[a.length - 1]) == null ? void 0 : l.role) === "user" && (a[a.length - 1] = { role: "user", content: r });
+    const c = new AbortController();
+    this.activeController = c;
+    const u = setTimeout(() => c.abort("timeout"), zt);
+    this.emitEvent({ type: "status", status: "starting", message: "Running OpenAI agent turn..." });
+    try {
+      const p = await this.runAgentLoop(a, c);
+      this.history.push({ role: "assistant", text: p }), this.emitEvent({ type: "assistantDelta", delta: p }), this.emitEvent({ type: "assistantCompleted" }), this.emitEvent({ type: "status", status: "ready", message: "Connected" });
+    } catch (p) {
+      const m = c.signal.aborted, g = String(c.signal.reason ?? ""), x = p instanceof Error ? m && g === "interrupted" ? "OpenAI request interrupted." : m && g === "timeout" ? "OpenAI request timed out." : p.message : String(p);
+      this.emitEvent({ type: "status", status: "error", message: x }), this.emitEvent({ type: "assistantCompleted" });
+    } finally {
+      clearTimeout(u), this.activeController === c && (this.activeController = null);
+    }
+  }
+  async runAgentLoop(e, r) {
+    var o, a, c, u, l;
+    const s = [...e];
+    let i = "";
+    for (let p = 0; p < qt; p++) {
+      const m = await this.fetchCompletionWithRetries(s, r);
+      m != null && m.usage && this.emitEvent({ type: "usageUpdated", usage: m.usage });
+      const g = (a = (o = m == null ? void 0 : m.choices) == null ? void 0 : o[0]) == null ? void 0 : a.message, x = this.extractAssistantText(g == null ? void 0 : g.content);
+      x && (i = x);
+      const E = Array.isArray(g == null ? void 0 : g.tool_calls) ? g.tool_calls : [];
+      if (E.length === 0)
+        return x || "No response content returned by OpenAI.";
+      const w = E.map((y, A) => ({
+        ...y,
+        id: y.id || `tool_${p}_${A}`,
+        type: y.type || "function"
+      })), b = {
+        role: "assistant",
+        content: x || null,
+        tool_calls: w
+      };
+      s.push(b);
+      for (let y = 0; y < w.length; y++) {
+        const A = w[y], v = A.id, S = ((c = A.function) == null ? void 0 : c.name) || "unknown_tool", C = this.safeToolArgsPreview((u = A.function) == null ? void 0 : u.arguments);
+        this.emitEvent({
+          type: "thinking",
+          message: C ? `Using ${S}(${C})` : `Using ${S}`
+        });
+        const R = await this.runTool(S, (l = A.function) == null ? void 0 : l.arguments);
+        s.push({
+          role: "tool",
+          tool_call_id: v,
+          content: R
+        });
+      }
+    }
+    return i || "Stopped after too many tool steps without a final answer.";
+  }
+  async fetchCompletionWithRetries(e, r) {
+    for (let i = 0; i <= 3; i++) {
+      const o = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: e,
+          tools: this.agentTools(),
+          tool_choice: "auto",
+          temperature: 0.1,
+          stream: !1
+        }),
+        signal: r.signal
+      });
+      if (o.ok)
+        return o.json();
+      const a = o.headers.get("retry-after"), c = await o.text().catch(() => ""), u = this.getRetryDelayMs(o.status, a, c, i);
+      if (u > 0 && i < 3) {
+        const m = (u / 1e3).toFixed(1).replace(/\.0$/, "");
+        this.emitEvent({
+          type: "thinking",
+          message: `OpenAI rate limited — retrying in ${m}s...`
+        }), await this.sleepWithAbort(u, r.signal);
+        continue;
+      }
+      const p = c ? ` ${c.slice(0, 500)}` : "";
+      throw new Error(`OpenAI request failed (${o.status}).${p}`);
+    }
+    throw new Error("OpenAI request failed after retries.");
+  }
+  getRetryDelayMs(e, r, s, i) {
+    if (e !== 429) return 0;
+    if (r) {
+      const a = Number(r);
+      if (Number.isFinite(a) && a > 0)
+        return Math.max(250, Math.round(a * 1e3));
+      const c = Date.parse(r);
+      if (!Number.isNaN(c)) {
+        const u = c - Date.now();
+        if (u > 0) return u;
+      }
+    }
+    const o = s.match(/try again in\s*([\d.]+)\s*s/i);
+    if (o) {
+      const a = Number(o[1]);
+      if (Number.isFinite(a) && a > 0)
+        return Math.max(250, Math.round(a * 1e3));
+    }
+    return Math.min(12e3, 2e3 * 2 ** i);
+  }
+  async sleepWithAbort(e, r) {
+    if (r.aborted) throw new Error("aborted");
+    await new Promise((s, i) => {
+      const o = setTimeout(() => {
+        r.removeEventListener("abort", a), s();
+      }, e), a = () => {
+        clearTimeout(o), r.removeEventListener("abort", a), i(new Error("aborted"));
+      };
+      r.addEventListener("abort", a);
+    });
+  }
+  extractAssistantText(e) {
+    return typeof e == "string" ? e : Array.isArray(e) ? e.map((r) => typeof (r == null ? void 0 : r.text) == "string" ? r.text : "").join("") : "";
+  }
+  agentTools() {
+    return [
+      {
+        type: "function",
+        function: {
+          name: "list_workspace_tree",
+          description: "List the current workspace tree (truncated).",
+          parameters: {
+            type: "object",
+            additionalProperties: !1,
+            properties: {}
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "search_workspace",
+          description: "Search text in workspace files. Returns file:line snippets.",
+          parameters: {
+            type: "object",
+            additionalProperties: !1,
+            properties: {
+              query: { type: "string", description: "Text to search for." },
+              caseSensitive: { type: "boolean" }
+            },
+            required: ["query"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "read_workspace_file",
+          description: "Read a text file from the workspace with optional line range.",
+          parameters: {
+            type: "object",
+            additionalProperties: !1,
+            properties: {
+              path: { type: "string", description: "Relative path from workspace root." },
+              startLine: { type: "integer" },
+              endLine: { type: "integer" }
+            },
+            required: ["path"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "write_workspace_file",
+          description: "Write UTF-8 text to a workspace file path. Use this to apply requested code changes.",
+          parameters: {
+            type: "object",
+            additionalProperties: !1,
+            properties: {
+              path: { type: "string", description: "Relative path from workspace root." },
+              content: { type: "string", description: "Full file content to write." }
+            },
+            required: ["path", "content"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "run_shell_command",
+          description: "Run a shell command in the workspace root (subject to permission mode and allowed command prefixes).",
+          parameters: {
+            type: "object",
+            additionalProperties: !1,
+            properties: {
+              command: { type: "string", description: "Command line to execute." },
+              timeoutMs: { type: "integer", description: "Optional timeout in milliseconds." }
+            },
+            required: ["command"]
+          }
+        }
+      }
+    ];
+  }
+  async runTool(e, r) {
+    let s = {};
+    if (typeof r == "string" && r.trim())
+      try {
+        s = JSON.parse(r);
+      } catch {
+        return "Tool error: Invalid JSON arguments.";
+      }
+    if (e === "list_workspace_tree")
+      return this.limitToolOutput(ce(this.cwd));
+    if (e === "search_workspace")
+      return this.limitToolOutput(this.searchWorkspace(s));
+    if (e === "read_workspace_file")
+      return this.limitToolOutput(this.readWorkspaceFile(s));
+    if (e === "write_workspace_file")
+      return this.limitToolOutput(this.writeWorkspaceFile(s));
+    if (e === "run_shell_command") {
+      const i = await this.runShellCommand(s);
+      return this.limitToolOutput(i);
+    }
+    return `Tool error: Unknown tool "${e}".`;
+  }
+  resolveWorkspacePath(e) {
+    if (typeof e != "string" || !e.trim())
+      return { ok: !1, error: "Path is required." };
+    const r = h.resolve(this.cwd), s = e.trim(), i = h.resolve(r, s), o = h.relative(r, i);
+    return !o || o === "." ? { ok: !1, error: "Path must point to a file inside the workspace." } : o.startsWith("..") || h.isAbsolute(o) ? { ok: !1, error: "Path escapes workspace root." } : { ok: !0, absolute: i, relative: o.replace(/\\/g, "/") };
+  }
+  readWorkspaceFile(e) {
+    const r = this.resolveWorkspacePath(e.path);
+    if (!r.ok) return `Tool error: ${r.error}`;
+    let s;
+    try {
+      s = d.statSync(r.absolute);
+    } catch {
+      return `Tool error: File not found: ${r.relative}`;
+    }
+    if (!s.isFile()) return `Tool error: Not a file: ${r.relative}`;
+    const i = d.readFileSync(r.absolute);
+    if (i.includes(0)) return `Tool error: File appears binary and cannot be read as text: ${r.relative}`;
+    const o = i.toString("utf8");
+    if (o.length > be)
+      return `Tool error: File too large (${o.length} chars). Use search_workspace or narrower line range.`;
+    const a = o.split(/\r?\n/), c = a.length, u = typeof e.startLine == "number" ? Math.floor(e.startLine) : 1, l = typeof e.endLine == "number" ? Math.floor(e.endLine) : Math.min(c, u + 220), p = Math.min(Math.max(u, 1), c), m = Math.min(Math.max(l, p), c), g = a.slice(p - 1, m).map((x, E) => `${p + E}: ${x}`).join(`
+`);
+    return `File: ${r.relative}
+Lines: ${p}-${m} of ${c}
+
+${g}`;
+  }
+  writeWorkspaceFile(e) {
+    if (this.sandbox === "read-only")
+      return "Tool error: Workspace is read-only (sandbox mode).";
+    if (this.permissionMode !== "proceed-always")
+      return "Tool error: Write denied in verify-first mode. Set permissions to Proceed always for autonomous edits.";
+    const r = this.resolveWorkspacePath(e.path);
+    if (!r.ok) return `Tool error: ${r.error}`;
+    if (typeof e.content != "string")
+      return "Tool error: content must be a string.";
+    const s = e.content;
+    if (s.length > be)
+      return `Tool error: Refusing to write large payload (${s.length} chars).`;
+    try {
+      const i = h.dirname(r.absolute);
+      if (!d.existsSync(i))
+        return `Tool error: Parent directory does not exist: ${h.relative(this.cwd, i).replace(/\\/g, "/")}`;
+      d.writeFileSync(r.absolute, s, "utf8");
+      const o = s.length === 0 ? 0 : s.split(/\r?\n/).length;
+      return `Wrote file: ${r.relative} (${s.length} chars, ${o} lines).`;
+    } catch (i) {
+      const o = i instanceof Error ? i.message : String(i);
+      return `Tool error: Failed writing ${r.relative}: ${o}`;
+    }
+  }
+  async runShellCommand(e) {
+    if (this.sandbox === "read-only")
+      return "Tool error: Workspace is read-only (sandbox mode).";
+    if (this.permissionMode !== "proceed-always")
+      return "Tool error: Command execution denied in verify-first mode. Set permissions to Proceed always.";
+    const r = typeof e.command == "string" ? e.command.trim() : "";
+    if (!r) return "Tool error: command is required.";
+    if (this.allowedCommandPrefixes.length > 0 && !this.allowedCommandPrefixes.some((a) => r.startsWith(a)))
+      return `Tool error: Command not in allowlist. Allowed prefixes: ${this.allowedCommandPrefixes.join(", ")}`;
+    const s = typeof e.timeoutMs == "number" ? Math.floor(e.timeoutMs) : Jt, i = Math.max(500, Math.min(Gt, s));
+    return this.runShellCommandAsync(r, i);
+  }
+  async runShellCommandAsync(e, r) {
+    const s = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "/bin/sh", i = process.platform === "win32" ? ["/d", "/s", "/c", e] : ["-lc", e];
+    try {
+      const o = I(s, i, {
+        cwd: this.cwd,
+        env: process.env,
+        windowsHide: !0
+      });
+      let a = "", c = "", u = !1;
+      o.stdout && (o.stdout.setEncoding("utf8"), o.stdout.on("data", (b) => {
+        a += b;
+      })), o.stderr && (o.stderr.setEncoding("utf8"), o.stderr.on("data", (b) => {
+        c += b;
+      }));
+      const l = new Promise((b) => {
+        o.on("exit", (y, A) => b({ code: y, signal: A }));
+      });
+      let p = null;
+      const m = new Promise((b) => {
+        p = setTimeout(() => {
+          u = !0;
+          try {
+            o.kill("SIGTERM");
+          } catch {
+          }
+          b({ timeout: !0 });
+        }, r);
+      }), g = await Promise.race([l, m]);
+      if (p && clearTimeout(p), "timeout" in g)
+        return `Command timed out after ${r}ms.
+
+stdout:
+${a || "(empty)"}
+
+stderr:
+${c || "(empty)"}`;
+      const x = g.code ?? -1, E = g.signal ?? "";
+      return `${`exit_code=${x}${E ? ` signal=${E}` : ""}${u ? " timeout=true" : ""}`}
+
+stdout:
+${a || "(empty)"}
+
+stderr:
+${c || "(empty)"}`;
+    } catch (o) {
+      return `Tool error: Failed to run command: ${o instanceof Error ? o.message : String(o)}`;
+    }
+  }
+  searchWorkspace(e) {
+    const r = typeof e.query == "string" ? e.query.trim() : "";
+    if (!r) return "Tool error: query is required.";
+    const s = !!e.caseSensitive, i = h.resolve(this.cwd), o = /* @__PURE__ */ new Set([
+      ".git",
+      "node_modules",
+      "dist",
+      "dist-electron",
+      "release",
+      "build",
+      ".barnaby",
+      ".next",
+      ".nuxt",
+      ".output",
+      "coverage"
+    ]), a = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".webp",
+      ".ico",
+      ".pdf",
+      ".zip",
+      ".gz",
+      ".exe",
+      ".dll",
+      ".woff",
+      ".woff2",
+      ".ttf",
+      ".mp4",
+      ".mp3",
+      ".icns",
+      ".bin",
+      ".map",
+      ".lock"
+    ]), c = [i], u = [];
+    let l = 0, p = !1;
+    const m = s ? r : r.toLowerCase();
+    for (; c.length > 0 && u.length < Je; ) {
+      const x = c.pop();
+      let E;
+      try {
+        E = d.readdirSync(x, { withFileTypes: !0 });
+      } catch {
+        continue;
+      }
+      for (const w of E) {
+        const b = w.name;
+        if (!b || b.startsWith(".")) continue;
+        const y = h.join(x, b);
+        if (w.isDirectory()) {
+          if (o.has(b)) continue;
+          c.push(y);
+          continue;
+        }
+        if (!w.isFile()) continue;
+        const A = h.extname(b).toLowerCase();
+        if (a.has(A)) continue;
+        if (l++, l > Ge) {
+          p = !0;
+          break;
+        }
+        let v = "";
+        try {
+          if (d.statSync(y).size > be) continue;
+          const R = d.readFileSync(y);
+          if (R.includes(0)) continue;
+          v = R.toString("utf8");
+        } catch {
+          continue;
+        }
+        const S = v.split(/\r?\n/);
+        for (let C = 0; C < S.length; C++) {
+          const R = S[C];
+          if (!(s ? R : R.toLowerCase()).includes(m)) continue;
+          const Et = h.relative(i, y).replace(/\\/g, "/"), Ct = R.length > 220 ? R.slice(0, 220) + "..." : R;
+          if (u.push(`${Et}:${C + 1}: ${Ct}`), u.length >= Je) break;
+        }
+      }
+      if (p) break;
+    }
+    return u.length === 0 ? `No matches for "${r}".` : `${p ? `Results for "${r}" (truncated after scanning ${Ge} files):` : `Results for "${r}":`}
+${u.join(`
+`)}`;
+  }
+  limitToolOutput(e) {
+    return e.length <= Ke ? e : `${e.slice(0, Ke)}
+... [truncated]`;
+  }
+  safeToolArgsPreview(e) {
+    if (!e || !e.trim()) return "";
+    const r = e.replace(/\s+/g, " ").trim();
+    return r.length > 120 ? r.slice(0, 120) + "..." : r;
+  }
+  pathToDataUrl(e) {
+    const r = h.isAbsolute(e) ? e : h.resolve(this.cwd, e);
+    let s;
+    try {
+      s = d.statSync(r);
+    } catch {
+      return null;
+    }
+    if (!s.isFile() || s.size > 8 * 1024 * 1024) return null;
+    let i;
+    try {
+      i = d.readFileSync(r);
+    } catch {
+      return null;
+    }
+    const o = h.extname(r).toLowerCase(), a = o === ".png" ? "image/png" : o === ".jpg" || o === ".jpeg" ? "image/jpeg" : o === ".webp" ? "image/webp" : o === ".gif" ? "image/gif" : null;
+    return a ? `data:${a};base64,${i.toString("base64")}` : null;
+  }
+  async interruptActiveTurn() {
+    if (this.activeController)
+      try {
+        this.activeController.abort("interrupted");
+      } catch {
+      } finally {
+        this.activeController = null;
+      }
+  }
+  async close() {
+    await this.interruptActiveTurn(), this.history = [];
+  }
+}
+function Oe(n) {
+  const t = h.join(n(), "orchestrator-secrets.json");
+  if (!d.existsSync(t)) return {};
+  try {
+    const e = d.readFileSync(t, "utf8");
+    if (!e.trim()) return {};
+    const r = JSON.parse(e);
+    if (!r || typeof r != "object" || Array.isArray(r)) return {};
+    const s = r;
+    return { licenseKey: typeof s.licenseKey == "string" ? s.licenseKey : void 0 };
+  } catch {
+    return {};
+  }
+}
+function Xt(n, t) {
+  const e = n(), r = h.join(e, "orchestrator-secrets.json");
+  d.mkdirSync(h.dirname(r), { recursive: !0 }), d.writeFileSync(r, JSON.stringify(t, null, 2), "utf8");
+}
+function Yt(n) {
+  const t = h.join(n(), "orchestrator-settings.json");
+  if (!d.existsSync(t)) return {};
+  try {
+    const e = d.readFileSync(t, "utf8");
+    if (!e.trim()) return {};
+    const r = JSON.parse(e);
+    return !r || typeof r != "object" || Array.isArray(r) ? {} : r;
+  } catch {
+    return {};
+  }
+}
+function Zt(n, t) {
+  const e = n(), r = h.join(e, "orchestrator-settings.json");
+  d.mkdirSync(h.dirname(r), { recursive: !0 }), d.writeFileSync(r, JSON.stringify(t, null, 2), "utf8");
+}
+const Qt = [
+  "node_modules/@barnaby",
+  "node_modules/@barnaby.build"
+], er = 1e4, tr = 5e3;
+let V = null;
+const Z = /* @__PURE__ */ new Map();
+let K = null, O = null, q = null;
+const J = /* @__PURE__ */ new Map(), le = /* @__PURE__ */ new Set(), G = /* @__PURE__ */ new Map();
+function rr(n) {
+  V = n;
+}
+function nr(n) {
+  O = n;
+}
+function Fe(n, ...t) {
+  !V || V.isDestroyed() || V.webContents.send(n, ...t);
+}
+function ee(n, ...t) {
+  return new Promise((e, r) => {
+    if (!V || V.isDestroyed()) {
+      r(new Error("No renderer window available"));
+      return;
+    }
+    const s = `${n}:response:${Date.now()}-${Math.random().toString(16).slice(2)}`, i = setTimeout(() => {
+      f.removeHandler(s), r(new Error(`Plugin host IPC timeout on ${n}`));
+    }, 3e4);
+    f.handleOnce(s, (o, a) => {
+      clearTimeout(i), a.ok ? e(a.data) : r(new Error(a.error ?? "Unknown renderer error"));
+    }), Fe("barnaby:plugin-host:request", { channel: n, responseChannel: s, args: t });
+  });
+}
+function sr() {
+  return {
+    async createPanel(n) {
+      return ee("plugin:createPanel", n ?? {});
+    },
+    async closePanel(n) {
+      return ee("plugin:closePanel", n);
+    },
+    async sendMessage(n, t, e) {
+      return ee("plugin:sendMessage", n, t, e ?? []);
+    },
+    async interruptPanel(n) {
+      return ee("plugin:interruptPanel", n);
+    },
+    getPanelInfo(n) {
+      return null;
+    },
+    getPanelMessages(n) {
+      return [];
+    },
+    listPanels() {
+      return [];
+    },
+    onPanelEvent(n, t) {
+      return J.has(n) || J.set(n, /* @__PURE__ */ new Set()), J.get(n).add(t), {
+        dispose() {
+          var e;
+          (e = J.get(n)) == null || e.delete(t);
+        }
+      };
+    },
+    onAnyPanelEvent(n) {
+      return le.add(n), {
+        dispose() {
+          le.delete(n);
+        }
+      };
+    },
+    onPanelTurnComplete(n, t) {
+      return G.has(n) || G.set(n, /* @__PURE__ */ new Set()), G.get(n).add(t), {
+        dispose() {
+          var e;
+          (e = G.get(n)) == null || e.delete(t);
+        }
+      };
+    },
+    async readFile(n) {
+      const t = (O == null ? void 0 : O()) ?? "";
+      if (!t) throw new Error("No workspace root set");
+      const e = h.join(t, n), r = d.statSync(e), s = d.readFileSync(e, "utf-8");
+      return { relativePath: n, size: r.size, content: s };
+    },
+    async writeFile(n, t) {
+      const e = (O == null ? void 0 : O()) ?? "";
+      if (!e) throw new Error("No workspace root set");
+      const r = h.join(e, n);
+      d.mkdirSync(h.dirname(r), { recursive: !0 }), d.writeFileSync(r, t, "utf-8");
+      const s = d.statSync(r);
+      return { relativePath: n, size: s.size };
+    },
+    async listFiles(n) {
+      return ee("plugin:listFiles", n ?? {});
+    },
+    getWorkspaceRoot() {
+      return (O == null ? void 0 : O()) ?? "";
+    },
+    registerDockPane(n, t) {
+      Fe("barnaby:plugin-host:dock-pane-registered", { pluginId: n });
+    },
+    getSetting(n) {
+      const t = q == null ? void 0 : q();
+      if (t) {
+        const e = Yt(() => t), s = {
+          "orchestrator.orchestratorModel": "orchestratorModel",
+          "orchestrator.workerProvider": "workerProvider",
+          "orchestrator.workerModel": "workerModel",
+          "orchestrator.maxParallelPanels": "maxParallelPanels",
+          "orchestrator.maxTaskAttempts": "maxTaskAttempts"
+        }[n];
+        if (s && e[s] !== void 0) return e[s];
+      }
+      try {
+        const e = (O == null ? void 0 : O()) ?? "";
+        if (!e) return;
+        const r = h.join(e, ".barnaby", "plugin-settings.json");
+        return d.existsSync(r) ? JSON.parse(d.readFileSync(r, "utf-8"))[n] : void 0;
+      } catch {
+        return;
+      }
+    },
+    setSetting(n, t) {
+      try {
+        const e = (O == null ? void 0 : O()) ?? "";
+        if (!e) return;
+        const r = h.join(e, ".barnaby"), s = h.join(r, "plugin-settings.json");
+        d.mkdirSync(r, { recursive: !0 });
+        let i = {};
+        try {
+          i = JSON.parse(d.readFileSync(s, "utf-8"));
+        } catch {
+        }
+        i[n] = t, d.writeFileSync(s, JSON.stringify(i, null, 2), "utf-8");
+      } catch {
+      }
+    },
+    getOrchestratorLicenseKeyState() {
+      const n = q == null ? void 0 : q();
+      return n ? { hasKey: (Oe(() => n).licenseKey ?? "").trim().length > 0 } : { hasKey: !1 };
+    },
+    log(n, t, e) {
+      const r = `[plugin:${n}]`;
+      t === "error" ? console.error(r, e) : t === "warn" ? console.warn(r, e) : console.log(r, e);
+    }
+  };
+}
+function ir(n, t) {
+  const e = J.get(n);
+  if (e)
+    for (const r of e)
+      try {
+        r(t);
+      } catch (s) {
+        console.error("[pluginHost] panel event handler error:", s);
+      }
+  for (const r of le)
+    try {
+      r(n, t);
+    } catch (s) {
+      console.error("[pluginHost] anyPanel event handler error:", s);
+    }
+}
+function or(n) {
+  const t = G.get(n);
+  if (t)
+    for (const e of t)
+      try {
+        e();
+      } catch (r) {
+        console.error("[pluginHost] turn complete handler error:", r);
+      }
+}
+function ar(n) {
+  var r, s, i;
+  const t = [];
+  for (const o of Qt) {
+    const a = h.join(n, o);
+    if (d.existsSync(a))
+      try {
+        const c = d.readdirSync(a, { withFileTypes: !0 });
+        for (const u of c) {
+          if (!u.isDirectory() && !u.isSymbolicLink()) continue;
+          const l = h.join(a, u.name, "package.json");
+          if (d.existsSync(l))
+            try {
+              ((r = JSON.parse(d.readFileSync(l, "utf-8")).barnaby) == null ? void 0 : r.plugin) === !0 && t.push(h.join(a, u.name));
+            } catch {
+            }
+        }
+      } catch {
+      }
+  }
+  const e = h.join(Q.homedir(), ".barnaby", "plugins");
+  if (d.existsSync(e))
+    try {
+      const o = d.readdirSync(e, { withFileTypes: !0 });
+      for (const a of o) {
+        if (!a.isDirectory() && !a.isSymbolicLink()) continue;
+        const c = h.join(e, a.name, "package.json");
+        if (d.existsSync(c))
+          try {
+            ((s = JSON.parse(d.readFileSync(c, "utf-8")).barnaby) == null ? void 0 : s.plugin) === !0 && t.push(h.join(e, a.name));
+          } catch {
+          }
+      }
+    } catch {
+    }
+  for (const o of ["@barnaby", "@barnaby.build"]) {
+    const a = h.join(e, "node_modules", o);
+    if (d.existsSync(a))
+      try {
+        const c = d.readdirSync(a, { withFileTypes: !0 });
+        for (const u of c) {
+          if (!u.isDirectory() && !u.isSymbolicLink()) continue;
+          const l = h.join(a, u.name, "package.json");
+          if (d.existsSync(l))
+            try {
+              ((i = JSON.parse(d.readFileSync(l, "utf-8")).barnaby) == null ? void 0 : i.plugin) === !0 && t.push(h.join(a, u.name));
+            } catch {
+            }
+        }
+      } catch {
+      }
+  }
+  return t;
+}
+async function Qe(n, t) {
+  var s;
+  q = t ?? null, console.log(`[pluginHost] Initializing plugin host (appRoot: ${n})`);
+  const e = ar(n);
+  console.log(`[pluginHost] Discovered ${e.length} plugin(s): ${e.join(", ") || "(none)"}`);
+  const r = sr();
+  for (const i of e)
+    try {
+      const a = JSON.parse(d.readFileSync(h.join(i, "package.json"), "utf-8")).main ?? "index.js", c = h.resolve(i, a), u = await import(Mt(c).href), l = u.default ?? u;
+      if (!l.pluginId || typeof l.activate != "function") {
+        console.warn(`[pluginHost] Skipping invalid plugin at ${i}`);
+        continue;
+      }
+      if (Z.has(l.pluginId)) {
+        console.warn(`[pluginHost] Duplicate plugin ID "${l.pluginId}" at ${i}, skipping`);
+        continue;
+      }
+      await l.activate(r);
+      const p = ((s = l.getLifecycleConfig) == null ? void 0 : s.call(l)) ?? null;
+      Z.set(l.pluginId, { plugin: l, lifecycleConfig: p, active: !0 }), console.log(`[pluginHost] Activated plugin: ${l.displayName} v${l.version}`);
+    } catch (o) {
+      console.error(`[pluginHost] Failed to load plugin at ${i}:`, o);
+    }
+  cr();
+}
+function cr() {
+  K || (K = setInterval(() => {
+    for (const [n, t] of Z) {
+      if (!t.active || !t.lifecycleConfig) continue;
+      const e = t.lifecycleConfig;
+      try {
+        if (!d.existsSync(e.stateFilePath)) continue;
+        const r = d.readFileSync(e.stateFilePath, "utf-8"), i = JSON.parse(r)[e.heartbeatField];
+        if (typeof i != "number" || !Number.isFinite(i)) continue;
+        const o = Date.now() - i;
+        o > e.staleThresholdMs + tr && (console.warn(`[pluginHost] Plugin "${n}" heartbeat is stale (${Math.round(o / 1e3)}s). Sending recovery signal.`), Fe("barnaby:plugin-host:recovery", {
+          pluginId: n,
+          recoveryPrompt: e.recoveryPrompt,
+          stateFilePath: e.stateFilePath,
+          staleness: o
+        }));
+      } catch {
+      }
+    }
+  }, er), typeof K.unref == "function" && K.unref());
+}
+async function De() {
+  var n, t;
+  K && (clearInterval(K), K = null);
+  for (const [e, r] of Z)
+    if (r.active)
+      try {
+        await ((t = (n = r.plugin).deactivate) == null ? void 0 : t.call(n)), r.active = !1, console.log(`[pluginHost] Deactivated plugin: ${e}`);
+      } catch (s) {
+        console.error(`[pluginHost] Error deactivating plugin "${e}":`, s);
+      }
+  Z.clear(), J.clear(), le.clear(), G.clear();
+}
+function lr() {
+  return Z;
+}
+const dr = Ft(import.meta.url);
+function ur() {
+  try {
+    return dr("node-pty");
+  } catch {
+    return null;
+  }
+}
+const pr = ".agentorchestrator.json", hr = ".barnaby", fr = "active-token.json", mr = 5e3, gr = 3e4, yr = "Agent Orchestrator", et = ".legacy-storage-migration-v1.json", Se = "agentorchestrator.chatHistory", Le = ".storage", tt = "chat-history.json", rt = "app-state.json", nt = "provider-secrets.json", wr = "runtime.log", vr = 200, kr = 2500, Ve = 1024 * 1024, br = 3e4, Sr = /* @__PURE__ */ new Set([
+  ".git",
+  "dist",
+  "dist-electron",
+  "release",
+  ".next",
+  "out",
+  ".turbo"
+]), N = Ot(Rt), st = h.dirname(It(import.meta.url));
+process.env.APP_ROOT = h.join(st, "../..");
+const _n = h.join(process.env.APP_ROOT, "dist-electron"), it = h.join(process.env.APP_ROOT, "dist"), X = process.env.VITE_DEV_SERVER_URL;
+process.env.VITE_PUBLIC = X ? h.join(process.env.APP_ROOT, "public") : it;
+const Ar = "com.agentorchestrator.app", xr = "Barnaby";
+Q.release().startsWith("6.1") && $.disableHardwareAcceleration();
+process.platform === "win32" && ($.setName(xr), $.setAppUserModelId(Ar));
+let k = null, B = null, Ee = [], de = !1;
+const ot = h.join(st, "../preload/index.mjs"), at = h.join(it, "index.html");
+let ie = null, Ce = !1, re = !1, oe = !1, ue = !1;
+const M = /* @__PURE__ */ new Map(), ct = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+let F = null;
+const W = /* @__PURE__ */ new Map();
+let H = null;
+function Pr() {
+  return process.defaultApp ? !process.argv.slice(1).filter(Boolean).some((e) => !e.startsWith("-")) : !1;
+}
+function j(n) {
+  return n.replace(/\\/g, "/");
+}
+function Te(n) {
+  try {
+    return d.statSync(n).isDirectory();
+  } catch {
+    return !1;
+  }
+}
+function ge() {
+  ie && (clearTimeout(ie), ie = null);
+}
+function ye() {
+  B && (B.isDestroyed() || B.close(), B = null);
+}
+function Xe(n) {
+  let t = "";
+  try {
+    d.existsSync(n) && (t = `data:image/png;base64,${d.readFileSync(n).toString("base64")}`);
+  } catch (s) {
+    D("splash-image-base64-failed", { splashImagePath: n, error: _(s) }, "warn");
+  }
+  const e = $.getVersion(), r = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Barnaby Splash</title>
+  <style>
+    html, body {
+      margin: 0;
+      width: 100%;
+      height: 100%;
+      background: #0b0b0b;
+      overflow: hidden;
+    }
+    .root {
+      width: 100%;
+      height: 100%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    img {
+      max-width: 90%;
+      max-height: 90%;
+      object-fit: contain;
+      user-select: none;
+      -webkit-user-drag: none;
+    }
+    .version {
+      position: fixed;
+      bottom: 8px;
+      right: 12px;
+      font-size: 11px;
+      color: white;
+      font-family: system-ui, sans-serif;
+      opacity: 0.8;
+    }
+  </style>
+</head>
+<body>
+  <div class="root">
+    ${t ? `<img src="${t}" alt="Barnaby splash" />` : ""}
+  </div>
+  <div class="version">${String(e).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</div>
+</body>
+</html>`;
+  return `data:text/html;charset=utf-8,${encodeURIComponent(r)}`;
+}
+function Er() {
+  const n = process.env.VITE_PUBLIC;
+  if (!n)
+    return D("splash-skipped", { reason: "vite-public-missing" }, "warn"), null;
+  const t = h.join(n, "splash.png"), e = h.join(n, "splash.html");
+  if (!d.existsSync(t))
+    return D("splash-skipped", { reason: "splash-image-missing", splashImagePath: t }, "warn"), null;
+  const r = d.existsSync(e), s = new L({
+    width: 560,
+    height: 360,
+    center: !0,
+    show: !0,
+    frame: !1,
+    resizable: !1,
+    minimizable: !1,
+    maximizable: !1,
+    fullscreenable: !1,
+    alwaysOnTop: !0,
+    skipTaskbar: !0,
+    backgroundColor: "#0b0b0b",
+    autoHideMenuBar: !0
+  });
+  s.setMenuBarVisibility(!1);
+  const i = () => {
+    s.webContents.executeJavaScript(
+      `(function(){var el=document.getElementById('version');if(el)el.textContent=${JSON.stringify($.getVersion())};})()`
+    ).catch(() => {
+    });
+  };
+  return r ? (s.webContents.once("did-finish-load", i), s.loadFile(e).catch((o) => {
+    D("splash-loadfile-failed", { splashHtmlPath: e, error: _(o) }, "warn"), s.loadURL(Xe(t)).catch(() => {
+    });
+  })) : (D("splash-html-missing-fallback", { splashHtmlPath: e }, "warn"), s.loadURL(Xe(t)).catch((o) => {
+    D("splash-fallback-loadurl-failed", { splashImagePath: t, error: _(o) }, "warn");
+  })), s.on("closed", () => {
+    B === s && (B = null);
+  }), s;
+}
+function Cr() {
+  !k || ue || (ue = !0, ge(), ye(), k.maximize(), k.show());
+}
+function $e() {
+  k && (ue || Ce && (oe && !re || Cr()));
+}
+function _e(n, t, e = /* @__PURE__ */ new Set()) {
+  d.mkdirSync(t, { recursive: !0 });
+  const r = d.readdirSync(n, { withFileTypes: !0 });
+  for (const s of r) {
+    if (e.has(s.name)) continue;
+    const i = h.join(n, s.name), o = h.join(t, s.name);
+    if (s.isDirectory()) {
+      _e(i, o, e);
+      continue;
+    }
+    s.isFile() && d.copyFileSync(i, o);
+  }
+}
+function Ye(n) {
+  if (!Te(n)) return !1;
+  const t = d.readdirSync(n, { withFileTypes: !0 }).filter((e) => e.isFile() && (e.name.endsWith(".ldb") || e.name.endsWith(".log"))).map((e) => h.join(n, e.name));
+  for (const e of t) {
+    let r = "";
+    try {
+      r = d.readFileSync(e, "latin1");
+    } catch {
+      continue;
+    }
+    let s = r.indexOf(Se);
+    for (; s >= 0; ) {
+      const i = r.slice(s, s + 240);
+      if (i.includes("[{") || i.includes("[\0{\0")) return !0;
+      s = r.indexOf(Se, s + Se.length);
+    }
+  }
+  return !1;
+}
+function se(n, t) {
+  try {
+    const e = h.join(n, et);
+    d.writeFileSync(
+      e,
+      JSON.stringify({ version: 1, status: t, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function Tr() {
+  const n = $.getPath("userData"), t = h.join(n, et);
+  if (d.existsSync(t)) return;
+  const e = h.join($.getPath("appData"), yr, "Local Storage", "leveldb"), r = h.join(n, "Local Storage", "leveldb");
+  if (!Te(e)) {
+    se(n, "skipped");
+    return;
+  }
+  if (!Ye(e)) {
+    se(n, "skipped");
+    return;
+  }
+  if (Ye(r)) {
+    se(n, "skipped");
+    return;
+  }
+  try {
+    if (Te(r)) {
+      const s = h.join(n, "Local Storage", `leveldb-pre-legacy-import-${Date.now()}`);
+      _e(r, s, /* @__PURE__ */ new Set(["LOCK"])), d.rmSync(r, { recursive: !0, force: !0 });
+    }
+    _e(e, r, /* @__PURE__ */ new Set(["LOCK"])), se(n, "migrated"), console.info("[Barnaby] Imported legacy chat history from Agent Orchestrator.");
+  } catch (s) {
+    console.warn("[Barnaby] Legacy chat history migration failed:", _(s));
+  }
+}
+function we(n, t) {
+  const e = h.resolve(n), r = t.split("/").filter(Boolean).join(h.sep), s = h.resolve(e, r), i = h.relative(e, s);
+  if (i.startsWith("..") || h.isAbsolute(i))
+    throw new Error("Path is outside the workspace root.");
+  return s;
+}
+function lt(n, t) {
+  const e = h.resolve(n), r = h.resolve(t), s = h.relative(e, r);
+  if (s.startsWith("..") || h.isAbsolute(s))
+    throw new Error("Path is outside the workspace root.");
+  return j(s);
+}
+function ve() {
+  return h.join($.getPath("userData"), Le, tt);
+}
+function U() {
+  return h.join($.getPath("userData"), Le);
+}
+function Ne() {
+  return h.join(U(), rt);
+}
+function We() {
+  return h.join(U(), wr);
+}
+function D(n, t, e = "info") {
+  try {
+    const r = We();
+    d.mkdirSync(h.dirname(r), { recursive: !0 });
+    const s = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      level: e,
+      pid: process.pid,
+      event: n,
+      detail: t ?? null
+    };
+    d.appendFileSync(r, `${JSON.stringify(s)}
+`, "utf8");
+  } catch {
+  }
+}
+function $r() {
+  const n = Ne();
+  if (!d.existsSync(n)) return null;
+  try {
+    const t = d.readFileSync(n, "utf8");
+    if (!t.trim()) return null;
+    const e = JSON.parse(t);
+    return e && typeof e == "object" && !Array.isArray(e) && "state" in e ? e.state ?? null : e;
+  } catch (t) {
+    return D("read-app-state-failed", _(t), "warn"), null;
+  }
+}
+function _r(n) {
+  const t = Ne(), e = {
+    version: 1,
+    savedAt: Date.now(),
+    state: n ?? null
+  };
+  return d.mkdirSync(h.dirname(t), { recursive: !0 }), d.writeFileSync(t, JSON.stringify(e, null, 2), "utf8"), {
+    ok: !0,
+    path: t,
+    savedAt: e.savedAt
+  };
+}
+function dt() {
+  return h.join(U(), nt);
+}
+function ut() {
+  const n = dt();
+  if (!d.existsSync(n)) return {};
+  try {
+    const t = d.readFileSync(n, "utf8");
+    if (!t.trim()) return {};
+    const e = JSON.parse(t);
+    return !e || typeof e != "object" || Array.isArray(e) ? {} : e;
+  } catch (t) {
+    return D("read-provider-secrets-failed", _(t), "warn"), {};
+  }
+}
+function Mr(n) {
+  const t = dt();
+  d.mkdirSync(h.dirname(t), { recursive: !0 }), d.writeFileSync(t, JSON.stringify(n, null, 2), "utf8");
+}
+function pe(n) {
+  var e;
+  return (((e = ut()[n]) == null ? void 0 : e.apiKey) ?? "").trim();
+}
+function pt(n, t) {
+  const e = ut(), r = t.trim();
+  return r ? e[n] = { ...e[n] ?? {}, apiKey: r } : delete e[n], Mr(e), { ok: !0, hasKey: r.length > 0 };
+}
+function Ir(n) {
+  const e = {
+    openrouter: "OPENROUTER_API_KEY",
+    codex: "OPENAI_API_KEY"
+  }[n];
+  if (!e)
+    return { ok: !1, hasKey: !1, imported: !1, detail: `No environment mapping for provider "${n}".` };
+  const r = (process.env[e] ?? "").trim();
+  return r ? { ok: !0, hasKey: pt(n, r).hasKey, imported: !0, detail: `Imported API key from ${e}.` } : { ok: !1, hasKey: !1, imported: !1, detail: `${e} is not set in this process environment.` };
+}
+function ht() {
+  return {
+    userDataPath: $.getPath("userData"),
+    storageDir: U(),
+    chatHistoryPath: ve(),
+    appStatePath: Ne(),
+    runtimeLogPath: We()
+  };
+}
+function ft(n) {
+  const t = ht();
+  switch (n) {
+    case "userData":
+      return { path: t.userDataPath, kind: "directory" };
+    case "storage":
+      return { path: t.storageDir, kind: "directory" };
+    case "chatHistory":
+      return { path: t.chatHistoryPath, kind: "file" };
+    case "appState":
+      return { path: t.appStatePath, kind: "file" };
+    case "runtimeLog":
+      return { path: t.runtimeLogPath, kind: "file" };
+  }
+}
+async function Rr(n) {
+  const t = typeof n == "string" ? n : void 0;
+  if (t !== "userData" && t !== "storage" && t !== "chatHistory" && t !== "appState" && t !== "runtimeLog")
+    return {
+      ok: !1,
+      path: "",
+      error: "Unknown diagnostics path target."
+    };
+  const e = ft(t);
+  if (!e)
+    return {
+      ok: !1,
+      path: "",
+      error: "Unknown diagnostics path target."
+    };
+  try {
+    e.kind === "directory" ? d.mkdirSync(e.path, { recursive: !0 }) : t === "runtimeLog" && (d.mkdirSync(h.dirname(e.path), { recursive: !0 }), d.existsSync(e.path) || d.writeFileSync(e.path, "", "utf8"));
+  } catch (s) {
+    return {
+      ok: !1,
+      path: e.path,
+      error: _(s)
+    };
+  }
+  const r = await z.openPath(e.path);
+  return {
+    ok: !r,
+    path: e.path,
+    error: r || void 0
+  };
+}
+function mt(n) {
+  return n === "chatHistory" || n === "appState" || n === "runtimeLog";
+}
+function Or(n, t) {
+  d.mkdirSync(h.dirname(t), { recursive: !0 }), d.existsSync(t) || d.writeFileSync(t, "", "utf8");
+}
+async function Fr(n) {
+  if (!mt(n))
+    return { ok: !1, path: "", error: "Unknown diagnostics file target." };
+  const t = ft(n);
+  if (!t || t.kind !== "file")
+    return { ok: !1, path: "", error: "Diagnostics target is not a file." };
+  try {
+    Or(n, t.path);
+    const e = d.readFileSync(t.path, "utf8");
+    return {
+      ok: !0,
+      path: t.path,
+      content: e,
+      writable: !1
+    };
+  } catch (e) {
+    return { ok: !1, path: t.path, error: _(e) };
+  }
+}
+async function Dr(n, t) {
+  return mt(n) ? { ok: !1, path: "", error: "Diagnostics files are read-only in this view." } : { ok: !1, path: "", error: "Unknown diagnostics file target." };
+}
+async function Lr() {
+  const n = ve(), t = h.dirname(n);
+  try {
+    d.mkdirSync(t, { recursive: !0 });
+  } catch (r) {
+    return {
+      ok: !1,
+      path: t,
+      error: _(r)
+    };
+  }
+  const e = await z.openPath(t);
+  return {
+    ok: !e,
+    path: t,
+    error: e || void 0
+  };
+}
+function Nr() {
+  const n = We();
+  try {
+    d.mkdirSync(h.dirname(n), { recursive: !0 }), d.existsSync(n) || d.writeFileSync(n, "", "utf8");
+  } catch (t) {
+    return {
+      ok: !1,
+      path: n,
+      error: _(t)
+    };
+  }
+  return z.openPath(n).then((t) => ({
+    ok: !t,
+    path: n,
+    error: t || void 0
+  }));
+}
+function Wr() {
+  process.on("uncaughtException", (n) => {
+    D("uncaughtException", { message: n == null ? void 0 : n.message, stack: n == null ? void 0 : n.stack }, "error");
+  }), process.on("unhandledRejection", (n) => {
+    D("unhandledRejection", n, "error");
+  }), $.on("render-process-gone", (n, t, e) => {
+    D(
+      "render-process-gone",
+      {
+        url: t.getURL(),
+        reason: e.reason,
+        exitCode: e.exitCode
+      },
+      "error"
+    );
+  }), $.on("child-process-gone", (n, t) => {
+    D(
+      "child-process-gone",
+      {
+        type: t.type,
+        reason: t.reason,
+        name: t.name,
+        serviceName: t.serviceName,
+        exitCode: t.exitCode
+      },
+      t.reason === "clean-exit" ? "info" : "warn"
+    );
+  });
+}
+function gt(n) {
+  if (!Array.isArray(n)) return [];
+  const t = process.env.APP_ROOT || process.cwd(), e = [];
+  for (const r of n) {
+    if (!r || typeof r != "object") continue;
+    const s = r;
+    if (!Array.isArray(s.messages) || s.messages.length === 0) continue;
+    const i = [];
+    for (const o of s.messages) {
+      if (!o || typeof o != "object") continue;
+      const a = o, c = a.role === "user" || a.role === "assistant" || a.role === "system" ? a.role : "system", u = a.format === "text" || a.format === "markdown" ? a.format : void 0, l = Array.isArray(a.attachments) ? a.attachments.filter((p) => !!(p && typeof p == "object")).map((p) => ({
+        id: typeof p.id == "string" && p.id.trim() ? p.id.trim() : `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        path: typeof p.path == "string" ? p.path : "",
+        label: typeof p.label == "string" && p.label.trim() ? p.label.trim() : "attachment",
+        mimeType: typeof p.mimeType == "string" && p.mimeType.trim() ? p.mimeType.trim() : void 0
+      })).filter((p) => !!p.path) : void 0;
+      i.push({
+        id: typeof a.id == "string" && a.id.trim() ? a.id.trim() : `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        role: c,
+        content: typeof a.content == "string" ? a.content : "",
+        format: u,
+        attachments: l && l.length > 0 ? l : void 0
+      });
+    }
+    i.length !== 0 && e.push({
+      id: typeof s.id == "string" && s.id.trim() ? s.id.trim() : `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+      title: typeof s.title == "string" && s.title.trim() ? s.title.trim() : "Untitled chat",
+      savedAt: typeof s.savedAt == "number" && Number.isFinite(s.savedAt) ? s.savedAt : Date.now(),
+      workspaceRoot: typeof s.workspaceRoot == "string" && s.workspaceRoot.trim() ? s.workspaceRoot.trim() : t,
+      model: typeof s.model == "string" && s.model.trim() ? s.model.trim() : "gpt-5",
+      permissionMode: s.permissionMode === "proceed-always" ? "proceed-always" : "verify-first",
+      sandbox: s.sandbox === "read-only" || s.sandbox === "workspace-write" ? s.sandbox : "workspace-write",
+      fontScale: typeof s.fontScale == "number" && Number.isFinite(s.fontScale) ? s.fontScale : 1,
+      messages: i
+    });
+  }
+  return e.sort((r, s) => s.savedAt - r.savedAt).slice(0, vr);
+}
+function jr() {
+  const n = ve();
+  if (!d.existsSync(n)) return [];
+  try {
+    const t = d.readFileSync(n, "utf8");
+    if (!t.trim()) return [];
+    const e = JSON.parse(t), r = e && typeof e == "object" && !Array.isArray(e) && "entries" in e ? e.entries : e;
+    return gt(r);
+  } catch (t) {
+    return console.warn("[Barnaby] Failed to read persisted chat history:", _(t)), [];
+  }
+}
+function Hr(n) {
+  const t = ve(), e = h.dirname(t), r = gt(n), s = {
+    version: 1,
+    savedAt: Date.now(),
+    entries: r
+  };
+  return d.mkdirSync(e, { recursive: !0 }), d.writeFileSync(t, JSON.stringify(s, null, 2), "utf8"), {
+    ok: !0,
+    count: r.length,
+    path: t
+  };
+}
+function Ur(n, t = {}) {
+  const e = h.resolve(n);
+  if (!d.existsSync(e)) throw new Error("Workspace path does not exist.");
+  if (!d.statSync(e).isDirectory()) throw new Error("Workspace path is not a directory.");
+  const r = !!t.includeHidden, s = !!t.includeNodeModules;
+  let i = 0, o = !1;
+  function a(c) {
+    if (o) return [];
+    const u = c ? we(e, c) : e;
+    let l = [];
+    try {
+      l = d.readdirSync(u, { withFileTypes: !0 });
+    } catch {
+      return [];
+    }
+    const p = l.filter((g) => !r && g.name.startsWith(".") ? !1 : g.isDirectory() ? g.name === "node_modules" && !s ? !1 : !Sr.has(g.name) : g.isFile()).sort((g, x) => g.isDirectory() !== x.isDirectory() ? g.isDirectory() ? -1 : 1 : g.name.localeCompare(x.name)), m = [];
+    for (const g of p) {
+      if (o) break;
+      if (i += 1, i > kr) {
+        o = !0;
+        break;
+      }
+      const x = j(c ? `${c}/${g.name}` : g.name);
+      g.isDirectory() ? m.push({
+        name: g.name,
+        relativePath: x,
+        type: "directory",
+        children: a(x)
+      }) : m.push({
+        name: g.name,
+        relativePath: x,
+        type: "file"
+      });
+    }
+    return m;
+  }
+  return { nodes: a(""), truncated: o };
+}
+function Br(n, t) {
+  if (!(t != null && t.trim())) throw new Error("File path is required.");
+  const e = we(n, j(t));
+  if (!d.existsSync(e)) throw new Error("File does not exist.");
+  const r = d.statSync(e);
+  if (!r.isFile()) throw new Error("Path is not a file.");
+  const s = Math.min(r.size, Ve), i = Buffer.alloc(s), o = d.openSync(e, "r");
+  try {
+    d.readSync(o, i, 0, s, 0);
+  } finally {
+    d.closeSync(o);
+  }
+  const a = i.includes(0);
+  return {
+    relativePath: j(t),
+    size: r.size,
+    truncated: r.size > Ve,
+    binary: a,
+    content: a ? "" : i.toString("utf8")
+  };
+}
+function zr(n, t) {
+  if (!(t != null && t.trim())) throw new Error("File path is required.");
+  const e = j(t), r = we(n, e);
+  if (!d.existsSync(r)) throw new Error("File does not exist.");
+  const s = d.statSync(r);
+  if (!s.isFile()) throw new Error("Path is not a file.");
+  const i = d.readFileSync(r), o = i.includes(0);
+  return {
+    relativePath: e,
+    size: s.size,
+    binary: o,
+    content: o ? "" : i.toString("utf8")
+  };
+}
+function qr(n, t, e) {
+  if (!(t != null && t.trim())) throw new Error("File path is required.");
+  const r = j(t), s = we(n, r);
+  d.mkdirSync(h.dirname(s), { recursive: !0 }), d.writeFileSync(s, e ?? "", "utf8");
+  const i = d.statSync(s);
+  return {
+    relativePath: r,
+    size: i.size
+  };
+}
+async function Kr(n, t) {
+  const e = h.resolve(n);
+  if (!d.existsSync(e)) throw new Error("Workspace path does not exist.");
+  if (!d.statSync(e).isDirectory()) throw new Error("Workspace path is not a directory.");
+  const r = j(t || "untitled.txt"), s = h.join(e, r.split("/").filter(Boolean).join(h.sep)), i = L.getFocusedWindow() ?? k ?? L.getAllWindows()[0] ?? void 0, o = await me.showSaveDialog(i, {
+    title: "Save file as",
+    defaultPath: s
+  });
+  if (o.canceled || !o.filePath) return null;
+  const a = lt(e, o.filePath);
+  if (!a) throw new Error("Save As path must be a file inside the workspace root.");
+  return a;
+}
+async function Jr(n) {
+  const t = h.resolve(n);
+  if (!d.existsSync(t)) throw new Error("Workspace path does not exist.");
+  if (!d.statSync(t).isDirectory()) throw new Error("Workspace path is not a directory.");
+  const e = L.getFocusedWindow() ?? k ?? L.getAllWindows()[0] ?? void 0, r = await me.showOpenDialog(e, {
+    title: "Open file",
+    defaultPath: t,
+    properties: ["openFile"]
+  });
+  if (r.canceled || r.filePaths.length === 0) return null;
+  const s = r.filePaths[0];
+  return lt(t, s);
+}
+function Gr(n) {
+  let t = "(detached HEAD)", e = 0, r = 0;
+  const s = [];
+  for (const c of n.split(/\r?\n/)) {
+    if (!c.trim()) continue;
+    if (c.startsWith("## ")) {
+      const y = c.slice(3).trim();
+      t = y.split("...")[0].trim().replace(/\s+\[.*\]$/, "") || t;
+      const v = y.match(/ahead (\d+)/), S = y.match(/behind (\d+)/);
+      e = v ? Number.parseInt(v[1], 10) : 0, r = S ? Number.parseInt(S[1], 10) : 0;
+      continue;
+    }
+    const u = c.slice(0, 2), l = c.slice(3).trim();
+    if (!l) continue;
+    let p = j(l), m;
+    if (l.includes(" -> ")) {
+      const [y, A] = l.split(" -> ");
+      m = j(y.trim()), p = j(A.trim());
+    }
+    const g = u[0] ?? " ", x = u[1] ?? " ", E = u === "??", w = !E && g !== " ", b = !E && x !== " ";
+    s.push({
+      relativePath: p,
+      indexStatus: g,
+      workingTreeStatus: x,
+      staged: w,
+      unstaged: b,
+      untracked: E,
+      renamedFrom: m
+    });
+  }
+  const i = s.filter((c) => c.staged).length, o = s.filter((c) => c.unstaged).length, a = s.filter((c) => c.untracked).length;
+  return {
+    ok: !0,
+    branch: t,
+    ahead: e,
+    behind: r,
+    stagedCount: i,
+    unstagedCount: o,
+    untrackedCount: a,
+    clean: s.length === 0,
+    entries: s,
+    checkedAt: Date.now()
+  };
+}
+function _(n) {
+  if (n && typeof n == "object") {
+    const t = n.stderr;
+    if (typeof t == "string" && t.trim()) return t.trim();
+  }
+  return n instanceof Error && n.message ? n.message : "Unknown error.";
+}
+function Vr(n) {
+  const t = h.resolve(n);
+  if (!d.existsSync(t)) throw new Error("Workspace path does not exist.");
+  if (!d.statSync(t).isDirectory()) throw new Error("Workspace path is not a directory.");
+  return t;
+}
+function Me(n) {
+  return h.join(n, hr, fr);
+}
+function he(n) {
+  try {
+    const t = d.readFileSync(n, "utf8"), e = JSON.parse(t);
+    return !e || typeof e != "object" || e.app !== "Barnaby" || e.version !== 1 || typeof e.instanceId != "string" || !e.instanceId.trim() || typeof e.pid != "number" || !Number.isFinite(e.pid) || e.pid <= 0 || typeof e.hostname != "string" || typeof e.workspaceRoot != "string" || !e.workspaceRoot.trim() || typeof e.acquiredAt != "number" || !Number.isFinite(e.acquiredAt) || typeof e.heartbeatAt != "number" || !Number.isFinite(e.heartbeatAt) ? null : {
+      version: 1,
+      app: "Barnaby",
+      instanceId: e.instanceId,
+      pid: e.pid,
+      hostname: e.hostname,
+      workspaceRoot: e.workspaceRoot,
+      acquiredAt: e.acquiredAt,
+      heartbeatAt: e.heartbeatAt
+    };
+  } catch {
+    return null;
+  }
+}
+function Xr(n) {
+  if (!Number.isFinite(n) || n <= 0) return !1;
+  if (n === process.pid) return !0;
+  try {
+    return process.kill(n, 0), !0;
+  } catch (t) {
+    return t.code !== "ESRCH";
+  }
+}
+function ke(n) {
+  return n.instanceId === ct && n.pid === process.pid;
+}
+function Yr(n) {
+  return ke(n) ? !1 : !Number.isFinite(n.heartbeatAt) || Date.now() - n.heartbeatAt > gr ? !0 : !Xr(n.pid);
+}
+function Ie(n, t, e) {
+  const r = Date.now();
+  return {
+    version: 1,
+    app: "Barnaby",
+    instanceId: ct,
+    pid: process.pid,
+    hostname: Q.hostname(),
+    workspaceRoot: n,
+    acquiredAt: t ?? r,
+    heartbeatAt: e ?? r
+  };
+}
+function ae(n, t, e) {
+  d.mkdirSync(h.dirname(n), { recursive: !0 }), d.writeFileSync(n, `${JSON.stringify(t, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: e === "exclusive" ? "wx" : "w"
+  });
+}
+function Ze() {
+  H || (H = setInterval(() => {
+    const n = Date.now();
+    for (const [t, e] of W) {
+      const r = he(e.lockFilePath);
+      if (r && !ke(r)) {
+        W.delete(t);
+        continue;
+      }
+      const s = Ie(t, e.acquiredAt, n);
+      try {
+        ae(e.lockFilePath, s, "overwrite");
+      } catch {
+      }
+    }
+    W.size === 0 && H && (clearInterval(H), H = null);
+  }, mr), typeof H.unref == "function" && H.unref());
+}
+function Zr(n) {
+  let t = "";
+  try {
+    t = Vr(n);
+  } catch (o) {
+    const a = h.resolve(n || ".");
+    return {
+      ok: !1,
+      reason: "invalid-workspace",
+      message: _(o),
+      workspaceRoot: a,
+      lockFilePath: Me(a),
+      owner: null
+    };
+  }
+  const e = Me(t), r = W.get(t);
+  if (r) {
+    const o = Ie(t, r.acquiredAt, Date.now());
+    try {
+      ae(e, o, "overwrite");
+    } catch (a) {
+      return {
+        ok: !1,
+        reason: "error",
+        message: _(a),
+        workspaceRoot: t,
+        lockFilePath: e
+      };
+    }
+    return {
+      ok: !0,
+      workspaceRoot: t,
+      lockFilePath: e
+    };
+  }
+  const s = Ie(t);
+  try {
+    return ae(e, s, "exclusive"), W.set(t, { lockFilePath: e, acquiredAt: s.acquiredAt }), Ze(), {
+      ok: !0,
+      workspaceRoot: t,
+      lockFilePath: e
+    };
+  } catch (o) {
+    if (o.code !== "EEXIST")
+      return {
+        ok: !1,
+        reason: "error",
+        message: _(o),
+        workspaceRoot: t,
+        lockFilePath: e
+      };
+  }
+  const i = he(e);
+  if (i && !Yr(i))
+    return {
+      ok: !1,
+      reason: "in-use",
+      message: "Workspace is already open in another Barnaby instance.",
+      workspaceRoot: t,
+      lockFilePath: e,
+      owner: {
+        pid: i.pid,
+        hostname: i.hostname,
+        acquiredAt: i.acquiredAt,
+        heartbeatAt: i.heartbeatAt
+      }
+    };
+  try {
+    ae(e, s, "overwrite");
+    const o = he(e);
+    return !o || !ke(o) ? {
+      ok: !1,
+      reason: "in-use",
+      message: "Workspace lock was claimed by another Barnaby instance.",
+      workspaceRoot: t,
+      lockFilePath: e,
+      owner: o ? {
+        pid: o.pid,
+        hostname: o.hostname,
+        acquiredAt: o.acquiredAt,
+        heartbeatAt: o.heartbeatAt
+      } : null
+    } : (W.set(t, { lockFilePath: e, acquiredAt: o.acquiredAt }), Ze(), {
+      ok: !0,
+      workspaceRoot: t,
+      lockFilePath: e
+    });
+  } catch (o) {
+    return {
+      ok: !1,
+      reason: "error",
+      message: _(o),
+      workspaceRoot: t,
+      lockFilePath: e,
+      owner: i ? {
+        pid: i.pid,
+        hostname: i.hostname,
+        acquiredAt: i.acquiredAt,
+        heartbeatAt: i.heartbeatAt
+      } : null
+    };
+  }
+}
+function yt(n) {
+  var i;
+  const t = h.resolve(n), e = ((i = W.get(t)) == null ? void 0 : i.lockFilePath) ?? Me(t);
+  let r = !1;
+  const s = he(e);
+  if (s && ke(s))
+    try {
+      d.rmSync(e, { force: !0 }), r = !0;
+    } catch {
+    }
+  return W.delete(t), W.size === 0 && H && (clearInterval(H), H = null), r;
+}
+function wt() {
+  const n = [...W.keys()];
+  for (const t of n)
+    yt(t);
+}
+function vt(n, t) {
+  if (process.platform === "win32") {
+    const e = [n, ...t].map((r) => r.includes(" ") ? `"${r}"` : r).join(" ");
+    return N(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", e], {
+      windowsHide: !0,
+      maxBuffer: 1024 * 1024
+    });
+  }
+  return N(n, t, {
+    windowsHide: !0,
+    maxBuffer: 1024 * 1024
+  });
+}
+async function Qr(n) {
+  try {
+    return await vt(n, ["--version"]), !0;
+  } catch {
+    return !1;
+  }
+}
+async function en(n) {
+  if ((n.type ?? (n.id === "openrouter" ? "api" : "cli")) === "api") {
+    const i = pe(n.id), o = (n.apiBaseUrl ?? "https://openrouter.ai/api/v1").replace(/\/+$/, "");
+    if (!i)
+      return {
+        provider: n.id,
+        installed: !0,
+        authenticated: !1,
+        detail: "API key not configured. Add your key in Settings -> Connectivity.",
+        checkedAt: Date.now()
+      };
+    try {
+      const a = await fetch(`${o}/models`, {
+        headers: {
+          Authorization: `Bearer ${i}`,
+          "HTTP-Referer": "https://barnaby.build",
+          "X-Title": "Barnaby"
+        },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (a.ok)
+        return {
+          provider: n.id,
+          installed: !0,
+          authenticated: !0,
+          detail: "API key is valid.",
+          checkedAt: Date.now()
+        };
+      const c = await a.text().catch(() => "");
+      return {
+        provider: n.id,
+        installed: !0,
+        authenticated: !1,
+        detail: `API check failed (${a.status}). ${c.slice(0, 200)}`.trim(),
+        checkedAt: Date.now()
+      };
+    } catch (a) {
+      return {
+        provider: n.id,
+        installed: !0,
+        authenticated: !1,
+        detail: _(a) || "API check failed.",
+        checkedAt: Date.now()
+      };
+    }
+  }
+  const e = n.cliPath ?? n.cliCommand ?? "", r = (n.authCheckCommand ?? "--version").trim().split(/\s+/).filter(Boolean), s = n.id === "codex";
+  try {
+    const i = await vt(e, r), o = `${i.stdout ?? ""}
+${i.stderr ?? ""}`.trim(), a = o.toLowerCase();
+    let c;
+    return s ? c = a.includes("logged in") && !a.includes("not logged in") : c = !0, {
+      provider: n.id,
+      installed: !0,
+      authenticated: c,
+      detail: o || (c ? "Logged in." : "Not logged in."),
+      checkedAt: Date.now()
+    };
+  } catch (i) {
+    const o = _(i), a = await Qr(e);
+    return {
+      provider: n.id,
+      installed: a,
+      authenticated: !1,
+      detail: o || (a ? "Login required." : `${n.id} CLI not found.`),
+      checkedAt: Date.now()
+    };
+  }
+}
+async function tn(n) {
+  if ((n.type ?? (n.id === "openrouter" ? "api" : "cli")) === "api") {
+    const r = n.loginUrl || "https://openrouter.ai/keys";
+    return await z.openExternal(r), { started: !0, detail: `Opened ${n.id} key management page.` };
+  }
+  const e = n.loginCommand ?? n.cliCommand;
+  return e ? process.platform === "win32" ? (await N(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "start", "", "cmd", "/k", e], {
+    windowsHide: !0
+  }), {
+    started: !0,
+    detail: `Opened terminal for ${n.id} login.`
+  }) : (await N("sh", ["-lc", e], { windowsHide: !0 }), { started: !0, detail: `Launched ${n.id} login.` }) : { started: !1, detail: `No login command configured for ${n.id}.` };
+}
+async function rn(n) {
+  const t = n.upgradePackage, e = n.upgradeCommand, r = t ? process.platform === "win32" ? `npm uninstall -g ${t} & npm install -g ${t}@latest` : `npm uninstall -g ${t}; npm install -g ${t}@latest` : e;
+  if (!r)
+    return { started: !1, detail: `No upgrade command configured for ${n.id}.` };
+  if (process.platform === "win32")
+    return await N(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "start", "", "cmd", "/k", r], {
+      windowsHide: !0
+    }), {
+      started: !0,
+      detail: `Opened terminal to upgrade ${n.id} CLI. Run the command shown, then close the window.`
+    };
+  if (process.platform === "darwin") {
+    const s = r.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return await N("osascript", [
+      "-e",
+      `tell application "Terminal" to do script "${s}"`
+    ]), {
+      started: !0,
+      detail: `Opened Terminal to upgrade ${n.id} CLI. Close the window when done.`
+    };
+  }
+  return await N("sh", ["-lc", r], { windowsHide: !0 }), { started: !0, detail: `Ran ${n.id} CLI upgrade. Re-check connectivity.` };
+}
+const nn = "Output a JSON array of model IDs you support. Use names like gemini-2.5-flash, gemini-2.5-pro, gemini-3-pro-preview. Output only the JSON array, no markdown or other text.", sn = 'Output only a JSON array of model IDs from the Codex CLI /model menu. Example: ["gpt-5.3-codex","gpt-5.2-codex"]. No other text.';
+async function on() {
+  return new Promise((t, e) => {
+    var a, c, u;
+    const r = ["exec", "--sandbox", "read-only", "--json", sn], s = process.platform === "win32" ? I("codex", r, {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: !0
+    }) : I("codex", r, { stdio: ["pipe", "pipe", "pipe"] });
+    let i = "";
+    (a = s.stdout) == null || a.setEncoding("utf8"), (c = s.stdout) == null || c.on("data", (l) => {
+      i += l;
+    }), (u = s.stderr) == null || u.on("data", () => {
+    });
+    const o = setTimeout(() => {
+      s.kill("SIGTERM"), e(new Error("Codex CLI models query timed out"));
+    }, 12e4);
+    s.on("error", (l) => {
+      clearTimeout(o), e(l);
+    }), s.on("exit", (l, p) => {
+      var m, g;
+      clearTimeout(o);
+      try {
+        for (const x of i.split(`
+`)) {
+          const E = x.trim();
+          if (!E.startsWith('{"type":"item.completed"')) continue;
+          const w = JSON.parse(E);
+          if (((m = w.item) == null ? void 0 : m.type) !== "agent_message" || !((g = w.item) != null && g.text)) continue;
+          let b = w.item.text.trim();
+          const y = b.match(/```(?:json)?\s*([\s\S]*?)```/);
+          y && (b = y[1].trim());
+          const A = JSON.parse(b);
+          if (!Array.isArray(A)) continue;
+          const v = A.filter((S) => typeof S == "string" && S.length > 0).map((S) => ({
+            id: S,
+            displayName: S
+          }));
+          t(v);
+          return;
+        }
+        t([]);
+      } catch {
+        t([]);
+      }
+    });
+  });
+}
+async function an() {
+  let n = await on().catch(() => []), t = [
+    { id: "sonnet", displayName: "sonnet" },
+    { id: "opus", displayName: "opus" },
+    { id: "haiku", displayName: "haiku" }
+  ], e = await kt().catch(() => []), r = await cn().catch(() => []);
+  return r.length === 0 && (r = [{ id: "openrouter/auto", displayName: "openrouter/auto" }]), n.length === 0 && (n = [
+    { id: "gpt-5.3-codex", displayName: "gpt-5.3-codex" },
+    { id: "gpt-5.2-codex", displayName: "gpt-5.2-codex" },
+    { id: "gpt-5.1-codex", displayName: "gpt-5.1-codex" },
+    { id: "gpt-4o", displayName: "gpt-4o" },
+    { id: "gpt-4o-mini", displayName: "gpt-4o-mini" },
+    { id: "gpt-4-turbo", displayName: "gpt-4-turbo" }
+  ]), e.length === 0 && (e = [{ id: "gemini-2.5-flash", displayName: "gemini-2.5-flash" }, { id: "gemini-2.5-pro", displayName: "gemini-2.5-pro" }]), { codex: n, claude: t, gemini: e, openrouter: r };
+}
+async function cn() {
+  try {
+    const n = await fetch("https://openrouter.ai/api/v1/models", { signal: AbortSignal.timeout(1e4) });
+    if (!n.ok) return [];
+    const t = await n.json(), r = (Array.isArray(t == null ? void 0 : t.data) ? t.data : []).filter((i) => typeof (i == null ? void 0 : i.id) == "string").map((i) => {
+      var o, a;
+      return {
+        id: String(i.id),
+        displayName: String(i.id),
+        isFree: String(i == null ? void 0 : i.id).includes(":free") || ((o = i == null ? void 0 : i.pricing) == null ? void 0 : o.prompt) === "0" && ((a = i == null ? void 0 : i.pricing) == null ? void 0 : a.completion) === "0"
+      };
+    }), s = r.filter((i) => i.isFree).slice(0, 24);
+    return s.length > 0 ? s.map(({ id: i, displayName: o }) => ({ id: i, displayName: o })) : r.slice(0, 24).map(({ id: i, displayName: o }) => ({ id: i, displayName: o }));
+  } catch {
+    return [];
+  }
+}
+async function kt() {
+  return new Promise((t, e) => {
+    var a, c, u;
+    const r = ["-o", "json", "-p", nn], s = process.platform === "win32" ? I(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "gemini", ...r], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: !0
+    }) : I("gemini", r, { stdio: ["pipe", "pipe", "pipe"] });
+    let i = "";
+    (a = s.stdout) == null || a.setEncoding("utf8"), (c = s.stdout) == null || c.on("data", (l) => {
+      i += l;
+    }), (u = s.stderr) == null || u.on("data", () => {
+    });
+    const o = setTimeout(() => {
+      s.kill("SIGTERM"), e(new Error("Gemini CLI models query timed out"));
+    }, 45e3);
+    s.on("error", (l) => {
+      clearTimeout(o), e(l);
+    }), s.on("exit", (l, p) => {
+      var m;
+      if (clearTimeout(o), l !== 0 && !p) {
+        e(new Error(`Gemini CLI exited with code ${l}`));
+        return;
+      }
+      try {
+        const g = JSON.parse(i), x = (m = g == null ? void 0 : g.response) == null ? void 0 : m.trim();
+        if (!x) {
+          t([]);
+          return;
+        }
+        let E = x;
+        const w = x.match(/```(?:json)?\s*([\s\S]*?)```/);
+        w && (E = w[1].trim());
+        const b = JSON.parse(E);
+        if (!Array.isArray(b)) {
+          t([]);
+          return;
+        }
+        const y = b.filter((A) => typeof A == "string" && A.length > 0).map((A) => ({
+          id: A.replace(/^models\//, ""),
+          displayName: A.replace(/^models\//, "")
+        }));
+        t(y);
+      } catch {
+        t([]);
+      }
+    });
+  });
+}
+function ln(n) {
+  const t = [], e = [], r = [], s = [];
+  for (const l of n)
+    l.untracked ? e.push(l.relativePath) : l.renamedFrom ? s.push({ from: l.renamedFrom, to: l.relativePath }) : l.indexStatus === "D" || l.workingTreeStatus === "D" ? r.push(l.relativePath) : l.indexStatus === "A" || l.indexStatus === "?" ? e.push(l.relativePath) : t.push(l.relativePath);
+  const i = t.length + e.length + r.length + s.length, o = [];
+  t.length && o.push(`${t.length} modified`), e.length && o.push(`${e.length} added`), r.length && o.push(`${r.length} deleted`), s.length && o.push(`${s.length} renamed`);
+  const a = i > 0 ? `Commit workspace changes (${o.join(", ")})` : "Commit workspace changes", c = [];
+  t.length && c.push("Modified:", ...t.map((l) => `  - ${l}`), ""), e.length && c.push("Added:", ...e.map((l) => `  - ${l}`), ""), r.length && c.push("Deleted:", ...r.map((l) => `  - ${l}`), ""), s.length && c.push("Renamed:", ...s.map((l) => `  - ${l.from} -> ${l.to}`), "");
+  const u = c.join(`
+`).trim();
+  return { subject: a, body: u || "No changes" };
+}
+async function Re(n, t) {
+  try {
+    const { stdout: e, stderr: r } = await N("git", ["-C", n, ...t], {
+      windowsHide: !0,
+      maxBuffer: 1048576
+    });
+    return { ok: !0, stdout: e == null ? void 0 : e.trim(), stderr: r == null ? void 0 : r.trim() };
+  } catch (e) {
+    const r = e && typeof e == "object" && "stderr" in e ? String(e.stderr ?? "") : "";
+    return { ok: !1, error: (e instanceof Error ? e.message : "Unknown error") || r, stderr: r };
+  }
+}
+async function je(n, t, e) {
+  return new Promise((r) => {
+    var a, c, u, l;
+    const s = I(t, e, {
+      cwd: n,
+      shell: !0,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: !0
+    });
+    let i = "", o = "";
+    (a = s.stdout) == null || a.setEncoding("utf8"), (c = s.stdout) == null || c.on("data", (p) => {
+      i += p;
+    }), (u = s.stderr) == null || u.setEncoding("utf8"), (l = s.stderr) == null || l.on("data", (p) => {
+      o += p;
+    }), s.on("error", (p) => r({ ok: !1, error: p.message })), s.on("exit", (p) => {
+      r(p === 0 ? { ok: !0, stdout: i, stderr: o } : { ok: !1, error: o || `Exit code ${p}`, stdout: i, stderr: o });
+    });
+  });
+}
+function bt(n) {
+  if (!Array.isArray(n)) return [];
+  const t = [];
+  for (const e of n) {
+    if (typeof e != "string") continue;
+    const r = j(e).trim();
+    if (!r || r.startsWith("/")) continue;
+    const s = r.split("/").filter((i) => i && i !== "." && i !== "..").join("/");
+    s && (t.includes(s) || t.push(s));
+  }
+  return t;
+}
+function dn(n, t) {
+  if (t.length === 0)
+    return {
+      selectedEntries: n,
+      pathspecs: [],
+      hasSelection: !1
+    };
+  const e = new Map(n.map((i) => [i.relativePath, i])), r = [];
+  for (const i of t) {
+    const o = e.get(i);
+    o && r.push(o);
+  }
+  const s = [];
+  for (const i of r)
+    s.includes(i.relativePath) || s.push(i.relativePath), i.renamedFrom && !s.includes(i.renamedFrom) && s.push(i.renamedFrom);
+  return {
+    selectedEntries: r,
+    pathspecs: s,
+    hasSelection: !0
+  };
+}
+function un(n) {
+  if (!n) return !1;
+  const t = n.toLowerCase();
+  return t.includes("nothing to commit") || t.includes("no changes");
+}
+async function St(n, t) {
+  const e = h.resolve(n), r = await At(e);
+  if (!r.ok || r.clean)
+    return { ok: !1, error: r.clean ? "Nothing to commit." : r.error ?? "Cannot read git status." };
+  const s = bt(t), i = dn(r.entries, s);
+  if (i.hasSelection && i.selectedEntries.length === 0)
+    return { ok: !1, error: "Selected files no longer have changes." };
+  const o = i.selectedEntries, a = i.hasSelection ? ["add", "-A", "--", ...i.pathspecs] : ["add", "-A"], c = await Re(e, a);
+  if (!c.ok) return { ok: !1, error: c.error ?? "git add failed" };
+  const u = ln(o), l = ["commit", "-m", u.subject, "-m", u.body];
+  i.hasSelection && l.push("--", ...i.pathspecs);
+  const p = await Re(e, l);
+  return p.ok ? { ok: !0 } : { ok: !1, error: p.error ?? "git commit failed" };
+}
+async function pn(n, t) {
+  const e = h.resolve(n), r = bt(t);
+  if (r.length > 0) {
+    const i = await St(e, r);
+    if (!i.ok && !un(i.error))
+      return i;
+  }
+  const s = await Re(e, ["push"]);
+  return { ok: s.ok, error: s.error };
+}
+async function hn(n, t) {
+  var o;
+  const e = h.resolve(n), r = h.join(e, "package.json");
+  if (!d.existsSync(r)) return { ok: !1, error: "No package.json found." };
+  const s = JSON.parse(d.readFileSync(r, "utf8"));
+  if (!((o = s == null ? void 0 : s.scripts) != null && o.deploy)) return { ok: !1, error: "No deploy script in package.json." };
+  const i = await je(e, "npm", ["run", "deploy"]);
+  return { ok: i.ok, error: i.error };
+}
+async function fn(n, t) {
+  var o;
+  const e = h.resolve(n), r = h.join(e, "package.json");
+  if (!d.existsSync(r)) return { ok: !1, error: "No package.json found." };
+  const s = JSON.parse(d.readFileSync(r, "utf8"));
+  if (!((o = s == null ? void 0 : s.scripts) != null && o.build)) return { ok: !1, error: "No build script in package.json." };
+  const i = await je(e, "npm", ["run", "build"]);
+  return { ok: i.ok, error: i.error };
+}
+async function mn(n, t) {
+  const e = h.resolve(n), r = await je(e, "gh", ["workflow", "run", "release.yml", "-f", "releasable=true", "--ref", "main"]);
+  return { ok: r.ok, error: r.error };
+}
+async function At(n) {
+  const t = h.resolve(n), e = {
+    branch: "(not a git repository)",
+    ahead: 0,
+    behind: 0,
+    stagedCount: 0,
+    unstagedCount: 0,
+    untrackedCount: 0,
+    clean: !0,
+    entries: [],
+    checkedAt: Date.now()
+  };
+  try {
+    if (!(await N("git", ["-C", t, "rev-parse", "--is-inside-work-tree"], {
+      windowsHide: !0,
+      maxBuffer: 1048576
+    })).stdout.trim().startsWith("true"))
+      return { ok: !1, ...e, error: "This workspace is not inside a git repository." };
+  } catch (r) {
+    return { ok: !1, ...e, error: _(r) };
+  }
+  try {
+    const r = await N("git", ["-C", t, "status", "--short", "--branch"], {
+      windowsHide: !0,
+      maxBuffer: 1048576
+    });
+    return Gr(r.stdout);
+  } catch (r) {
+    return { ok: !1, ...e, error: _(r) };
+  }
+}
+function te(n, t) {
+  k == null || k.webContents.send("agentorchestrator:event", { agentWindowId: n, evt: t }), k == null || k.webContents.send("fireharness:event", { agentWindowId: n, evt: t }), ir(n, t), (t == null ? void 0 : t.type) === "assistantCompleted" && or(n);
+}
+async function xt(n, t) {
+  var o, a;
+  const e = t.provider ?? "codex", r = M.get(n);
+  if (r && (await r.close(), M.delete(n)), e === "gemini") {
+    const c = new Pe();
+    c.on("event", (l) => te(n, l));
+    const u = await c.connect({
+      model: t.model,
+      cwd: t.cwd,
+      initialHistory: t.initialHistory
+    });
+    return M.set(n, c), { client: c, result: u };
+  }
+  if (e === "claude") {
+    const c = new Ht();
+    c.on("event", (l) => te(n, l));
+    const u = await c.connect({
+      cwd: t.cwd,
+      model: t.model,
+      permissionMode: t.permissionMode,
+      initialHistory: t.initialHistory
+    });
+    return M.set(n, c), { client: c, result: u };
+  }
+  if (e === "openrouter") {
+    const c = new Bt();
+    c.on("event", (p) => te(n, p));
+    const u = pe("openrouter");
+    if (!u) throw new Error("OpenRouter API key is missing. Open Settings -> Connectivity and add it.");
+    const l = await c.connect({
+      cwd: t.cwd,
+      model: t.model,
+      apiKey: u,
+      baseUrl: (o = t.modelConfig) == null ? void 0 : o.openrouterBaseUrl,
+      initialHistory: t.initialHistory
+    });
+    return M.set(n, c), { client: c, result: l };
+  }
+  if (e === "codex" && ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"].includes(t.model)) {
+    const l = new Vt();
+    l.on("event", (g) => te(n, g));
+    const p = pe("codex");
+    if (!p) throw new Error("OpenAI API key is missing. Add it in Settings -> Connectivity (OpenAI card, API key).");
+    const m = await l.connect({
+      cwd: t.cwd,
+      model: t.model,
+      apiKey: p,
+      baseUrl: ((a = t.modelConfig) == null ? void 0 : a.openaiBaseUrl) ?? "https://api.openai.com/v1",
+      permissionMode: t.permissionMode,
+      sandbox: t.sandbox,
+      allowedCommandPrefixes: t.allowedCommandPrefixes,
+      initialHistory: t.initialHistory
+    });
+    return M.set(n, l), { client: l, result: m };
+  }
+  const s = new Lt();
+  s.on("event", (c) => {
+    te(n, c), (c == null ? void 0 : c.type) === "status" && c.status === "closed" && M.delete(n);
+  });
+  const i = await s.connect(t);
+  return M.set(n, s), { client: s, result: i };
+}
+async function Pt() {
+  ge(), ye(), Ce = !1, re = !1, oe = !1, ue = !1, B = Er(), oe = !!B, oe ? ie = setTimeout(() => {
+    re = !0, $e();
+  }, br) : re = !0;
+  const { width: n, height: t } = _t.getPrimaryDisplay().workAreaSize, e = Math.floor(n / 5), r = Math.floor(t * 0.9), s = X ? "(DEV)" : `(V${$.getVersion()})`;
+  k = new L({
+    title: `Barnaby ${s}`,
+    icon: h.join(process.env.VITE_PUBLIC, "appicon.png"),
+    show: !1,
+    width: e,
+    height: r,
+    webPreferences: {
+      preload: ot
+      // Warning: Enable nodeIntegration and disable contextIsolation is not secure in production
+      // nodeIntegration: true,
+      // Consider using contextBridge.exposeInMainWorld
+      // Read more on https://www.electronjs.org/docs/latest/tutorial/context-isolation
+      // contextIsolation: false,
+    }
+  }), X ? (k.loadURL(X), k.webContents.openDevTools()) : k.loadFile(at), k.webContents.on("did-finish-load", () => {
+    k == null || k.setTitle(`Barnaby ${s}`);
+  }), k.once("ready-to-show", () => {
+    Ce = !0, $e();
+  }), k.webContents.setWindowOpenHandler(({ url: i }) => (i.startsWith("https:") && z.openExternal(i), { action: "deny" })), He();
+}
+$.whenReady().then(async () => {
+  if (Pr()) {
+    D("bare-electron-host-launch-blocked", { argv: process.argv }, "warn"), $.quit();
+    return;
+  }
+  Wr(), D("app-start", { version: $.getVersion(), platform: process.platform, electron: process.versions.electron }), Tr(), await Pt(), k && (rr(k), nr(() => {
+    for (const [n] of W) return n;
+    return "";
+  }), Qe($.getAppPath(), U).then(() => {
+    k == null || k.webContents.send("barnaby:plugin-host:plugins-loaded");
+  }).catch((n) => {
+    console.error("[pluginHost] Initialization failed:", n);
+  }));
+});
+$.on("window-all-closed", () => {
+  k = null, ye(), ge(), wt(), De().catch(() => {
+  });
+  for (const n of M.values())
+    n.close().catch(() => {
+    });
+  M.clear(), process.platform !== "darwin" && $.quit();
+});
+$.on("before-quit", () => {
+  ye(), ge(), wt(), De().catch(() => {
+  });
+  for (const n of M.values())
+    n.close().catch(() => {
+    });
+  M.clear();
+});
+$.on("activate", () => {
+  const n = L.getAllWindows();
+  n.length ? n[0].focus() : Pt();
+});
+f.handle("open-win", (n, t) => {
+  const e = new L({
+    webPreferences: {
+      preload: ot,
+      nodeIntegration: !0,
+      contextIsolation: !1
+    }
+  });
+  X ? e.loadURL(`${X}#${t}`) : e.loadFile(at, { hash: t });
+});
+f.handle("fireharness:connect", async (n, t) => {
+  const { result: e } = await xt("default", t);
+  return e;
+});
+f.handle("fireharness:sendMessage", async (n, t) => {
+  const e = M.get("default");
+  return e && await e.sendUserMessage(t), {};
+});
+f.handle("fireharness:interrupt", async () => {
+  const n = M.get("default");
+  return n && await n.interruptActiveTurn(), {};
+});
+f.handle("fireharness:disconnect", async () => {
+  const n = M.get("default");
+  return n ? (await n.close(), M.delete("default"), {}) : {};
+});
+f.handle("agentorchestrator:connect", async (n, t, e) => {
+  const { result: r } = await xt(t, e);
+  return r;
+});
+f.handle("agentorchestrator:sendMessage", async (n, t, e) => {
+  const r = M.get(t);
+  return r && await r.sendUserMessage(e), {};
+});
+function gn(n) {
+  if (!n.length) return "";
+  const t = n.filter((e) => e.role === "user" || e.role === "assistant").map((e) => `${e.role === "user" ? "User" : "Assistant"}:
+${(e.content ?? "").trim()}`).filter((e) => e.length > 0).join(`
+
+`);
+  return t ? `Previous conversation:
+
+${t}
+
+User continues: ` : "";
+}
+f.handle("agentorchestrator:sendMessageEx", async (n, t, e) => {
+  const r = M.get(t);
+  if (!r) return {};
+  let s = typeof (e == null ? void 0 : e.text) == "string" ? e.text : "";
+  const i = Array.isArray(e == null ? void 0 : e.imagePaths) ? e.imagePaths.filter((a) => typeof a == "string" && a.trim().length > 0) : [], o = Array.isArray(e == null ? void 0 : e.priorMessagesForContext) ? e.priorMessagesForContext : [];
+  if (o.length > 0) {
+    const a = gn(o.slice(-24));
+    a && (s = a + s);
+  }
+  if (i.length > 0) {
+    const a = r;
+    if (typeof a.sendUserMessageWithImages != "function")
+      throw new Error("Selected provider does not support image attachments in this app yet.");
+    return await a.sendUserMessageWithImages(s, i), {};
+  }
+  return await r.sendUserMessage(s), {};
+});
+f.handle("agentorchestrator:loadChatHistory", async () => jr());
+f.handle("agentorchestrator:saveChatHistory", async (n, t) => Hr(t));
+f.handle("agentorchestrator:loadAppState", async () => $r());
+f.handle("agentorchestrator:saveAppState", async (n, t) => _r(t));
+f.handle("agentorchestrator:setWindowTheme", async (n, t) => {
+  const e = t === "light" || t === "dark" || t === "system" ? t : "system";
+  return Ae.themeSource = e, { ok: !0, themeSource: e, shouldUseDarkColors: Ae.shouldUseDarkColors };
+});
+f.handle("agentorchestrator:rendererReady", async () => (re = !0, $e(), { ok: !0 }));
+f.handle("agentorchestrator:getDiagnosticsInfo", async () => ht());
+f.handle("agentorchestrator:getLoadedPlugins", async () => {
+  const n = lr();
+  return Array.from(n.entries()).map(([t, e]) => ({
+    pluginId: t,
+    displayName: e.plugin.displayName,
+    version: e.plugin.version,
+    active: e.active
+  }));
+});
+f.handle("agentorchestrator:openRuntimeLog", async () => Nr());
+f.handle("agentorchestrator:openDiagnosticsPath", async (n, t) => Rr(t));
+f.handle("agentorchestrator:readDiagnosticsFile", async (n, t) => Fr(t));
+f.handle("agentorchestrator:writeDiagnosticsFile", async (n, t, e) => Dr(t));
+f.handle("agentorchestrator:openExternalUrl", async (n, t) => {
+  const e = typeof t == "string" ? t.trim() : "";
+  if (!e) return { ok: !1, error: "URL is required." };
+  let r;
+  try {
+    r = new URL(e);
+  } catch {
+    return { ok: !1, error: "Invalid URL." };
+  }
+  const s = r.protocol.toLowerCase();
+  if (s !== "http:" && s !== "https:" && s !== "mailto:")
+    return { ok: !1, error: `Unsupported URL protocol: ${s}` };
+  try {
+    return await z.openExternal(r.toString()), { ok: !0 };
+  } catch (i) {
+    return { ok: !1, error: _(i) };
+  }
+});
+f.handle("agentorchestrator:getOrchestratorLicenseKeyState", async () => ({ hasKey: (Oe(U).licenseKey ?? "").trim().length > 0 }));
+f.handle("agentorchestrator:setOrchestratorLicenseKey", async (n, t) => {
+  const e = typeof t == "string" ? t.trim() : "", r = Oe(U);
+  return r.licenseKey = e || void 0, Xt(U, r), { ok: !0, hasKey: e.length > 0 };
+});
+f.handle("agentorchestrator:syncOrchestratorSettings", async (n, t) => {
+  const e = t;
+  if (!e || typeof e != "object" || Array.isArray(e)) return;
+  const r = {};
+  typeof e.orchestratorModel == "string" && (r.orchestratorModel = e.orchestratorModel), typeof e.workerProvider == "string" && (r.workerProvider = e.workerProvider), typeof e.workerModel == "string" && (r.workerModel = e.workerModel), typeof e.maxParallelPanels == "number" && e.maxParallelPanels >= 1 && e.maxParallelPanels <= 8 && (r.maxParallelPanels = e.maxParallelPanels), typeof e.maxTaskAttempts == "number" && e.maxTaskAttempts >= 1 && e.maxTaskAttempts <= 10 && (r.maxTaskAttempts = e.maxTaskAttempts), Zt(U, r);
+});
+f.handle("agentorchestrator:openPluginsFolder", async () => {
+  const n = h.join(Q.homedir(), ".barnaby", "plugins");
+  try {
+    d.existsSync(n) || d.mkdirSync(n, { recursive: !0 });
+    const t = await z.openPath(n);
+    return t ? { ok: !1, error: t } : { ok: !0 };
+  } catch (t) {
+    return { ok: !1, error: _(t) };
+  }
+});
+f.handle("agentorchestrator:installOrchestratorPlugin", async () => {
+  const n = h.join(Q.homedir(), ".barnaby", "plugins");
+  try {
+    d.existsSync(n) || d.mkdirSync(n, { recursive: !0 });
+    const t = h.join(n, "package.json");
+    if (!d.existsSync(t)) {
+      const { execSync: r } = await import("node:child_process");
+      r("npm init -y", { cwd: n, stdio: "pipe" });
+    }
+    const { execSync: e } = await import("node:child_process");
+    return e("npm install @barnaby.build/orchestrator", { cwd: n, stdio: "pipe" }), await De(), await Qe($.getAppPath(), U), k == null || k.webContents.send("barnaby:plugin-host:plugins-loaded"), { ok: !0 };
+  } catch (t) {
+    return { ok: !1, error: _(t) };
+  }
+});
+f.handle("agentorchestrator:interrupt", async (n, t) => {
+  const e = M.get(t);
+  return e ? (await e.interruptActiveTurn(), {}) : {};
+});
+f.handle("agentorchestrator:disconnect", async (n, t) => {
+  const e = M.get(t);
+  return e ? (await e.close(), M.delete(t), {}) : {};
+});
+f.handle("agentorchestrator:openFolderDialog", async () => {
+  const n = k ?? L.getFocusedWindow() ?? L.getAllWindows()[0] ?? void 0, t = await me.showOpenDialog(n, {
+    properties: ["openDirectory"],
+    title: "Select workspace folder"
+  });
+  return t.canceled || t.filePaths.length === 0 ? null : t.filePaths[0];
+});
+async function yn(n) {
+  const t = h.resolve(n);
+  try {
+    if (process.platform === "win32") {
+      const e = process.env.ComSpec ?? "cmd.exe";
+      await N(e, ["/d", "/s", "/c", "start", "", "cmd", "/k", `cd /d "${t}"`], {
+        windowsHide: !0
+      });
+    } else if (process.platform === "darwin") {
+      const e = t.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      await N("osascript", [
+        "-e",
+        `tell application "Terminal" to do script "cd \\"${e}\\""`
+      ]);
+    } else {
+      const e = I("gnome-terminal", ["--working-directory", t], { detached: !0, stdio: "ignore" });
+      e.on("error", () => {
+        I("xterm", ["-e", `cd "${t}" && exec ${process.env.SHELL ?? "bash"}`], {
+          detached: !0,
+          stdio: "ignore"
+        }).unref();
+      }), e.unref();
+    }
+    return { ok: !0 };
+  } catch (e) {
+    return { ok: !1, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+f.handle("agentorchestrator:openTerminalInWorkspace", async (n, t) => yn(t));
+f.handle("agentorchestrator:terminalSpawn", async (n, t) => {
+  if (F) {
+    try {
+      F.kill();
+    } catch {
+    }
+    F = null;
+  }
+  const e = ur();
+  if (!e)
+    return { ok: !1, error: "Terminal unavailable: node-pty not loaded. Rebuild with: npx electron-rebuild" };
+  const r = process.env[process.platform === "win32" ? "COMSPEC" : "SHELL"] ?? (process.platform === "win32" ? "cmd.exe" : "/bin/bash"), s = h.resolve(t || process.env.HOME || process.env.USERPROFILE || process.cwd());
+  try {
+    return F = e.spawn(r, [], {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd: s,
+      env: process.env
+    }), F.onData((i) => {
+      k == null || k.webContents.send("agentorchestrator:terminalData", i);
+    }), F.onExit(() => {
+      F = null, k == null || k.webContents.send("agentorchestrator:terminalExit", {});
+    }), { ok: !0 };
+  } catch (i) {
+    return F = null, { ok: !1, error: i instanceof Error ? i.message : String(i) };
+  }
+});
+f.on("agentorchestrator:terminalWrite", (n, t) => {
+  F && F.write(t);
+});
+f.handle("agentorchestrator:terminalResize", (n, t, e) => {
+  F && F.resize(t, e);
+});
+f.handle("agentorchestrator:terminalDestroy", () => {
+  if (F) {
+    try {
+      F.kill();
+    } catch {
+    }
+    F = null;
+  }
+});
+f.handle("agentorchestrator:writeWorkspaceConfig", async (n, t) => {
+  const e = h.join(t, pr), r = { version: 1, agentorchestrator: !0 };
+  return d.writeFileSync(e, JSON.stringify(r, null, 2), "utf8"), !0;
+});
+f.handle("agentorchestrator:claimWorkspace", async (n, t) => Zr(t));
+f.handle("agentorchestrator:releaseWorkspace", async (n, t) => t != null && t.trim() ? yt(t) : !1);
+f.handle("agentorchestrator:savePastedImage", async (n, t, e) => {
+  const r = /^data:([^;]+);base64,(.+)$/.exec(String(t ?? ""));
+  if (!r) throw new Error("Invalid image data");
+  const s = r[1], i = r[2], o = (e && typeof e == "string" ? e : s).toLowerCase(), a = o.includes("jpeg") || o.includes("jpg") ? "jpg" : o.includes("webp") ? "webp" : o.includes("gif") ? "gif" : "png", c = h.join(Q.tmpdir(), "agentorchestrator", "pasted-images");
+  d.mkdirSync(c, { recursive: !0 });
+  const u = h.join(c, `paste-${Date.now()}-${Math.random().toString(16).slice(2)}.${a}`);
+  return d.writeFileSync(u, Buffer.from(i, "base64")), { path: u, mimeType: o };
+});
+f.handle("agentorchestrator:listWorkspaceTree", async (n, t, e) => Ur(t, e));
+f.handle("agentorchestrator:readWorkspaceFile", async (n, t, e) => Br(t, e));
+f.handle("agentorchestrator:readWorkspaceTextFile", async (n, t, e) => zr(t, e));
+f.handle("agentorchestrator:writeWorkspaceFile", async (n, t, e, r) => qr(t, e, r));
+f.handle("agentorchestrator:pickWorkspaceSavePath", async (n, t, e) => Kr(t, e));
+f.handle("agentorchestrator:pickWorkspaceOpenPath", async (n, t) => Jr(t));
+f.handle("agentorchestrator:getGitStatus", async (n, t) => At(t));
+f.handle("agentorchestrator:gitCommit", async (n, t, e) => St(t, e));
+f.handle("agentorchestrator:gitPush", async (n, t, e) => pn(t, e));
+f.handle("agentorchestrator:gitDeploy", async (n, t, e) => hn(t));
+f.handle("agentorchestrator:gitBuild", async (n, t, e) => fn(t));
+f.handle("agentorchestrator:gitRelease", async (n, t, e) => mn(t));
+f.on("agentorchestrator:setRecentWorkspaces", (n, t) => {
+  Ee = Array.isArray(t) ? t : [], He();
+});
+f.on("agentorchestrator:setEditorMenuState", (n, t) => {
+  const e = !!t;
+  de !== e && (de = e, He());
+});
+f.handle("agentorchestrator:getProviderAuthStatus", async (n, t) => en(t));
+f.handle("agentorchestrator:startProviderLogin", async (n, t) => tn(t));
+f.handle("agentorchestrator:upgradeProviderCli", async (n, t) => rn(t));
+f.handle("agentorchestrator:setProviderApiKey", async (n, t, e) => pt(t, e));
+f.handle("agentorchestrator:getProviderApiKeyState", async (n, t) => ({ hasKey: pe(t).length > 0 }));
+f.handle("agentorchestrator:importProviderApiKeyFromEnv", async (n, t) => Ir(t));
+f.handle("agentorchestrator:resetApplicationData", async () => {
+  try {
+    const n = $.getPath("userData"), t = h.join(n, Le), e = h.join(t, rt), r = h.join(t, tt), s = h.join(t, nt);
+    d.existsSync(e) && d.unlinkSync(e), d.existsSync(r) && d.unlinkSync(r), d.existsSync(s) && d.unlinkSync(s);
+  } catch (n) {
+    console.error("Failed to reset application data:", n);
+  }
+  $.relaunch(), $.exit(0);
+});
+f.handle("agentorchestrator:getGeminiAvailableModels", async () => kt());
+f.handle("agentorchestrator:getAvailableModels", async () => an());
+f.handle("agentorchestrator:findInPage", async (n, t) => {
+  const e = n.sender;
+  !e || typeof t != "string" || !t.trim() || e.findInPage(t.trim(), { findNext: !1 });
+});
+f.handle("agentorchestrator:showContextMenu", async (n, t) => {
+  const e = t === "input-selection" || t === "chat-selection" ? t : null;
+  if (!e) return { ok: !1 };
+  const r = e === "input-selection" ? [
+    { label: "Undo", role: "undo" },
+    { label: "Redo", role: "redo" },
+    { type: "separator" },
+    { label: "Cut", role: "cut" },
+    { label: "Copy", role: "copy" },
+    { label: "Paste", role: "paste" },
+    { type: "separator" },
+    { label: "Select All", role: "selectAll" }
+  ] : [
+    { label: "Copy", role: "copy" },
+    { type: "separator" },
+    { label: "Select All", role: "selectAll" }
+  ], s = xe.buildFromTemplate(r), i = L.fromWebContents(n.sender) ?? L.getFocusedWindow() ?? L.getAllWindows()[0] ?? void 0;
+  return !i || i.isDestroyed() ? { ok: !1 } : (s.popup({ window: i }), { ok: !0 });
+});
+function T(n, t) {
+  const e = { action: n, ...t };
+  k == null || k.webContents.send("agentorchestrator:menu", e), k == null || k.webContents.send("fireharness:menu", e);
+}
+function wn() {
+  const n = process.env.VITE_PUBLIC ?? "", t = n ? h.join(n, "splash.png") : "";
+  let e = "";
+  try {
+    t && d.existsSync(t) && (e = `data:image/png;base64,${d.readFileSync(t).toString("base64")}`);
+  } catch (m) {
+    D("about-splash-base64-failed", { splashImagePath: t, error: _(m) }, "warn");
+  }
+  const r = $.getVersion(), s = "Barnaby", i = "Barnaby is an autonomous agent desktop for developers. It orchestrates parallel agent loops directly through your local CLI subscriptions.", o = "No API keys, no middleman. Connect to Codex, Claude, and Gemini via your existing terminal sessions. Experience workspace-aware agents with flexible split layouts and intelligent provider routing.", a = "incendiosoftware@gmail.com", c = Ae.shouldUseDarkColors, u = {
+    bg: c ? "#0b0b0b" : "#f5f5f5",
+    text: c ? "#e0e0e0" : "#171717",
+    h1: c ? "#ffffff" : "#0a0a0a",
+    version: c ? "#888" : "#525252",
+    description: c ? "#ffffff" : "#0a0a0a",
+    blurb: c ? "#aaa" : "#404040",
+    contact: c ? "#666" : "#737373",
+    link: c ? "#4daafc" : "#2563eb",
+    border: c ? "#222" : "#e5e5e5"
+  }, l = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>About ${s}</title>
+  <style>
+    html, body {
+      margin: 0;
+      padding: 0;
+      width: 100%;
+      height: 100%;
+      background: ${u.bg};
+      color: ${u.text};
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+      overflow: hidden;
+      user-select: none;
+    }
+    .container {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      height: 100%;
+      padding: 32px;
+      text-align: center;
+    }
+    .splash-container {
+      width: 320px;
+      margin-bottom: 24px;
+    }
+                .splash-container img { 
+                    width: 100%; 
+                    height: auto; 
+                    object-fit: contain; 
+                    max-width: 300px;
+                    max-height: 300px;
+                }    h1 {
+      margin: 0 0 4px 0;
+      font-size: 24px;
+      font-weight: 700;
+      color: ${u.h1};
+    }
+    .version {
+      color: ${u.version};
+      font-size: 13px;
+      margin-bottom: 24px;
+    }
+    .content {
+      max-width: 440px;
+    }
+    .description {
+      font-size: 16px;
+      line-height: 1.5;
+      margin-bottom: 12px;
+      font-weight: 600;
+      color: ${u.description};
+    }
+    .blurb {
+      font-size: 14px;
+      line-height: 1.5;
+      color: ${u.blurb};
+      margin-bottom: 32px;
+    }
+    .contact {
+      font-size: 12px;
+      color: ${u.contact};
+      border-top: 1px solid ${u.border};
+      padding-top: 16px;
+      width: 100%;
+    }
+    .contact a {
+      color: ${u.link};
+      text-decoration: none;
+      cursor: pointer;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="splash-container">
+      <img src="${e}" alt="Barnaby Splash" />
+    </div>
+    <h1>${s}</h1>
+    <div class="version">Version ${r}</div>
+    <div class="content">
+      <div class="description">${i}</div>
+      <div class="blurb">${o}</div>
+    </div>
+    <div class="contact">
+      Contact: <a href="mailto:${a}">${a}</a> | <a href="https://barnaby.build">barnaby.build</a>
+    </div>
+  </div>
+</body>
+</html>`, p = new L({
+    width: 500,
+    height: 540,
+    resizable: !1,
+    minimizable: !1,
+    maximizable: !1,
+    fullscreenable: !1,
+    title: `About ${s}`,
+    autoHideMenuBar: !0,
+    backgroundColor: u.bg,
+    parent: k ?? void 0,
+    modal: !!k,
+    show: !1,
+    webPreferences: {
+      nodeIntegration: !1,
+      contextIsolation: !0
+    }
+  });
+  p.setMenuBarVisibility(!1), p.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(l)}`), p.webContents.setWindowOpenHandler(({ url: m }) => ((m.startsWith("http:") || m.startsWith("https:") || m.startsWith("mailto:")) && z.openExternal(m), { action: "deny" })), p.once("ready-to-show", () => {
+    p.show();
+  });
+}
+function He() {
+  const n = Ee.length > 0 ? Ee.slice(0, 10).map((e) => ({
+    label: h.basename(e) || e,
+    click: () => T("openWorkspace", { path: e })
+  })) : [{ label: "(none)", enabled: !1 }], t = [
+    {
+      label: "File",
+      submenu: [
+        { label: "New Agent", accelerator: "CmdOrCtrl+Shift+N", click: () => T("newAgentWindow") },
+        { label: "New Workspace", click: () => T("newWorkspace") },
+        { label: "New File", accelerator: "CmdOrCtrl+N", click: () => T("newFile") },
+        { type: "separator" },
+        {
+          label: "Open Agent",
+          click: () => {
+            Lr().then((e) => {
+              !e.ok && e.error && me.showErrorBox("Open Agent", `Could not open agent history folder:
+${e.error}`);
+            });
+          }
+        },
+        { label: "Open Workspace", click: () => T("openWorkspacePicker") },
+        { label: "Open File", click: () => T("openFile") },
+        { label: "Open Recent", submenu: n },
+        { label: "Save", accelerator: "CmdOrCtrl+S", enabled: de, click: () => T("saveEditorFile") },
+        { label: "Save As", accelerator: "CmdOrCtrl+Shift+S", enabled: de, click: () => T("saveEditorFileAs") },
+        { type: "separator" },
+        { label: "Close", accelerator: "CmdOrCtrl+W", click: () => T("closeFocused") },
+        { label: "Close Workspace", click: () => T("closeWorkspace") },
+        { label: "Exit", role: "quit" }
+      ]
+    },
+    {
+      label: "Edit",
+      submenu: [
+        { label: "Undo", role: "undo" },
+        { label: "Redo", role: "redo" },
+        { type: "separator" },
+        { label: "Cut", role: "cut" },
+        { label: "Copy", role: "copy" },
+        { label: "Paste", role: "paste" },
+        { label: "Find", accelerator: "CmdOrCtrl+F", click: () => T("findInPage") },
+        { label: "Find in Files", accelerator: "CmdOrCtrl+Shift+F", click: () => T("findInFiles") },
+        { type: "separator" },
+        { label: "Connectivity", click: () => T("openConnectivity") },
+        { label: "Models", click: () => T("openModelSetup") },
+        { label: "Preferences", accelerator: "CmdOrCtrl+,", click: () => T("openPreferences") },
+        { label: "Agents", click: () => T("openAgents") },
+        { label: "Orchestrator", click: () => T("openOrchestrator") },
+        { label: "Diagnostics", click: () => T("openDiagnostics") }
+      ]
+    },
+    {
+      label: "View",
+      submenu: [
+        {
+          label: "Layout",
+          submenu: [
+            { label: "Tile Vertical (V)", click: () => T("layoutVertical") },
+            { label: "Tile Horizontal (H)", click: () => T("layoutHorizontal") },
+            { label: "Tile / Grid", click: () => T("layoutGrid") }
+          ]
+        },
+        { label: "View Workspace Window", click: () => T("toggleWorkspaceWindow") },
+        { label: "View Code Window", click: () => T("toggleCodeWindow") },
+        { type: "separator" },
+        { role: "reload" },
+        { role: "toggleDevTools" },
+        { type: "separator" },
+        { label: "Reset Zoom", click: () => T("resetZoom") },
+        { label: "Zoom In", click: () => T("zoomIn") },
+        { label: "Zoom Out", click: () => T("zoomOut") },
+        { type: "separator" },
+        { role: "togglefullscreen" }
+      ]
+    },
+    {
+      label: "Help",
+      submenu: [
+        {
+          label: "About Barnaby",
+          click: () => {
+            wn();
+          }
+        }
+      ]
+    }
+  ];
+  xe.setApplicationMenu(xe.buildFromTemplate(t));
+}
+export {
+  _n as MAIN_DIST,
+  it as RENDERER_DIST,
+  X as VITE_DEV_SERVER_URL
+};