@fancyboi999/open-tag-daemon 0.1.0 → 0.3.0

package/dist/cli.mjs

@@ -3725,7 +3725,7 @@ try {
 // src/daemon/index.ts
 import os4 from "node:os";
 import fs3 from "node:fs";
-import path7 from "node:path";
+import path12 from "node:path";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3791,22 +3791,31 @@ function safeJson(o) {
   }
 }
 
+// src/daemonProtocol.ts
+var MACHINE_REJECTED_CODE = 4001;
+
 // src/daemon/connection.ts
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e4;
 var Connection = class {
-  constructor(url, key, onMsg, onOpen) {
+  constructor(url, key, onMsg, onOpen, mkWs = (u) => new wrapper_default(u)) {
     this.url = url;
     this.key = key;
     this.onMsg = onMsg;
     this.onOpen = onOpen;
+    this.mkWs = mkWs;
   }
   url;
   key;
   onMsg;
   onOpen;
+  mkWs;
   ws = null;
-  delay = 1e3;
+  delay = INITIAL_BACKOFF_MS;
   timer = null;
   should = true;
+  accepted = false;
+  // per-attempt: flips true once the server sends any frame (proof it accepted us, not rejected)
   log = createLogger("daemon:conn");
   connect() {
     this.should = true;
@@ -3824,13 +3833,17 @@ var Connection = class {
     if (!this.should) return;
     const wsUrl = this.url.replace(/^http/, "ws") + `/daemon/connect?key=${encodeURIComponent(this.key)}`;
     this.log.info("connecting", { url: this.url });
-    this.ws = new wrapper_default(wsUrl);
+    this.accepted = false;
+    this.ws = this.mkWs(wsUrl);
     this.ws.on("open", () => {
-      this.delay = 1e3;
       this.log.info("connected");
       this.onOpen();
     });
     this.ws.on("message", (d) => {
+      if (!this.accepted) {
+        this.accepted = true;
+        this.delay = INITIAL_BACKOFF_MS;
+      }
       let m;
       try {
         m = JSON.parse(d.toString());
@@ -3839,8 +3852,16 @@ var Connection = class {
       }
       this.onMsg(m);
     });
-    this.ws.on("close", () => {
-      this.log.warn("disconnected");
+    this.ws.on("close", (code, reason) => {
+      if (code === MACHINE_REJECTED_CODE) {
+        this.delay = MAX_BACKOFF_MS;
+        this.log.error(
+          "server rejected this machine: its connection key is unknown or was removed. Re-issue the connect command (workspace \u2192 Computers \u2192 this machine \u2192 Reconnect), then restart the daemon with the new key.",
+          { code, reason: reason?.toString?.() ?? String(reason ?? "") }
+        );
+      } else {
+        this.log.warn("disconnected", { code });
+      }
       this.scheduleReconnect();
     });
     this.ws.on("error", (e) => this.log.error("ws error", { detail: String(e?.message ?? e) }));
@@ -3852,13 +3873,13 @@ var Connection = class {
       this.timer = null;
       this.doConnect();
     }, this.delay);
-    this.delay = Math.min(this.delay * 2, 3e4);
+    this.delay = Math.min(this.delay * 2, MAX_BACKOFF_MS);
   }
 };
 
 // src/daemon/agentManager.ts
 import { mkdir, writeFile, readFile, access, rm } from "node:fs/promises";
-import path5 from "node:path";
+import path10 from "node:path";
 import os2 from "node:os";
 
 // src/daemon/prompt.ts
@@ -4421,6 +4442,893 @@ var codexRuntime = {
   }
 };
 
+// src/daemon/copilotRuntime.ts
+import { spawn as spawn3 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { writeFileSync as writeFileSync2 } from "node:fs";
+import path5 from "node:path";
+var MAX3 = 2e3;
+var clip3 = (s) => String(s ?? "").slice(0, MAX3);
+var EFFORTS2 = /* @__PURE__ */ new Set(["none", "low", "medium", "high", "xhigh", "max"]);
+function reasoningEffort2(rc) {
+  const e = rc?.reasoningEffort;
+  return typeof e === "string" && EFFORTS2.has(e) ? e : null;
+}
+function summarizeToolArgs(tr) {
+  let args2 = tr?.arguments;
+  if (typeof args2 === "string") {
+    try {
+      args2 = JSON.parse(args2);
+    } catch {
+      return clip3(args2).slice(0, 160);
+    }
+  }
+  if (!args2 || typeof args2 !== "object") return "";
+  const v = args2.command ?? args2.path ?? args2.file_path ?? args2.filePath ?? args2.query ?? args2.pattern ?? args2.url ?? "";
+  return clip3(typeof v === "string" ? v : JSON.stringify(v)).slice(0, 160);
+}
+function handleCopilotEvent(evt) {
+  const out = { trajectory: [] };
+  const data = evt?.data ?? {};
+  switch (evt?.type) {
+    case "assistant.turn_start":
+      out.activity = { activity: "working", detail: "turn" };
+      break;
+    case "assistant.message": {
+      if (data.content) out.trajectory.push({ kind: "text", text: clip3(data.content) });
+      if (Array.isArray(data.toolRequests))
+        for (const tr of data.toolRequests)
+          out.trajectory.push({ kind: "tool", toolName: String(tr?.name ?? "tool"), toolInput: summarizeToolArgs(tr) });
+      break;
+    }
+    case "assistant.reasoning":
+      if (data.content) out.trajectory.push({ kind: "thinking", text: clip3(data.content) });
+      break;
+    case "result":
+      if (typeof evt.sessionId === "string" && evt.sessionId) out.sessionId = evt.sessionId;
+      if (typeof evt.exitCode === "number") out.exitCode = evt.exitCode;
+      break;
+    case "session.error":
+      out.error = clip3(data.message ?? data.error ?? "copilot session error");
+      break;
+  }
+  return out;
+}
+function buildArgs(prompt, sessionId, model, effort) {
+  const args2 = ["-p", prompt, "--output-format", "json", "--allow-all", "--no-ask-user", "--session-id", sessionId];
+  const m = model && model !== "default" ? model : "";
+  if (m) args2.push("--model", m);
+  if (effort) args2.push("--effort", effort);
+  return args2;
+}
+var CopilotRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    this.sessionId = opts.sessionId || randomUUID();
+    this.env = { ...opts.env };
+    delete this.env.NODE_OPTIONS;
+    try {
+      writeFileSync2(path5.join(opts.cwd, "AGENTS.md"), opts.systemPrompt);
+    } catch (e) {
+      cb.log.warn("copilot: AGENTS.md write failed", { detail: String(e) });
+    }
+    cb.onSession(this.sessionId);
+    this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  sessionId;
+  everSucceeded = false;
+  env;
+  enqueue(text) {
+    if (this.stopped) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(prompt) {
+    this.turnBusy = true;
+    this.cb.onActivity("working", "turn");
+    const args2 = buildArgs(prompt, this.sessionId, this.opts.model, reasoningEffort2(this.opts.runtimeConfig));
+    const proc = spawn3("copilot", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: this.env });
+    this.proc = proc;
+    let buf = "";
+    let resultSeen = false;
+    const errTail = [];
+    let errLen = 0;
+    const processLine = (ln) => {
+      const t = ln.trim();
+      if (!t) return;
+      let evt;
+      try {
+        evt = JSON.parse(t);
+      } catch {
+        return;
+      }
+      const emit = handleCopilotEvent(evt);
+      if (emit.exitCode !== void 0) resultSeen = true;
+      if (emit.error) {
+        this.cb.onTrajectory([{ kind: "text", text: "[copilot error] " + emit.error.slice(0, 500) }]);
+        this.cb.onActivity("error", emit.error.slice(0, 200));
+      }
+      if (emit.activity) this.cb.onActivity(emit.activity.activity, emit.activity.detail);
+      if (emit.trajectory.length) this.cb.onTrajectory(emit.trajectory);
+    };
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      buf += c.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const ln of lines) processLine(ln);
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 4096 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("copilot spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "copilot not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", (code) => {
+      if (buf.trim()) processLine(buf);
+      buf = "";
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      if (code === 0 || resultSeen) {
+        this.everSucceeded = true;
+        this.cb.onActivity("online", "");
+        this.pump();
+        return;
+      }
+      const tail = errTail.join("").trim();
+      const last = tail.split("\n").filter(Boolean).pop() || `copilot exited ${code ?? "signal"}`;
+      this.cb.onTrajectory([{ kind: "text", text: "[copilot error] " + clip3(tail).slice(0, 500) }]);
+      this.cb.onActivity("error", last.slice(0, 200));
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var copilotRuntime = {
+  name: "copilot",
+  experimental: true,
+  start(opts, cb) {
+    const run = new CopilotRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
+// src/daemon/opencodeRuntime.ts
+import { spawn as spawn4 } from "node:child_process";
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import path6 from "node:path";
+var MAX4 = 2e3;
+var clip4 = (s) => String(s ?? "").slice(0, MAX4);
+function variant(rc) {
+  const e = rc?.reasoningEffort;
+  return typeof e === "string" && e ? e : null;
+}
+function summarizeToolInput(input) {
+  if (!input || typeof input !== "object") return clip4(input).slice(0, 160);
+  const v = input.command ?? input.filePath ?? input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.url ?? "";
+  return clip4(typeof v === "string" ? v : JSON.stringify(v)).slice(0, 160);
+}
+function handleOpencodeEvent(evt) {
+  const out = { trajectory: [] };
+  if (typeof evt?.sessionID === "string" && evt.sessionID) out.sessionId = evt.sessionID;
+  const part = evt?.part ?? {};
+  switch (evt?.type) {
+    case "step_start":
+      out.activity = { activity: "working", detail: "turn" };
+      break;
+    case "text":
+      if (part.text) out.trajectory.push({ kind: "text", text: clip4(part.text) });
+      break;
+    case "reasoning":
+      if (part.text) out.trajectory.push({ kind: "thinking", text: clip4(part.text) });
+      break;
+    case "tool_use": {
+      const name = String(part.tool ?? "tool");
+      const input = part.state?.input ?? part.input;
+      out.trajectory.push({ kind: "tool", toolName: name, toolInput: summarizeToolInput(input) });
+      break;
+    }
+    case "error":
+      out.error = String(evt.error?.data?.message ?? evt.error?.name ?? "opencode error");
+      break;
+  }
+  return out;
+}
+function buildArgs2(message, opts, sessionId) {
+  const args2 = ["run", "--format", "json", "--dangerously-skip-permissions", "--dir", opts.cwd];
+  const model = opts.model && opts.model !== "default" ? opts.model : "";
+  if (model) args2.push("--model", model);
+  const v = variant(opts.runtimeConfig);
+  if (v) args2.push("--variant", v);
+  if (sessionId) args2.push("--session", sessionId);
+  args2.push(message);
+  return args2;
+}
+var OpencodeRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    this.sessionId = opts.sessionId ?? null;
+    this.env = { ...opts.env, PWD: opts.cwd };
+    delete this.env.NODE_OPTIONS;
+    try {
+      writeFileSync3(path6.join(opts.cwd, "AGENTS.md"), opts.systemPrompt);
+    } catch (e) {
+      cb.log.warn("opencode: AGENTS.md write failed", { detail: String(e) });
+    }
+    if (this.sessionId) cb.onSession(this.sessionId);
+    this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  sessionId;
+  everSucceeded = false;
+  env;
+  enqueue(text) {
+    if (this.stopped) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(message) {
+    this.turnBusy = true;
+    this.cb.onActivity("working", "turn");
+    const args2 = buildArgs2(message, this.opts, this.sessionId);
+    const proc = spawn4("opencode", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: this.env });
+    this.proc = proc;
+    let buf = "";
+    const errTail = [];
+    let errLen = 0;
+    const processLine = (ln) => {
+      const t = ln.trim();
+      if (!t) return;
+      let evt;
+      try {
+        evt = JSON.parse(t);
+      } catch {
+        return;
+      }
+      const emit = handleOpencodeEvent(evt);
+      if (emit.sessionId && emit.sessionId !== this.sessionId) {
+        this.sessionId = emit.sessionId;
+        this.cb.onSession(emit.sessionId);
+      }
+      if (emit.error) {
+        this.cb.onTrajectory([{ kind: "text", text: "[opencode error] " + emit.error.slice(0, 500) }]);
+        this.cb.onActivity("error", emit.error.slice(0, 200));
+      }
+      if (emit.activity) this.cb.onActivity(emit.activity.activity, emit.activity.detail);
+      if (emit.trajectory.length) this.cb.onTrajectory(emit.trajectory);
+    };
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      buf += c.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const ln of lines) processLine(ln);
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 4096 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("opencode spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "opencode not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", (code) => {
+      if (buf.trim()) processLine(buf);
+      buf = "";
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      if (code === 0) {
+        this.everSucceeded = true;
+        this.cb.onActivity("online", "");
+        this.pump();
+        return;
+      }
+      const tail = errTail.join("").trim();
+      const last = tail.split("\n").filter(Boolean).pop() || `opencode exited ${code ?? "signal"}`;
+      this.cb.onTrajectory([{ kind: "text", text: "[opencode error] " + clip4(tail).slice(0, 500) }]);
+      this.cb.onActivity("error", last.slice(0, 200));
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var opencodeRuntime = {
+  name: "opencode",
+  experimental: true,
+  start(opts, cb) {
+    const run = new OpencodeRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
+// src/daemon/kimiRuntime.ts
+import { spawn as spawn5 } from "node:child_process";
+import { writeFileSync as writeFileSync4 } from "node:fs";
+import path7 from "node:path";
+var MAX5 = 2e3;
+var clip5 = (s) => String(s ?? "").slice(0, MAX5);
+function summarizeToolArgs2(argsJson) {
+  let a = argsJson;
+  if (typeof a === "string") {
+    try {
+      a = JSON.parse(a);
+    } catch {
+      return clip5(a).slice(0, 160);
+    }
+  }
+  if (!a || typeof a !== "object") return "";
+  const v = a.command ?? a.filePath ?? a.file_path ?? a.path ?? a.pattern ?? a.query ?? a.url ?? "";
+  return clip5(typeof v === "string" ? v : JSON.stringify(v)).slice(0, 160);
+}
+function handleKimiEvent(evt) {
+  const out = { trajectory: [] };
+  if (evt?.role === "meta" && evt.type === "session.resume_hint" && typeof evt.session_id === "string") {
+    out.sessionId = evt.session_id;
+    return out;
+  }
+  if (evt?.role === "assistant") {
+    if (typeof evt.content === "string" && evt.content) out.trajectory.push({ kind: "text", text: clip5(evt.content) });
+    if (Array.isArray(evt.tool_calls))
+      for (const tc of evt.tool_calls) {
+        const fn = tc?.function ?? {};
+        out.trajectory.push({ kind: "tool", toolName: String(fn.name ?? "tool"), toolInput: summarizeToolArgs2(fn.arguments) });
+      }
+  }
+  return out;
+}
+function buildArgs3(prompt, model, sessionId) {
+  const args2 = ["-p", prompt, "--output-format", "stream-json"];
+  const m = model && model !== "default" ? model : "";
+  if (m) args2.push("-m", m);
+  if (sessionId) args2.push("-r", sessionId);
+  return args2;
+}
+var KimiRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    this.sessionId = opts.sessionId ?? null;
+    this.env = { ...opts.env, PWD: opts.cwd };
+    delete this.env.NODE_OPTIONS;
+    try {
+      writeFileSync4(path7.join(opts.cwd, "AGENTS.md"), opts.systemPrompt);
+    } catch (e) {
+      cb.log.warn("kimi: AGENTS.md write failed", { detail: String(e) });
+    }
+    if (this.sessionId) cb.onSession(this.sessionId);
+    this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  sessionId;
+  everSucceeded = false;
+  env;
+  enqueue(text) {
+    if (this.stopped) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(prompt) {
+    this.turnBusy = true;
+    this.cb.onActivity("working", "turn");
+    const args2 = buildArgs3(prompt, this.opts.model, this.sessionId);
+    const proc = spawn5("kimi", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: this.env });
+    this.proc = proc;
+    let buf = "";
+    const errTail = [];
+    let errLen = 0;
+    const processLine = (ln) => {
+      const t = ln.trim();
+      if (!t) return;
+      let evt;
+      try {
+        evt = JSON.parse(t);
+      } catch {
+        return;
+      }
+      const emit = handleKimiEvent(evt);
+      if (emit.sessionId && emit.sessionId !== this.sessionId) {
+        this.sessionId = emit.sessionId;
+        this.cb.onSession(emit.sessionId);
+      }
+      if (emit.activity) this.cb.onActivity(emit.activity.activity, emit.activity.detail);
+      if (emit.trajectory.length) this.cb.onTrajectory(emit.trajectory);
+    };
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      buf += c.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const ln of lines) processLine(ln);
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 4096 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("kimi spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "kimi not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", (code) => {
+      if (buf.trim()) processLine(buf);
+      buf = "";
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      if (code === 0) {
+        this.everSucceeded = true;
+        this.cb.onActivity("online", "");
+        this.pump();
+        return;
+      }
+      const tail = errTail.join("").trim();
+      if (/not found|no session|session .* not/i.test(tail)) this.sessionId = null;
+      const last = tail.split("\n").filter(Boolean).pop() || `kimi exited ${code ?? "signal"}`;
+      this.cb.onTrajectory([{ kind: "text", text: "[kimi error] " + clip5(tail).slice(0, 500) }]);
+      this.cb.onActivity("error", last.slice(0, 200));
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var kimiRuntime = {
+  name: "kimi",
+  experimental: true,
+  start(opts, cb) {
+    const run = new KimiRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
+// src/daemon/piRuntime.ts
+import { spawn as spawn6 } from "node:child_process";
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import path8 from "node:path";
+var MAX6 = 2e3;
+var clip6 = (s) => String(s ?? "").slice(0, MAX6);
+function summarizeToolArgs3(args2) {
+  if (!args2 || typeof args2 !== "object") return clip6(args2).slice(0, 160);
+  const v = args2.command ?? args2.filePath ?? args2.file_path ?? args2.path ?? args2.pattern ?? args2.query ?? args2.url ?? "";
+  return clip6(typeof v === "string" ? v : JSON.stringify(v)).slice(0, 160);
+}
+function handlePiEvent(evt) {
+  const out = { trajectory: [] };
+  if (evt?.type === "session" && typeof evt.id === "string") {
+    out.sessionId = evt.id;
+    return out;
+  }
+  if (evt?.type === "message_end" && evt.message?.role === "assistant") {
+    const m = evt.message;
+    if (Array.isArray(m.content))
+      for (const b of m.content) {
+        if (b?.type === "text" && b.text) out.trajectory.push({ kind: "text", text: clip6(b.text) });
+        else if (b?.type === "toolCall") out.trajectory.push({ kind: "tool", toolName: String(b.name ?? "tool"), toolInput: summarizeToolArgs3(b.arguments) });
+      }
+    if (m.stopReason === "error") out.error = String(m.errorMessage ?? "pi model error (no message)");
+  }
+  return out;
+}
+function buildArgs4(prompt, model, sessionId, cwd, promptFile) {
+  const args2 = ["-p", prompt, "--mode", "json", "--append-system-prompt", promptFile, "--session-dir", cwd];
+  const m = model && model !== "default" ? model : "";
+  if (m) args2.push("--model", m);
+  if (sessionId) args2.push("--session", sessionId);
+  return args2;
+}
+var PiRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    this.sessionId = opts.sessionId ?? null;
+    this.promptFile = path8.join(opts.cwd, ".pi-system-prompt.md");
+    this.env = { ...opts.env };
+    delete this.env.NODE_OPTIONS;
+    try {
+      writeFileSync5(this.promptFile, opts.systemPrompt);
+    } catch (e) {
+      this.promptWriteFailed = true;
+      cb.log.warn("pi: system-prompt write failed", { detail: String(e) });
+    }
+    if (this.sessionId) cb.onSession(this.sessionId);
+    this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  sessionId;
+  everSucceeded = false;
+  promptFile;
+  env;
+  promptWriteFailed = false;
+  enqueue(text) {
+    if (this.stopped) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(prompt) {
+    this.turnBusy = true;
+    if (this.promptWriteFailed) {
+      this.cb.onTrajectory([{ kind: "text", text: "[pi error] system-prompt write failed \u2014 check cwd permissions" }]);
+      this.cb.onActivity("error", "pi: system-prompt write failed");
+      this.turnBusy = false;
+      if (!this.everSucceeded) {
+        this.cb.onExit(1);
+        return;
+      }
+      return;
+    }
+    this.cb.onActivity("working", "turn");
+    const args2 = buildArgs4(prompt, this.opts.model, this.sessionId, this.opts.cwd, this.promptFile);
+    const proc = spawn6("pi", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: this.env });
+    this.proc = proc;
+    let buf = "";
+    const errTail = [];
+    let errLen = 0;
+    const processLine = (ln) => {
+      const t = ln.trim();
+      if (!t) return;
+      let evt;
+      try {
+        evt = JSON.parse(t);
+      } catch {
+        return;
+      }
+      const emit = handlePiEvent(evt);
+      if (emit.sessionId && emit.sessionId !== this.sessionId) {
+        this.sessionId = emit.sessionId;
+        this.cb.onSession(emit.sessionId);
+      }
+      if (emit.trajectory.length) this.cb.onTrajectory(emit.trajectory);
+      if (emit.error) {
+        this.cb.onTrajectory([{ kind: "text", text: "[pi error] " + clip6(emit.error).slice(0, 500) }]);
+        this.cb.onActivity("error", emit.error.slice(0, 200));
+      }
+    };
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      buf += c.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const ln of lines) processLine(ln);
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 4096 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("pi spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "pi not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", (code) => {
+      if (buf.trim()) processLine(buf);
+      buf = "";
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      if (code === 0) {
+        this.everSucceeded = true;
+        this.cb.onActivity("online", "");
+        this.pump();
+        return;
+      }
+      const tail = errTail.join("").trim();
+      const last = tail.split("\n").filter(Boolean).pop() || `pi exited ${code ?? "signal"}`;
+      this.cb.onTrajectory([{ kind: "text", text: "[pi error] " + clip6(tail).slice(0, 500) }]);
+      this.cb.onActivity("error", last.slice(0, 200));
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var piRuntime = {
+  name: "pi",
+  experimental: true,
+  start(opts, cb) {
+    const run = new PiRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
+// src/daemon/cursorRuntime.ts
+import { spawn as spawn7 } from "node:child_process";
+import { writeFileSync as writeFileSync6 } from "node:fs";
+import path9 from "node:path";
+var MAX7 = 2e3;
+var clip7 = (s) => String(s ?? "").slice(0, MAX7);
+function summarizeToolArgs4(args2) {
+  if (!args2 || typeof args2 !== "object") return clip7(args2).slice(0, 160);
+  const v = args2.command ?? args2.filePath ?? args2.file_path ?? args2.path ?? args2.pattern ?? args2.query ?? args2.url ?? "";
+  return clip7(typeof v === "string" ? v : JSON.stringify(v)).slice(0, 160);
+}
+function handleCursorEvent(evt) {
+  const out = { trajectory: [] };
+  if (typeof evt?.session_id === "string" && evt.session_id) out.sessionId = evt.session_id;
+  if (evt?.type === "tool_call" && evt.subtype === "started") {
+    const tc = evt.tool_call;
+    if (tc && typeof tc === "object") {
+      const key = Object.keys(tc).find((k) => k.endsWith("ToolCall")) ?? Object.keys(tc)[0] ?? "tool";
+      const name = key.replace(/ToolCall$/, "") || "tool";
+      out.trajectory.push({ kind: "tool", toolName: name, toolInput: summarizeToolArgs4(tc[key]?.args) });
+    }
+  } else if (evt?.type === "result") {
+    out.resultSeen = true;
+    if (evt.is_error) out.error = clip7(evt.result) || "cursor reported an error";
+    else if (evt.result != null) out.trajectory.push({ kind: "text", text: clip7(evt.result) });
+  } else if (evt?.type === "system" && evt?.subtype === "error") {
+    out.error = clip7(evt.error ?? evt.message ?? "cursor system error");
+  }
+  return out;
+}
+function buildArgs5(prompt, model, sessionId) {
+  const args2 = ["-p", prompt, "--output-format", "stream-json", "-f"];
+  const m = model && model !== "default" ? model : "";
+  if (m) args2.push("--model", m);
+  if (sessionId) args2.push("--resume", sessionId);
+  return args2;
+}
+var CursorRun = class {
+  constructor(opts, cb) {
+    this.opts = opts;
+    this.cb = cb;
+    this.sessionId = opts.sessionId ?? null;
+    this.env = { ...opts.env };
+    delete this.env.NODE_OPTIONS;
+    try {
+      writeFileSync6(path9.join(opts.cwd, "AGENTS.md"), opts.systemPrompt);
+    } catch (e) {
+      cb.log.warn("cursor: AGENTS.md write failed", { detail: String(e) });
+    }
+    if (this.sessionId) cb.onSession(this.sessionId);
+    this.enqueue(opts.initialPrompt);
+  }
+  opts;
+  cb;
+  queue = [];
+  turnBusy = false;
+  stopped = false;
+  proc = null;
+  sessionId;
+  everSucceeded = false;
+  env;
+  enqueue(text) {
+    if (this.stopped) return;
+    this.queue.push(text);
+    this.pump();
+  }
+  pump() {
+    if (this.stopped || this.turnBusy || this.queue.length === 0) return;
+    this.runTurn(this.queue.shift());
+  }
+  runTurn(prompt) {
+    this.turnBusy = true;
+    this.cb.onActivity("working", "turn");
+    const args2 = buildArgs5(prompt, this.opts.model, this.sessionId);
+    const proc = spawn7("cursor-agent", args2, { cwd: this.opts.cwd, stdio: ["ignore", "pipe", "pipe"], env: this.env });
+    this.proc = proc;
+    let buf = "";
+    let resultSeen = false;
+    let resultError = false;
+    const errTail = [];
+    let errLen = 0;
+    const processLine = (ln) => {
+      const t = ln.trim();
+      if (!t) return;
+      let evt;
+      try {
+        evt = JSON.parse(t);
+      } catch {
+        return;
+      }
+      const emit = handleCursorEvent(evt);
+      if (emit.sessionId && emit.sessionId !== this.sessionId) {
+        this.sessionId = emit.sessionId;
+        this.cb.onSession(emit.sessionId);
+      }
+      if (emit.resultSeen) resultSeen = true;
+      if (emit.error) {
+        resultError = true;
+        this.cb.onTrajectory([{ kind: "text", text: "[cursor error] " + clip7(emit.error).slice(0, 500) }]);
+        this.cb.onActivity("error", emit.error.slice(0, 200));
+      }
+      if (emit.trajectory.length) this.cb.onTrajectory(emit.trajectory);
+    };
+    proc.stdout?.on("data", (c) => {
+      if (this.stopped) return;
+      buf += c.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const ln of lines) processLine(ln);
+    });
+    proc.stderr?.on("data", (c) => {
+      const t = c.toString();
+      errTail.push(t);
+      errLen += t.length;
+      while (errLen > 4096 && errTail.length > 1) errLen -= errTail.shift().length;
+    });
+    proc.on("error", (e) => {
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      this.cb.log.error("cursor spawn failed", { detail: String(e?.message ?? e) });
+      this.cb.onActivity("offline", "cursor-agent not found");
+      if (!this.everSucceeded) this.cb.onExit(1);
+      else this.pump();
+    });
+    proc.on("exit", (code) => {
+      if (buf.trim()) processLine(buf);
+      buf = "";
+      this.proc = null;
+      this.turnBusy = false;
+      if (this.stopped) return;
+      if (code === 0) {
+        if (!resultError) {
+          this.everSucceeded = true;
+          this.cb.onActivity("online", "");
+        } else if (!this.everSucceeded) {
+          this.cb.onExit(1);
+          return;
+        }
+        this.pump();
+        return;
+      }
+      if (!resultError) {
+        const tail = errTail.join("").trim();
+        const last = tail.split("\n").filter(Boolean).pop() || `cursor-agent exited ${code ?? "signal"}`;
+        this.cb.onTrajectory([{ kind: "text", text: "[cursor error] " + clip7(tail).slice(0, 500) }]);
+        this.cb.onActivity("error", last.slice(0, 200));
+      }
+      if (!this.everSucceeded) {
+        this.cb.onExit(code ?? 1);
+        return;
+      }
+      this.pump();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (p) {
+      try {
+        p.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+};
+var cursorRuntime = {
+  name: "cursor",
+  experimental: true,
+  start(opts, cb) {
+    const run = new CursorRun(opts, cb);
+    return { deliver: (text) => run.enqueue(text), stop: () => run.stop() };
+  }
+};
+
 // src/daemon/runtimes.ts
 function has(tool) {
   try {
@@ -4431,10 +5339,10 @@ function has(tool) {
   }
 }
 function detectRuntimes() {
-  const found = ["claude", "codex", "kimi", "gemini", "opencode"].filter(has);
+  const found = ["claude", "codex", "copilot", "kimi", "opencode", "pi", "cursor-agent"].filter(has).map((t) => t === "cursor-agent" ? "cursor" : t);
   return found;
 }
-var REG = { claude: claudeRuntime, codex: codexRuntime };
+var REG = { claude: claudeRuntime, codex: codexRuntime, copilot: copilotRuntime, opencode: opencodeRuntime, kimi: kimiRuntime, pi: piRuntime, cursor: cursorRuntime };
 function getRuntime(name) {
   return REG[name] ?? null;
 }
@@ -4485,7 +5393,7 @@ var AgentManager = class {
   async reset(agentId, wipeWorkspace = false, clearMemory = false) {
     this.teardown(agentId);
     this.send({ type: "agent:session", agentId, sessionId: null });
-    const dir = path5.join(DATA_DIR, agentId);
+    const dir = path10.join(DATA_DIR, agentId);
     if (wipeWorkspace) {
       try {
         await rm(dir, { recursive: true, force: true });
@@ -4495,7 +5403,7 @@ var AgentManager = class {
       }
     } else if (clearMemory) {
       try {
-        await writeFile(path5.join(dir, "MEMORY.md"), "# Memory\n\n(reset)\n");
+        await writeFile(path10.join(dir, "MEMORY.md"), "# Memory\n\n(reset)\n");
         this.log.info("memory cleared", { agentId });
       } catch (e) {
         this.log.warn("clearMemory failed", { agentId, detail: String(e) });
@@ -4509,7 +5417,7 @@ var AgentManager = class {
    *  title + `## Role`, preserving the agent's own sections. No-op if the workspace/file doesn't exist
    *  yet (a not-yet-started agent gets fresh values from the DB when start() seeds it). */
   async syncProfile(agentId, displayName, description) {
-    const mem = path5.join(DATA_DIR, agentId, "MEMORY.md");
+    const mem = path10.join(DATA_DIR, agentId, "MEMORY.md");
     let content;
     try {
       content = await readFile(mem, "utf8");
@@ -4551,9 +5459,9 @@ var AgentManager = class {
       return;
     }
     if (runtime.experimental) this.log.warn("experimental runtime", { runtime: runtime.name });
-    const dir = path5.join(DATA_DIR, agentId);
-    await mkdir(path5.join(dir, "notes"), { recursive: true });
-    const mem = path5.join(dir, "MEMORY.md");
+    const dir = path10.join(DATA_DIR, agentId);
+    await mkdir(path10.join(dir, "notes"), { recursive: true });
+    const mem = path10.join(dir, "MEMORY.md");
     try {
       await access(mem);
     } catch {
@@ -4654,22 +5562,22 @@ var AgentManager = class {
 
 // src/daemon/workspace.ts
 import { readdir, readFile as readFile2, stat } from "node:fs/promises";
-import path6 from "node:path";
+import path11 from "node:path";
 import os3 from "node:os";
 var DATA_DIR2 = agentsDir();
 var MAX_FILE = 256 * 1024;
 var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 function safe(agentId, rel) {
-  const root = path6.join(DATA_DIR2, agentId);
-  const target = path6.resolve(root, rel || ".");
-  if (target !== root && !target.startsWith(root + path6.sep)) return null;
+  const root = path11.join(DATA_DIR2, agentId);
+  const target = path11.resolve(root, rel || ".");
+  if (target !== root && !target.startsWith(root + path11.sep)) return null;
   return target;
 }
 async function walk(root, rel, acc, depth) {
   if (depth > 6 || acc.length > 2e3) return;
   let ds;
   try {
-    ds = await readdir(path6.join(root, rel), { withFileTypes: true });
+    ds = await readdir(path11.join(root, rel), { withFileTypes: true });
   } catch {
     return;
   }
@@ -4679,7 +5587,7 @@ async function walk(root, rel, acc, depth) {
     let size = 0;
     let modifiedAt = null;
     try {
-      const s = await stat(path6.join(root, childRel));
+      const s = await stat(path11.join(root, childRel));
       size = d.isFile() ? s.size : 0;
       modifiedAt = s.mtime.toISOString();
     } catch {
@@ -4689,7 +5597,7 @@ async function walk(root, rel, acc, depth) {
   }
 }
 async function listWorkspace(agentId, _subPath = "") {
-  const root = path6.join(DATA_DIR2, agentId);
+  const root = path11.join(DATA_DIR2, agentId);
   try {
     const files = [];
     await walk(root, "", files, 0);
@@ -4727,7 +5635,7 @@ async function readSkillsDir(dir, sourcePath) {
     if (!e.isDirectory()) continue;
     let name = e.name, description = "", userInvocable = false;
     try {
-      const txt = await readFile2(path6.join(dir, e.name, "SKILL.md"), "utf8");
+      const txt = await readFile2(path11.join(dir, e.name, "SKILL.md"), "utf8");
       const fm = /^---\n([\s\S]*?)\n---/.exec(txt);
       if (fm) {
         name = fmField(fm[1], "name") || e.name;
@@ -4742,8 +5650,8 @@ async function readSkillsDir(dir, sourcePath) {
   return out;
 }
 async function listSkills(agentId) {
-  const global = await readSkillsDir(path6.join(os3.homedir(), ".claude", "skills"), "~/.claude/skills");
-  const workspace = await readSkillsDir(path6.join(DATA_DIR2, agentId, ".claude", "skills"), "<workspace>/.claude/skills");
+  const global = await readSkillsDir(path11.join(os3.homedir(), ".claude", "skills"), "~/.claude/skills");
+  const workspace = await readSkillsDir(path11.join(DATA_DIR2, agentId, ".claude", "skills"), "<workspace>/.claude/skills");
   return { global, workspace };
 }
 async function readWorkspaceFile(agentId, rel) {
@@ -4761,6 +5669,190 @@ async function readWorkspaceFile(agentId, rel) {
   }
 }
 
+// src/daemon/listModels.ts
+import { spawn as spawn8 } from "node:child_process";
+var titleCase = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
+function isModelId(s) {
+  return /^[A-Za-z][A-Za-z0-9\-_./]*$/.test(s);
+}
+var CLAUDE_MODELS = [
+  { id: "sonnet", label: "Sonnet" },
+  { id: "opus", label: "Opus" },
+  { id: "haiku", label: "Haiku" }
+];
+var CLAUDE_EFFORT_LABEL = {
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Max"
+};
+var CLAUDE_MODEL_EFFORT_ALLOW = {
+  opus: /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]),
+  sonnet: /* @__PURE__ */ new Set(["low", "medium", "high", "max"]),
+  haiku: /* @__PURE__ */ new Set(["low", "medium", "high"])
+};
+function parseClaudeEffortLevels(helpText) {
+  const m = /--effort\s*(?:<[^>]+>)?\s*(?:Effort level[^(]*)?\(([^)]+)\)/.exec(helpText);
+  if (!m) return [];
+  return m[1].split(",").map((s) => s.trim()).filter((s) => /^[a-z]+$/i.test(s));
+}
+function claudeThinkingForModel(modelId, superset) {
+  const allow = CLAUDE_MODEL_EFFORT_ALLOW[modelId];
+  const levels = superset.filter((v) => !allow || allow.has(v)).map((v) => ({ value: v, label: CLAUDE_EFFORT_LABEL[v] ?? titleCase(v) }));
+  if (!levels.length) return void 0;
+  return { levels, default: levels.some((l) => l.value === "medium") ? "medium" : levels[0].value };
+}
+function parseCodexModels(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    return [];
+  }
+  const models = Array.isArray(parsed?.models) ? parsed.models : [];
+  const out = [];
+  for (const m of models) {
+    if (m?.visibility !== "list") continue;
+    const slug = typeof m?.slug === "string" ? m.slug : "";
+    if (!slug) continue;
+    const raw = Array.isArray(m?.supported_reasoning_levels) ? m.supported_reasoning_levels : [];
+    const levels = raw.map((l) => ({ value: String(l?.effort ?? ""), label: titleCase(String(l?.effort ?? "")), description: typeof l?.description === "string" ? l.description : void 0 })).filter((l) => l.value);
+    const thinking = levels.length ? { levels, default: typeof m?.default_reasoning_level === "string" ? m.default_reasoning_level : void 0 } : void 0;
+    out.push({ id: slug, label: typeof m?.display_name === "string" && m.display_name ? m.display_name : slug, provider: "openai", ...thinking ? { thinking } : {} });
+  }
+  return out;
+}
+function parseOpencodeModels(stdout) {
+  const out = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("{") || line.startsWith('"') || line.startsWith("}")) continue;
+    if (line === line.toUpperCase() && /[A-Z]/.test(line)) continue;
+    const id = line.split(/\s+/)[0];
+    const slash = id.indexOf("/");
+    if (slash <= 0 || slash >= id.length - 1) continue;
+    out.push({ id, label: id, provider: id.slice(0, slash) });
+  }
+  return out;
+}
+function parseCursorModels(stdout) {
+  const out = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const sep = line.indexOf(" - ");
+    if (sep < 0) continue;
+    const id = line.slice(0, sep).trim();
+    if (!isModelId(id)) continue;
+    let label = line.slice(sep + 3).trim();
+    const isDefault = /default/i.test(label);
+    const paren = label.indexOf("(");
+    if (paren >= 0) label = label.slice(0, paren).trim();
+    out.push({ id, label: label || id, provider: "cursor", ...isDefault ? { default: true } : {} });
+  }
+  return out;
+}
+function parsePiModels(out) {
+  const res = [];
+  for (const raw of out.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (isPiNoise(line)) continue;
+    const fields = line.split(/\s+/);
+    const first = fields[0];
+    if (first.toLowerCase() === "provider") continue;
+    let id;
+    if (first.includes(":") || first.includes("/")) id = first.replace(":", "/");
+    else if (fields.length >= 2) id = `${first}/${fields[1]}`;
+    else continue;
+    const slash = id.indexOf("/");
+    if (slash <= 0 || slash >= id.length - 1) continue;
+    res.push({ id, label: id, provider: id.slice(0, slash) });
+  }
+  return res;
+}
+function isPiNoise(line) {
+  const l = line.toLowerCase();
+  return l.includes("no models match pattern") || l.startsWith("warning:") || l.startsWith("error:") || l.startsWith("info:");
+}
+var LIST_TIMEOUT_MS = 7e3;
+var OUT_CAP = 256 * 1024;
+function runList(bin, args2, timeoutMs = LIST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const env = { ...process.env };
+    delete env.NODE_OPTIONS;
+    let proc;
+    try {
+      proc = spawn8(bin, args2, { stdio: ["ignore", "pipe", "pipe"], env });
+    } catch (e) {
+      return resolve({ stdout: "", stderr: String(e?.message ?? e), code: 1 });
+    }
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c) => {
+      if (stdout.length < OUT_CAP) stdout += c.toString();
+    });
+    proc.stderr?.on("data", (c) => {
+      if (stderr.length < OUT_CAP) stderr += c.toString();
+    });
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }, timeoutMs);
+    proc.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr: stderr || String(e?.message ?? e), code: 1 });
+    });
+    proc.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code });
+    });
+  });
+}
+async function listModels(runtime) {
+  switch (runtime) {
+    case "opencode": {
+      let r = await runList("opencode", ["models", "--verbose"], 5e3);
+      let models = parseOpencodeModels(r.stdout);
+      if (!models.length) {
+        r = await runList("opencode", ["models"], 2e3);
+        models = parseOpencodeModels(r.stdout);
+      }
+      return models.length ? models : null;
+    }
+    case "cursor": {
+      const r = await runList("cursor-agent", ["--list-models"]);
+      const models = parseCursorModels(r.stdout);
+      return models.length ? models : null;
+    }
+    case "pi": {
+      const r = await runList("pi", ["--list-models"]);
+      const models = parsePiModels(r.stdout || r.stderr);
+      return models.length ? models : null;
+    }
+    case "claude": {
+      const r = await runList("claude", ["--help"]);
+      const superset = parseClaudeEffortLevels(r.stdout || r.stderr);
+      if (!superset.length) return null;
+      return CLAUDE_MODELS.map((m) => {
+        const thinking = claudeThinkingForModel(m.id, superset);
+        return { ...m, provider: "anthropic", ...thinking ? { thinking } : {} };
+      });
+    }
+    case "codex": {
+      const r = await runList("codex", ["debug", "models"]);
+      const models = parseCodexModels(r.stdout);
+      return models.length ? models : null;
+    }
+    default:
+      return null;
+  }
+}
+
 // src/daemon/index.ts
 var log = createLogger("daemon");
 var args = process.argv.slice(2);
@@ -4785,7 +5877,7 @@ var readMachineId = () => {
 };
 var saveMachineId = (id) => {
   try {
-    fs3.mkdirSync(path7.dirname(MID_FILE), { recursive: true });
+    fs3.mkdirSync(path12.dirname(MID_FILE), { recursive: true });
     fs3.writeFileSync(MID_FILE, id);
   } catch {
   }
@@ -4826,6 +5918,9 @@ conn = new Connection(serverUrl, apiKey, (msg) => {
     case "agent:skills:list":
       void listSkills(msg.agentId).then((r) => conn.send({ type: "skills:list", requestId: msg.requestId, agentId: msg.agentId, ...r }));
       break;
+    case "probe-models":
+      void listModels(msg.runtime ?? "").then((models) => conn.send({ type: "models", requestId: msg.requestId, runtime: msg.runtime, models })).catch((e) => conn.send({ type: "models", requestId: msg.requestId, runtime: msg.runtime, models: null, error: String(e?.message ?? e) }));
+      break;
     case "ping":
       conn.send({ type: "pong" });
       break;
@@ -4840,7 +5935,7 @@ conn = new Connection(serverUrl, apiKey, (msg) => {
     runningAgents: mgr.running(),
     hostname: os4.hostname(),
     os: `${os4.platform()} ${os4.arch()}`,
-    daemonVersion: "0.1.0",
+    daemonVersion: "0.3.0",
     machineId: readMachineId()
     // Stable identity: empty on first connection; server sends it back via ready:ack for persistence.
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fancyboi999/open-tag-daemon",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "open-tag compute-plane daemon — connect any machine to an open-tag server so its agents run there. No repo clone needed.",
   "license": "Apache-2.0",
   "type": "module",