@cecwxf/dsh-room 0.3.2 → 0.3.4

package/dist/index.js

@@ -416,8 +416,8 @@ __export(mcp_workspace_exports, {
   MCP_TOOL_DEFS: () => MCP_TOOL_DEFS,
   WorkspaceMcp: () => WorkspaceMcp
 });
-import { mkdir as mkdir3, readFile as readFile3, readdir, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join2, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { lstat, mkdir as mkdir3, readFile as readFile3, readdir, realpath, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, sep } from "node:path";
 import { spawn } from "node:child_process";
 function actionFor(tool) {
   if (tool === "workspace_write" || tool === "workspace_mkdir") return "fs.write";
@@ -482,16 +482,27 @@ var init_mcp_workspace = __esm({
         const root = resolve2(this.cfg.workspacePath);
         const target = resolve2(root, rel || ".");
         const relToRoot = relative2(root, target);
-        if (relToRoot.startsWith("..") || relToRoot.includes(`..${sep}`)) throw new Error("path escapes workspace");
-        try {
-          const { realpath } = await import("node:fs/promises");
-          const real = await realpath(target).catch(() => target);
-          const realRoot = await realpath(root).catch(() => root);
-          if (!real.startsWith(realRoot + sep) && real !== realRoot) throw new Error("path escapes workspace (symlink)");
-        } catch (e) {
-          if (e.message.includes("escapes")) throw e;
+        const outside = (p) => isAbsolute2(p) || p === ".." || p.startsWith(`..${sep}`);
+        if (outside(relToRoot)) throw new Error("path escapes workspace");
+        const realRoot = await realpath(root);
+        let ancestor = resolve2(realRoot, relToRoot);
+        const suffix = [];
+        while (true) {
+          let real;
+          try {
+            real = await realpath(ancestor);
+          } catch (e) {
+            if (e.code !== "ENOENT") throw e;
+            if ((await lstat(ancestor).catch(() => null))?.isSymbolicLink()) throw new Error("path escapes workspace (dangling symlink)");
+            const parent = dirname2(ancestor);
+            if (parent === ancestor) throw e;
+            suffix.unshift(relative2(parent, ancestor));
+            ancestor = parent;
+            continue;
+          }
+          if (outside(relative2(realRoot, real))) throw new Error("path escapes workspace (symlink)");
+          return resolve2(real, ...suffix);
         }
-        return target;
       }
       async maybeApprove(tool, summary, detail, from) {
         const action = actionFor(tool);
@@ -503,7 +514,7 @@ var init_mcp_workspace = __esm({
         if (cap) {
           const grant = resolvePeerGrant(this.cfg, from, cap);
           if (grant === "deny") throw new Error(`peer grant deny: ${cap} for ${from}`);
-          if (grant === "auto") return;
+          if (grant === "auto" && (cap !== "read" || this.cfg.permissions.autoRead)) return;
         }
         if (!action && cap === "read") {
           const decision2 = await this.approvals.request({
@@ -541,6 +552,7 @@ var init_mcp_workspace = __esm({
         await mkdir3(this.cfg.workspacePath, { recursive: true });
         switch (tool) {
           case "workspace_list": {
+            await this.maybeApprove(tool, `list ${args.path ?? "."}`, "", from);
             const dir = await this.resolveSafe(String(args.path ?? "."));
             const entries = await readdir(dir, { withFileTypes: true });
             return {
@@ -549,18 +561,20 @@ var init_mcp_workspace = __esm({
             };
           }
           case "workspace_read": {
-            if (!this.cfg.permissions.autoRead) await this.maybeApprove("workspace_read", `read ${args.path}`, "", from);
+            await this.maybeApprove(tool, `read ${args.path}`, "", from);
             const file = await this.resolveSafe(String(args.path ?? ""));
             const buf = await readFile3(file);
             if (buf.length > 256 * 1024) throw new Error("file too large (>256KiB)");
             return { path: String(args.path), content: buf.toString("utf8") };
           }
           case "workspace_stat": {
+            await this.maybeApprove(tool, `stat ${args.path}`, "", from);
             const file = await this.resolveSafe(String(args.path ?? ""));
             const st = await stat2(file);
             return { path: String(args.path), size: st.size, mtimeMs: st.mtimeMs, isDirectory: st.isDirectory(), isFile: st.isFile() };
           }
           case "workspace_search": {
+            await this.maybeApprove(tool, `search ${args.path ?? "."}`, String(args.query ?? ""), from);
             const q = String(args.query ?? "");
             if (!q) throw new Error("query required");
             const start = await this.resolveSafe(String(args.path ?? "."));
@@ -630,9 +644,22 @@ var init_mcp_workspace = __esm({
   }
 });
 
+// src/models.ts
+function resolveSelection(defaults, room = {}, agent = {}) {
+  return {
+    provider: agent.provider || room.provider || defaults.provider,
+    model: agent.model || room.model || defaults.model,
+    reasoningEffort: agent.reasoningEffort || room.reasoningEffort || defaults.reasoningEffort
+  };
+}
+function describeModel(selection, catalog) {
+  if (!selection.provider || !selection.model) return null;
+  return catalog.find((m) => m.provider === selection.provider && m.model === selection.model) ?? { provider: selection.provider, model: selection.model, name: selection.model };
+}
+
 // src/plugin.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4, appendFile as appendFile2 } from "node:fs/promises";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4, appendFile as appendFile2, rename as rename2, rm as rm3 } from "node:fs/promises";
 import { dirname as dirname4, join as join3 } from "node:path";
 
 // ../protocol/dist/types.js
@@ -1229,7 +1256,7 @@ var WsTransport = class {
       return;
     this.teardownSocket();
     const gen = ++this.generation;
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       const ws = new WebSocket(this.url);
       this.ws = ws;
       let settled = false;
@@ -1250,7 +1277,7 @@ var WsTransport = class {
           reject(err);
         } else {
           this._connected = true;
-          resolve3();
+          resolve4();
         }
       };
       const timer = setTimeout(() => finish(new Error(`WebSocket connect timeout (${timeoutMs}ms) to ${this.url}`)), timeoutMs);
@@ -1340,6 +1367,8 @@ var CollabClient = class _CollabClient {
   statusHandlers = [];
   waiters = [];
   joined = false;
+  hasJoined = false;
+  reconnecting;
   disposed = false;
   capabilities;
   reconnect;
@@ -1361,9 +1390,11 @@ var CollabClient = class _CollabClient {
     this.transport.onClose(() => {
       this.joined = false;
       this.setConnStatus("disconnected", "ws_closed");
-      if (this.reconnect && !this.disposed) {
+      if (this.reconnect && !this.disposed && !this.reconnecting) {
         this.setConnStatus("connecting", "reconnect");
-        void this.reconnectLoop();
+        this.reconnecting = this.reconnectLoop().finally(() => {
+          this.reconnecting = void 0;
+        });
       }
     });
   }
@@ -1441,7 +1472,15 @@ var CollabClient = class _CollabClient {
     await this.transport.connect();
   }
   async join(timeoutMs = 1e4) {
+    if (this.disposed)
+      throw new Error("disposed");
+    if (this.joined)
+      return;
+    const catchUp = this.hasJoined || !!this.cursor;
+    const since = this.cursor?.get() ?? this.seq;
     await this.connect();
+    if (this.disposed)
+      throw new Error("disposed");
     const challengeP = this.waitFor((f) => f.type === "ctrl" && (f.method === "challenge" || f.method === "error"), timeoutMs);
     this.transport.send({
       v: 1,
@@ -1481,14 +1520,16 @@ var CollabClient = class _CollabClient {
       throw new Error("expected joined");
     }
     this.joined = true;
+    this.hasJoined = true;
     this.peers = joined.peers;
     this.seq = joined.seq;
     this.setConnStatus("connected");
     for (const h of this.peerHandlers)
       h(this.peers);
-    const since = this.cursor?.get() ?? 0;
-    if (since > 0 && since < this.seq) {
-      await this.poll(since);
+    if (catchUp && since < joined.seq) {
+      const missed = await this.pollFrames(since);
+      for (const frame of missed.frames)
+        await this.handleFwd(frame);
     }
     this.startPing();
   }
@@ -1583,6 +1624,18 @@ var CollabClient = class _CollabClient {
   }
   async poll(sinceSeq) {
     const since = sinceSeq ?? this.cursor?.get() ?? 0;
+    const res = await this.pollFrames(since);
+    const out = [];
+    for (const fwd of res.frames) {
+      const p = await this.decryptFwd(fwd);
+      if (p)
+        out.push(p);
+    }
+    this.seq = Math.max(this.seq, res.seq);
+    this.cursor?.set(this.seq);
+    return out;
+  }
+  async pollFrames(since) {
     const resP = this.waitFor((f) => f.type === "ctrl" && f.method === "poll_result", 5e3);
     this.transport.send({
       v: 1,
@@ -1594,16 +1647,8 @@ var CollabClient = class _CollabClient {
     });
     const res = await resP;
     if (res.type !== "ctrl" || res.method !== "poll_result")
-      return [];
-    const out = [];
-    for (const fwd of res.frames) {
-      const p = await this.decryptFwd(fwd);
-      if (p)
-        out.push(p);
-    }
-    this.seq = Math.max(this.seq, res.seq);
-    this.cursor?.set(this.seq);
-    return out;
+      throw new Error("expected poll_result");
+    return res;
   }
   async history(sinceSeq = 0) {
     return this.poll(sinceSeq);
@@ -1651,20 +1696,23 @@ var CollabClient = class _CollabClient {
   }
   async decryptFwd(frame) {
     try {
+      if (frame.roomId !== this.roomId)
+        return null;
       const aad = new TextEncoder().encode(`${frame.roomId}:${frame.from}`);
       const plain = await decrypt(this.roomKey, frame.nonce, frame.ciphertext, aad);
-      return decodePayload(plain);
+      const payload = decodePayload(plain);
+      return payload.sender === frame.from ? payload : null;
     } catch {
       return null;
     }
   }
   waitFor(pred, timeoutMs) {
-    const p = new Promise((resolve3, reject) => {
+    const p = new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         this.waiters = this.waiters.filter((w) => w.timer !== timer);
         reject(new Error("timeout waiting for frame"));
       }, timeoutMs);
-      this.waiters.push({ pred, resolve: resolve3, reject, timer });
+      this.waiters.push({ pred, resolve: resolve4, reject, timer });
     });
     p.catch(() => {
     });
@@ -1818,6 +1866,7 @@ var RunScheduler = class {
   runs = [];
   reqs = /* @__PURE__ */ new Map();
   aborts = /* @__PURE__ */ new Map();
+  gates = /* @__PURE__ */ new Map();
   idleWaiters = [];
   enqueue(req) {
     const run = {
@@ -1835,7 +1884,10 @@ var RunScheduler = class {
     this.reqs.set(run.id, req);
     this.changed();
     if (req.gate) {
-      req.gate().then(
+      const gate = req.gate;
+      const ac = new AbortController();
+      this.gates.set(run.id, ac);
+      Promise.resolve().then(() => ac.signal.aborted ? false : gate(ac.signal)).then(
         (ok2) => {
           if (run.state !== "approval") return;
           if (ok2) run.state = "queued";
@@ -1844,8 +1896,12 @@ var RunScheduler = class {
         },
         (e) => {
           if (run.state === "approval") this.finish(run, "failed", e.message);
+          this.pump();
         }
-      );
+      ).finally(() => {
+        this.gates.delete(run.id);
+        this.pump();
+      });
     } else this.pump();
     return run;
   }
@@ -1853,11 +1909,14 @@ var RunScheduler = class {
   list(roomId, finished = 8) {
     const mine = this.runs.filter((r) => !roomId || r.roomId === roomId);
     const active = mine.filter((r) => r.state === "approval" || r.state === "queued" || r.state === "running");
-    const done = mine.filter((r) => !active.includes(r)).slice(-finished);
+    const done = finished > 0 ? mine.filter((r) => !active.includes(r)).slice(-finished) : [];
     return [...active, ...done].map((r) => ({ ...r }));
   }
   running(roomId) {
-    return this.runs.filter((r) => r.roomId === roomId && r.state === "running").length;
+    return this.runs.filter((r) => r.roomId === roomId && this.aborts.has(r.id)).length;
+  }
+  isExecuting(roomId, agentId) {
+    return this.runs.some((r) => r.roomId === roomId && r.agentId === agentId && this.aborts.has(r.id));
   }
   /** Stop every queued/running run in a room (optionally one agent). Returns how many were stopped. */
   stop(roomId, agentId) {
@@ -1865,6 +1924,7 @@ var RunScheduler = class {
     for (const r of this.runs) {
       if (r.roomId !== roomId || agentId && r.agentId !== agentId) continue;
       if (r.state === "approval" || r.state === "queued") {
+        this.gates.get(r.id)?.abort();
         this.finish(r, "stopped", "stopped by user");
         n++;
       } else if (r.state === "running") {
@@ -1878,18 +1938,18 @@ var RunScheduler = class {
   }
   /** Resolves when no run is approval/queued/running (tests, e2e). */
   whenIdle() {
-    if (!this.runs.some((r) => r.state === "approval" || r.state === "queued" || r.state === "running")) return Promise.resolve();
+    if (!this.busy()) return Promise.resolve();
     return new Promise((r) => this.idleWaiters.push(r));
   }
   pump() {
     for (const run of this.runs) {
       if (run.state !== "queued") continue;
       if (this.running(run.roomId) >= Math.max(1, this.limitFor(run.roomId))) continue;
-      if (this.runs.some((r) => r.state === "running" && r.roomId === run.roomId && r.agentId === run.agentId)) continue;
+      if (this.isExecuting(run.roomId, run.agentId)) continue;
       this.start(run);
     }
     this.changed();
-    if (!this.runs.some((r) => r.state === "approval" || r.state === "queued" || r.state === "running")) {
+    if (!this.busy()) {
       const w = this.idleWaiters;
       this.idleWaiters = [];
       for (const fn of w) fn();
@@ -1901,7 +1961,9 @@ var RunScheduler = class {
     run.state = "running";
     run.startedAt = Date.now();
     const req = this.reqs.get(run.id);
-    Promise.resolve().then(() => this.exec(run, req, ac.signal)).then(
+    Promise.resolve().then(() => {
+      if (!ac.signal.aborted) return this.exec(run, req, ac.signal);
+    }).then(
       () => run.state === "running" && this.finish(run, "done"),
       (e) => run.state === "running" && this.finish(run, ac.signal.aborted ? "stopped" : "failed", e?.message ?? String(e))
     ).finally(() => {
@@ -1914,9 +1976,17 @@ var RunScheduler = class {
     run.endedAt = Date.now();
     if (error) run.error = error;
     this.reqs.delete(run.id);
-    if (this.runs.length > 400) this.runs = this.runs.filter((r) => r.state === "approval" || r.state === "queued" || r.state === "running" || Date.now() - (r.endedAt ?? 0) < 36e5).slice(-300);
+    if (this.runs.length > 400) {
+      const active = this.runs.filter((r) => r.state === "approval" || r.state === "queued" || this.aborts.has(r.id) || this.gates.has(r.id));
+      const finished = this.runs.filter((r) => !active.includes(r)).slice(-300);
+      const keep = /* @__PURE__ */ new Set([...active, ...finished]);
+      this.runs = this.runs.filter((r) => keep.has(r));
+    }
     this.changed();
   }
+  busy() {
+    return this.aborts.size > 0 || this.gates.size > 0 || this.runs.some((r) => r.state === "approval" || r.state === "queued");
+  }
   changed() {
     try {
       this.onChange();
@@ -1936,19 +2006,23 @@ import { WebSocketServer } from "ws";
 import { WebSocket as WebSocket2 } from "ws";
 var RING = 1e3;
 var RATE = 40;
+var MAX_CIPHERTEXT = 256 * 1024;
 var LanRoom = class {
   roomId;
   socks = /* @__PURE__ */ new Set();
   seq = 0;
   ring = [];
   roomRate = [];
+  identities = /* @__PURE__ */ new Map();
   constructor(roomId) {
     this.roomId = roomId;
   }
   attach(ws) {
-    const s = { ws, joined: false, stamps: [] };
+    const s = { ws, joined: false, stamps: [], processing: Promise.resolve() };
     this.socks.add(s);
-    ws.on("message", (data) => void this.onMessage(s, data.toString()));
+    ws.on("message", (data) => {
+      s.processing = s.processing.then(() => this.onMessage(s, data.toString())).catch(() => this.error(s, "bad_frame", "invalid frame"));
+    });
     ws.on("close", () => this.onClose(s));
     ws.on("error", () => this.onClose(s));
   }
@@ -1965,6 +2039,9 @@ var LanRoom = class {
         this.send(s.ws, frame);
     }
   }
+  error(s, code, message) {
+    this.send(s.ws, { v: 1, type: "ctrl", method: "error", code, message, roomId: this.roomId });
+  }
   rateOk(stamps, now, limit) {
     const recent = stamps.filter((t) => now - t < 1e3);
     if (recent.length >= limit)
@@ -1973,22 +2050,26 @@ var LanRoom = class {
     return { ok: true, next: recent };
   }
   async onMessage(s, text2) {
-    const now = Date.now();
-    const rr = this.rateOk(this.roomRate, now, 200);
-    this.roomRate = rr.next;
-    if (!rr.ok)
-      return;
-    const sr = this.rateOk(s.stamps, now, RATE);
-    s.stamps = sr.next;
-    if (!sr.ok)
-      return;
     for (const line of text2.split("\n")) {
+      if (!this.socks.has(s))
+        return;
       if (!line.trim())
         continue;
+      const now = Date.now();
+      const rr = this.rateOk(this.roomRate, now, 200);
+      this.roomRate = rr.next;
+      const sr = this.rateOk(s.stamps, now, RATE);
+      s.stamps = sr.next;
+      if (!rr.ok || !sr.ok)
+        return this.error(s, "rate_limit", "too many frames");
       let frame;
       try {
-        frame = JSON.parse(line);
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+          throw new Error("not an object");
+        frame = parsed;
       } catch {
+        this.error(s, "bad_json", "frame must be a JSON object");
         continue;
       }
       if (frame.v !== 1)
@@ -2009,11 +2090,19 @@ var LanRoom = class {
       }
       if (frame.type === "ctrl" && frame.method === "poll") {
         const since = frame.sinceSeq ?? 0;
+        if (!Number.isSafeInteger(since) || since < 0) {
+          this.error(s, "bad_poll", "invalid sinceSeq");
+          continue;
+        }
         const frames = this.ring.filter((f) => f.seq > since);
         this.send(s.ws, { v: 1, type: "ctrl", method: "poll_result", roomId: this.roomId, frames, seq: this.seq });
         continue;
       }
       if (frame.type === "fwd") {
+        if (frame.roomId !== this.roomId || frame.from !== s.agentId || typeof frame.ciphertext !== "string" || !frame.ciphertext || frame.ciphertext.length > MAX_CIPHERTEXT || typeof frame.nonce !== "string" || !/^[A-Za-z0-9_-]{16}$/.test(frame.nonce)) {
+          this.error(s, "bad_frame", "invalid encrypted frame");
+          continue;
+        }
         this.seq += 1;
         const fwd = { ...frame, seq: this.seq, roomId: this.roomId, from: s.agentId };
         this.ring.push(fwd);
@@ -2028,23 +2117,44 @@ var LanRoom = class {
       this.send(s.ws, { v: 1, type: "ctrl", method: "error", code: "bad_room", message: "room mismatch", roomId: this.roomId });
       return;
     }
-    if (!s.challenge || !frame.challengeResp) {
-      s.challenge = b64uEncode(randomBytes(32));
-      s.publicKey = frame.publicKey;
-      this.send(s.ws, { v: 1, type: "ctrl", method: "challenge", roomId: this.roomId, challenge: s.challenge });
-      s.agentId = frame.agentId;
-      s.capabilities = frame.capabilities;
+    if (typeof frame.agentId !== "string" || !frame.agentId || frame.agentId.length > 128 || typeof frame.publicKey !== "string" || !frame.publicKey || frame.publicKey.length > 256 || typeof frame.challengeResp !== "string" || frame.challengeResp.length > 256 || frame.capabilities !== void 0 && (!Array.isArray(frame.capabilities) || frame.capabilities.length > 32 || frame.capabilities.some((c) => typeof c !== "string" || c.length > 128))) {
+      return this.error(s, "bad_join", "invalid identity or capabilities");
+    }
+    const knownKey = this.identities.get(frame.agentId);
+    if (knownKey && knownKey !== frame.publicKey)
+      return this.error(s, "identity_conflict", "agentId belongs to another public key in this room");
+    if (s.joined) {
+      if (frame.agentId !== s.agentId || frame.publicKey !== s.publicKey)
+        return this.error(s, "identity_locked", "joined socket identity cannot change");
+      this.send(s.ws, { v: 1, type: "ctrl", method: "joined", roomId: this.roomId, agentId: s.agentId, peers: this.members(), seq: this.seq });
       return;
     }
-    const ok2 = await verifyChallenge(frame.publicKey, s.challenge, frame.challengeResp);
+    if (!s.pending || !frame.challengeResp || s.pending.agentId !== frame.agentId || s.pending.publicKey !== frame.publicKey) {
+      s.pending = { challenge: b64uEncode(randomBytes(32)), agentId: frame.agentId, publicKey: frame.publicKey };
+      this.send(s.ws, { v: 1, type: "ctrl", method: "challenge", roomId: this.roomId, challenge: s.pending.challenge });
+      return;
+    }
+    const pending = s.pending;
+    s.pending = void 0;
+    const ok2 = await verifyChallenge(frame.publicKey, pending.challenge, frame.challengeResp).catch(() => false);
+    if (!this.socks.has(s))
+      return;
     if (!ok2) {
       this.send(s.ws, { v: 1, type: "ctrl", method: "error", code: "bad_sig", message: "challenge failed", roomId: this.roomId });
       return;
     }
+    const verifiedKey = this.identities.get(frame.agentId);
+    if (verifiedKey && verifiedKey !== frame.publicKey)
+      return this.error(s, "identity_conflict", "agentId belongs to another public key in this room");
+    this.identities.set(frame.agentId, frame.publicKey);
     s.agentId = frame.agentId;
     s.publicKey = frame.publicKey;
     s.capabilities = frame.capabilities;
     s.joined = true;
+    for (const old of [...this.socks]) {
+      if (old !== s && old.joined && old.agentId === s.agentId)
+        this.onClose(old);
+    }
     const peers = this.members();
     this.send(s.ws, { v: 1, type: "ctrl", method: "joined", roomId: this.roomId, agentId: s.agentId, peers, seq: this.seq });
     this.broadcast({ v: 1, type: "ctrl", method: "peer_update", roomId: this.roomId, peers, event: "joined", agentId: s.agentId }, s.ws);
@@ -2158,10 +2268,10 @@ function browseLanRelays(opts) {
     }
   });
   dns.query({ questions: [{ name: MDNS_SERVICE, type: "PTR" }] });
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     setTimeout(() => {
       dns.destroy();
-      resolve3([...found.values()]);
+      resolve4([...found.values()]);
     }, timeoutMs);
   });
 }
@@ -2472,19 +2582,33 @@ var LanRelayServer = class {
       res.writeHead(200, { "content-type": "text/plain" });
       res.end("Collab LAN / VPS Relay\nWS: /ws/:roomId\nDirectory: GET|POST /directory/rooms, DELETE /directory/rooms/:roomId\nHealth: /health\nmDNS: _collab._tcp.local\n");
     });
-    this.wss = new WebSocketServer({ noServer: true });
+    this.wss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
     this.http.on("upgrade", (req, socket, head) => {
-      const m = /^\/ws\/([^/?#]+)/.exec(req.url ?? "");
+      const m = /^\/ws\/([^/?#]+)\/?(?:\?[^#]*)?$/.exec(req.url ?? "");
       if (!m) {
         socket.destroy();
         return;
       }
-      const roomId = decodeURIComponent(m[1]);
+      let roomId;
+      try {
+        roomId = decodeURIComponent(m[1]);
+        if (!/^[A-Za-z0-9_-]{1,128}$/.test(roomId))
+          throw new Error("invalid roomId");
+      } catch {
+        socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+        return;
+      }
       this.wss.handleUpgrade(req, socket, head, (ws) => {
         this.room(roomId).attach(ws);
       });
     });
-    await new Promise((resolve3) => this.http.listen(port, host, resolve3));
+    await new Promise((resolve4, reject) => {
+      this.http.once("error", reject);
+      this.http.listen(port, host, () => {
+        this.http.off("error", reject);
+        resolve4();
+      });
+    });
     const addr = this.http.address();
     this.port = typeof addr === "object" && addr ? addr.port : port;
     if (this.opts.mdns !== false) {
@@ -2494,8 +2618,12 @@ var LanRelayServer = class {
   }
   async close() {
     this.stopMdns?.();
-    await new Promise((resolve3) => this.wss?.close(() => resolve3()));
-    await new Promise((resolve3) => this.http?.close(() => resolve3()));
+    for (const ws of this.wss?.clients ?? [])
+      ws.terminate();
+    if (this.wss)
+      await new Promise((resolve4) => this.wss.close(() => resolve4()));
+    if (this.http)
+      await new Promise((resolve4) => this.http.close(() => resolve4()));
   }
 };
 
@@ -2521,8 +2649,9 @@ var ApprovalQueue = class {
   }
   /** Ask for approval; resolves with allow|deny. Auto-denies after timeoutMs. */
   request(opts) {
+    if (opts.signal?.aborted) return Promise.resolve("deny");
     const requestId = randomUUID();
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const entry = {
         requestId,
         roomId: opts.roomId,
@@ -2532,22 +2661,22 @@ var ApprovalQueue = class {
         from: opts.from,
         createdAt: Date.now(),
         resolve: (d) => {
+          if (!this.pending.has(requestId)) return;
           clearTimeout(timer);
+          opts.signal?.removeEventListener("abort", abort);
           this.pending.delete(requestId);
           this.emit();
-          resolve3(d);
+          resolve4(d);
         }
       };
-      this.pending.set(requestId, entry);
-      this.emit();
+      const abort = () => entry.resolve("deny");
       const timer = setTimeout(() => {
-        if (this.pending.has(requestId)) {
-          this.pending.delete(requestId);
-          this.emit();
-          resolve3("deny");
-        }
+        entry.resolve("deny");
       }, opts.timeoutMs ?? 12e4);
       timer.unref?.();
+      this.pending.set(requestId, entry);
+      opts.signal?.addEventListener("abort", abort, { once: true });
+      this.emit();
     });
   }
   decide(requestId, decision) {
@@ -2564,7 +2693,8 @@ init_member_config();
 
 // src/state.ts
 import { chmod, mkdir as mkdir4, readFile as readFile4, rename, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname3, resolve as resolve3 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 function newId(prefix) {
   return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -2608,12 +2738,25 @@ async function loadState(path) {
     return null;
   }
 }
+var pendingWrites = /* @__PURE__ */ new Map();
 async function saveState(path, state) {
+  path = resolve3(path);
+  const snapshot = structuredClone(state);
+  const pending = (pendingWrites.get(path) ?? Promise.resolve()).catch(() => {
+  }).then(() => writeState(path, snapshot));
+  pendingWrites.set(path, pending);
+  try {
+    await pending;
+  } finally {
+    if (pendingWrites.get(path) === pending) pendingWrites.delete(path);
+  }
+}
+async function writeState(path, state) {
   const dir = dirname3(path);
   await mkdir4(dir, { recursive: true, mode: 448 });
   await chmod(dir, 448).catch(() => {
   });
-  const tmp = `${path}.${process.pid}.tmp`;
+  const tmp = `${path}.${process.pid}.${randomUUID2()}.tmp`;
   const body = {
     version: 3,
     activeWorkspaceId: state.activeWorkspaceId,
@@ -2622,9 +2765,13 @@ async function saveState(path, state) {
     rooms: state.rooms,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile3(tmp, JSON.stringify(body, null, 2), { mode: 384 });
-  await chmod(tmp, 384);
-  await rename(tmp, path);
+  try {
+    await writeFile3(tmp, JSON.stringify(body, null, 2), { mode: 384, flag: "wx" });
+    await chmod(tmp, 384);
+    await rename(tmp, path);
+  } finally {
+    await rm2(tmp, { force: true });
+  }
 }
 
 // src/commands.ts
@@ -2768,19 +2915,35 @@ ${HELP}` };
 }
 
 // src/plugin.ts
+import { createRequire } from "node:module";
+var requirePkg = createRequire(import.meta.url);
+var PLUGIN_VERSION = (() => {
+  try {
+    return requirePkg("../package.json").version;
+  } catch {
+    return "0.3.4";
+  }
+})();
 var SUMMARY_MAX = 120;
 var MESSAGES_MAX = 300;
 var AGENT_SERVICES = ["agents", "agentDefaultModel", "agentPresets", "permissionPresets", "sessionTitle", "workspaceRegistry"];
 var text = (s) => [{ type: "text", text: s }];
 var jsonRender = (_args, value) => text(JSON.stringify(value));
-function withTimeout(p, ms, label) {
+function withTimeout(p, ms, label, signal) {
   let t;
+  let onAbort;
   const timeout = new Promise((_, rej) => {
     t = setTimeout(() => rej(new Error(`${label} timed out after ${ms}ms`)), ms);
     t.unref?.();
   });
-  return Promise.race([p, timeout]).finally(() => {
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal?.reason ?? new Error("stopped by user"));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
+  return Promise.race([p, timeout, aborted]).finally(() => {
     if (t) clearTimeout(t);
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
   });
 }
 async function loadIdentity(path, agentName) {
@@ -2850,6 +3013,7 @@ var RoomConn = class {
   locks;
   git;
   historyTimer;
+  historySave;
   announceTimer;
   normalized;
   /** Normalized once; the same object afterwards so `conn.local.x = …` always sticks. */
@@ -2911,6 +3075,36 @@ var CollabBridge = class {
   sessionAgents = /* @__PURE__ */ new Map();
   /** Override how a local agent run executes (tests / mock provider). */
   localRunner = null;
+  models = [];
+  async refreshModels() {
+    const llm = this.ctx.get("llm", false);
+    if (!llm?.listProviders || !llm?.listModels) return;
+    const results = await Promise.allSettled(llm.listProviders().map(async (p) => {
+      const entries = await withTimeout(llm.listModels(p.id), 5e3, `models ${p.id}`);
+      return entries.map((m) => ({ provider: p.id, model: m.id, name: m.name || m.id }));
+    }));
+    this.models = results.flatMap((r) => r.status === "fulfilled" ? r.value : []);
+    this.emit({ type: "rooms" });
+  }
+  selectedModel(conn, agent) {
+    const defaults = this.ctx.get("agentDefaultModel", false)?.currentSelection?.() ?? {};
+    return resolveSelection(defaults, conn?.meta.memberConfig, agent);
+  }
+  resolvedModel(conn, agent) {
+    return describeModel(this.selectedModel(conn, agent), this.models);
+  }
+  async resetAgentSession(conn, agent) {
+    const key = `${conn.meta.roomId}:${agent.agentId}`;
+    const pending = this.agentHandles.get(key);
+    this.agentHandles.delete(key);
+    const sid = conn.meta.agentSessions?.[agent.agentId];
+    if (sid) this.sessionAgents.delete(sid);
+    if (conn.meta.agentSessions) delete conn.meta.agentSessions[agent.agentId];
+    conn.meta.agentNoEffort = conn.meta.agentNoEffort?.filter((id) => id !== agent.agentId);
+    this.noEffort.delete(key);
+    if (pending) await pending.then((h) => h.dispose()).catch(() => {
+    });
+  }
   log(level, ...a) {
     this.ctx.logger[level]("[collab]", ...a);
     const dbg = process.env.DSH_ROOM_DEBUG_LOG;
@@ -2941,6 +3135,7 @@ var CollabBridge = class {
   start() {
     this.ready ??= (async () => {
       await this.self();
+      await this.refreshModels();
       const st = await loadState(this.config.statePath);
       for (const w of st?.workspaces ?? []) this.workspaces.set(w.id, w);
       if (!this.workspaces.size) {
@@ -2949,14 +3144,26 @@ var CollabBridge = class {
       }
       this.activeWorkspaceId = st?.activeWorkspaceId ?? [...this.workspaces.keys()][0] ?? null;
       const metas = st?.rooms ?? [];
-      if (this.config.invite && !metas.some((m) => this.config.invite.includes(`/join/${encodeURIComponent(m.roomId)}#`) || this.config.invite.includes(`/join/${m.roomId}#`))) {
+      if (this.config.invite && !metas.some((m) => m.roomId === CollabClient.parseInvite(this.config.invite).roomId)) {
         const { roomId } = CollabClient.parseInvite(this.config.invite);
         const wsId = this.activeWorkspaceId;
         metas.push({ roomId, invite: this.config.invite, name: roomId, description: "", tags: [], public: false, owner: false, joinedAt: Date.now(), workspaceId: wsId });
       }
       this.activeRoomId = st?.activeRoomId ?? metas[0]?.roomId ?? null;
-      await Promise.all(metas.map((m) => this.open(m).catch((e) => this.log("error", `rejoin ${m.roomId} failed: ${e.message}`))));
+      for (const meta of metas) {
+        const conn = new RoomConn(meta);
+        conn.onAdd = () => this.scheduleHistorySave(conn);
+        this.rooms.set(meta.roomId, conn);
+      }
       await this.persist();
+      this.emit({ type: "rooms" });
+      void Promise.all(
+        metas.map(
+          (m) => withTimeout(this.open(m), 2e4, `rejoin ${m.roomId}`).catch(
+            (e) => this.log("error", `rejoin ${m.roomId} failed: ${e.message}`)
+          )
+        )
+      ).then(() => this.emit({ type: "rooms" }));
     })();
     return this.ready;
   }
@@ -2966,11 +3173,13 @@ var CollabBridge = class {
   // ── room lifecycle ───────────────────────────────────────────────────────
   async open(meta) {
     const existing = this.rooms.get(meta.roomId);
-    if (existing) return existing;
-    const conn = new RoomConn(meta);
-    conn.onAdd = () => this.scheduleHistorySave(conn);
-    this.rooms.set(meta.roomId, conn);
-    this.emit({ type: "rooms" });
+    if (existing?.client?.isJoined()) return existing;
+    const conn = existing ?? new RoomConn(meta);
+    if (!existing) {
+      conn.onAdd = () => this.scheduleHistorySave(conn);
+      this.rooms.set(meta.roomId, conn);
+      this.emit({ type: "rooms" });
+    }
     try {
       await this.connect(conn);
     } catch (e) {
@@ -2988,7 +3197,7 @@ var CollabBridge = class {
     const roomId = parsed.roomId;
     const roomKeyB64 = parsed.roomKeyB64;
     conn.meta.transport = parsed.mode;
-    const wsUrl = inviteWsUrl(parsed);
+    const wsUrl = this.inviteUrl(parsed);
     if (!conn.meta.memberConfig) {
       conn.meta.memberConfig = defaultMemberConfig(this.config.workspacePath);
     }
@@ -3055,18 +3264,25 @@ var CollabBridge = class {
       conn.presenceTimer.unref?.();
     }
     this.log("info", `joined room ${roomId} as ${identity.agentId} via ${loopback ? "in-process loopback" : wsUrl} (${loopback ? "local" : parsed.mode})`);
-    if (loopback || conn.local.agents.length) await this.loadLocalHistory(conn);
+    if (loopback || conn.local.agents.length) {
+      await withTimeout(this.loadLocalHistory(conn), 3e3, `local-history ${roomId}`).catch(
+        (e) => this.log("warn", `local history ${roomId}: ${e.message}`)
+      );
+    }
     try {
-      for (const p of await client.history(0)) {
+      const hist = await withTimeout(client.history(0), 5e3, `history ${roomId}`);
+      for (const p of hist) {
         const m = toMessage(p, identity.agentId);
         if (m) conn.add(m);
       }
     } catch (e) {
       this.log("warn", `history for ${roomId} failed: ${e.message}`);
     }
-    await this.connectAgents(conn).catch((e) => this.log("warn", `local agents for ${roomId} failed: ${e.message}`));
+    await withTimeout(this.connectAgents(conn), loopback ? 8e3 : 2e4, `connectAgents ${roomId}`).catch(
+      (e) => this.log("warn", `local agents for ${roomId} failed: ${e.message}`)
+    );
     try {
-      await this.announceMemberConfig(conn);
+      await withTimeout(this.announceMemberConfig(conn), 5e3, `announce ${roomId}`);
     } catch (e) {
       this.log("warn", `announce member.config failed: ${e.message}`);
     }
@@ -3204,7 +3420,13 @@ var CollabBridge = class {
       }
     };
     meta.local = normalizeLocalSettings(meta.local);
-    const conn = await withTimeout(this.open(meta), 25e3, "create room join");
+    this.log("info", `createRoom begin name=${meta.name} localOnly=${!!opts.localOnly} agents=${(opts.agents ?? []).length}`);
+    const conn = new RoomConn(meta);
+    conn.onAdd = () => this.scheduleHistorySave(conn);
+    this.rooms.set(meta.roomId, conn);
+    conn.status = "connecting";
+    this.activeRoomId = meta.roomId;
+    this.emit({ type: "rooms" });
     for (const entry of opts.agents ?? []) {
       if (typeof entry === "string") {
         if (AGENT_PRESETS.some((p) => p.key === entry)) await this.addLocalAgent(meta.roomId, { preset: entry }, { connect: false });
@@ -3212,24 +3434,35 @@ var CollabBridge = class {
         await this.addLocalAgent(meta.roomId, entry, { connect: false });
       }
     }
-    this.activeRoomId = meta.roomId;
     if (bindTo) this.bind(conn, bindTo);
     await this.persist();
-    if (conn.local.agents.length) {
-      if (conn.local.loopback) {
-        await withTimeout(this.connectAgents(conn), 6e3, "local agents join").catch(
-          (e) => this.log("warn", `local agents for ${meta.roomId}: ${e.message}`)
+    this.log("info", `createRoom persisted ${meta.roomId} with ${conn.local.agents.length} agent(s); connecting in background`);
+    void this.finishCreateConnect(conn, meta.public).catch(
+      (e) => this.log("error", `createRoom background connect ${meta.roomId}: ${e.message}`)
+    );
+    return { ...this.view(conn), invite: meta.invite, listed: false };
+  }
+  /** Background: host join + local agent joins + optional directory publish. Never awaited by HTTP create. */
+  async finishCreateConnect(conn, isPublic) {
+    try {
+      await withTimeout(this.connect(conn), conn.local.loopback ? 8e3 : 2e4, `connect ${conn.meta.roomId}`);
+      if (conn.local.agents.length) {
+        await withTimeout(this.connectAgents(conn), conn.local.loopback ? 8e3 : 25e3, `agents ${conn.meta.roomId}`).catch(
+          (e) => this.log("warn", `local agents for ${conn.meta.roomId}: ${e.message}`)
         );
-      } else {
-        void this.connectAgents(conn).catch((e) => this.log("warn", `background local agents for ${meta.roomId}: ${e.message}`));
       }
+      if (isPublic && conn.meta.owner) {
+        this.startHeartbeat(conn);
+        await this.publish(conn).catch((e) => this.log("warn", `directory publish failed: ${e.message}`));
+      }
+      this.log("info", `createRoom connected ${conn.meta.roomId} status=${conn.status}`);
+    } catch (e) {
+      conn.status = "offline";
+      conn.error = e.message;
+      this.emit({ type: "rooms" });
+      throw e;
     }
-    let listing;
-    if (meta.public) listing = await this.publish(conn).catch((e) => {
-      this.log("warn", `directory publish failed: ${e.message}`);
-      return void 0;
-    });
-    return { ...this.view(conn), invite: meta.invite, listed: !!listing };
+    this.emit({ type: "rooms" });
   }
   /** Join by invite. `info` carries directory metadata when joining from search results. */
   async joinInvite(invite, info = {}, bindTo) {
@@ -3314,6 +3547,7 @@ var CollabBridge = class {
       this.emit({ type: "message", roomId: conn.meta.roomId, message: m });
       this.routeLocal(conn, full);
     }
+    if (conn.local.loopback || conn.local.agents.length) await this.saveLocalHistory(conn);
     return { roomId: conn.meta.roomId, ...r };
   }
   send(roomId, textIn, mentions, replyTo) {
@@ -3382,7 +3616,7 @@ var CollabBridge = class {
       error: conn.error,
       members: (() => {
         const localAgents = conn.local.agents;
-        for (const a of localAgents) if (conn.agents.get(a.agentId)?.isJoined()) live.add(a.agentId);
+        for (const a of localAgents) live.add(a.agentId);
         const ids = [...live];
         const cfgs = this.peerConfigs.get(conn.meta.roomId);
         return ids.map((agentId) => {
@@ -3405,7 +3639,7 @@ var CollabBridge = class {
       bound: !!sessionId,
       sessionId,
       transport: conn.local.loopback ? "local" : conn.meta.transport ?? (conn.meta.invite.startsWith("collab://lan/") ? "lan" : "relay"),
-      memberConfig: conn.meta.memberConfig ? { ...publicMemberConfig(conn.meta.memberConfig), workspacePath: conn.meta.memberConfig.workspacePath, peerGrants: conn.meta.memberConfig.peerGrants, permissions: conn.meta.memberConfig.permissions } : null,
+      memberConfig: conn.meta.memberConfig ? { ...publicMemberConfig(conn.meta.memberConfig), workspacePath: conn.meta.memberConfig.workspacePath, resolvedModel: this.resolvedModel(conn), peerGrants: conn.meta.memberConfig.peerGrants, permissions: conn.meta.memberConfig.permissions } : null,
       peerConfigs: Object.fromEntries(this.peerConfigs.get(conn.meta.roomId) ?? []),
       local: this.localView(conn),
       runs: this.scheduler.list(conn.meta.roomId)
@@ -3413,6 +3647,9 @@ var CollabBridge = class {
   }
   state() {
     return {
+      version: PLUGIN_VERSION,
+      models: this.models,
+      defaultModel: this.resolvedModel(),
       self: this.identity?.agentId ?? null,
       relayUrl: this.config.relayUrl,
       lanRelayPort: this.lanRelay?.port ?? null,
@@ -3443,7 +3680,20 @@ var CollabBridge = class {
       workspacePath: patch.workspacePath ?? cur.workspacePath,
       workspaceLabel: patch.workspaceLabel ?? cur.workspaceLabel
     };
+    const modelChanged = ["provider", "model", "reasoningEffort"].some((k) => cur[k] !== next[k]);
+    if (modelChanged && conn.local.agents.some((a) => this.scheduler.isExecuting(roomId, a.agentId))) throw new Error("Stop running agents before changing the room model");
+    const before = conn.local.agents.map((a) => this.selectedModel(conn, a));
     conn.meta.memberConfig = next;
+    if (modelChanged) {
+      const host = this.sessions.get(roomId);
+      this.sessions.delete(roomId);
+      delete conn.meta.sessionId;
+      if (host) await host.then((h) => h.dispose()).catch(() => {
+      });
+      for (const [i, a] of conn.local.agents.entries()) {
+        if (JSON.stringify(before[i]) !== JSON.stringify(this.selectedModel(conn, a))) await this.resetAgentSession(conn, a);
+      }
+    }
     this.mcpByRoom.get(roomId)?.updateConfig(next);
     await this.persist();
     if (conn.client) await this.announceMemberConfig(conn);
@@ -3621,7 +3871,7 @@ var CollabBridge = class {
     const summary = `collab ${kind} from ${from} in ${conn.meta.name}`.slice(0, SUMMARY_MAX);
     return Object.freeze({
       role: "user",
-      id: randomUUID2(),
+      id: randomUUID3(),
       content: Object.freeze([Object.freeze({ type: "text", text: body })]),
       source: Object.freeze({ kind: "collab", roomId: conn.meta.roomId, from, messageId, form: "notice", summary })
     });
@@ -3685,13 +3935,13 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
         const wsPath = roomPath && roomPath.trim() ? roomPath : cfg.workspacePath;
         await mkdir5(wsPath, { recursive: true });
         const workspace = await svc.workspaceRegistry.create(wsPath, wsPath === cfg.workspacePath ? "collab" : void 0);
-        const selected = svc.agentDefaultModel.currentSelection();
-        const sessionId = `collab-${roomId}-${randomUUID2().slice(0, 8)}`;
+        const selected = this.selectedModel(conn);
+        const sessionId = `collab-${roomId}-${randomUUID3().slice(0, 8)}`;
         const handle = await svc.agents.create({
           sessionId,
           signal: this.abort.signal,
           meta: { cwd: workspace.path, agentPreset: preset.id },
-          agentOptions: { provider: selected.provider, model: selected.model },
+          agentOptions: { provider: selected.provider, model: selected.model, ...selected.reasoningEffort ? { reasoningEffort: selected.reasoningEffort } : {} },
           setup: async (agentCtx) => {
             await svc.agentPresets.mount(agentCtx, preset.id);
           }
@@ -3712,6 +3962,9 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     return pending;
   }
   // ── local multi-agent: members hosted by this dsh ────────────────────────
+  inviteUrl(parsed) {
+    return inviteWsUrl(parsed.uri.startsWith("collab://join/") ? { ...parsed, wsBase: this.config.relayUrl } : parsed);
+  }
   transportFor(conn, wsUrl) {
     return conn.local.loopback ? new MockTransport(this.hub, `loopback:${conn.meta.roomId}`) : new WsTransport(wsUrl);
   }
@@ -3738,7 +3991,7 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
       identity,
       roomId: parsed.roomId,
       roomKey: parsed.roomKeyB64,
-      transport: this.transportFor(conn, inviteWsUrl(parsed)),
+      transport: this.transportFor(conn, this.inviteUrl(parsed)),
       autoReply: "off",
       reconnect: !conn.local.loopback,
       capabilities: ["collab.v1", "dsh", "member.config", "local-agent"]
@@ -3837,13 +4090,11 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     const clean = sanitizeAgentInput(input);
     const sessionKeys = ["model", "provider", "reasoningEffort", "scope"];
     const resetSession = sessionKeys.some((k) => k in clean && clean[k] !== a[k]);
+    if (resetSession && this.scheduler.isExecuting(roomId, a.agentId)) throw new Error("Stop this agent before changing its model or scope");
     if (clean.moderator) for (const x of conn.local.agents) x.moderator = false;
     Object.assign(a, clean, { id: a.id, agentId: a.agentId });
     if (resetSession) {
-      this.agentHandles.delete(`${conn.meta.roomId}:${a.agentId}`);
-      if (conn.meta.agentSessions) delete conn.meta.agentSessions[a.agentId];
-      conn.meta.agentNoEffort = conn.meta.agentNoEffort?.filter((x) => x !== a.agentId);
-      this.noEffort.delete(`${conn.meta.roomId}:${a.agentId}`);
+      await this.resetAgentSession(conn, a);
     }
     await this.persist();
     await this.announceAgentConfig(conn, a).catch(() => {
@@ -3901,6 +4152,7 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     await conn.client?.dispose().catch(() => {
     });
     conn.client = null;
+    conn.lastSeenPeers.clear();
     conn.local.loopback = wantLoopback;
     conn.status = "connecting";
     this.emit({ type: "rooms" });
@@ -3914,19 +4166,31 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     return join3(dirname4(this.config.statePath), "local-history", `${roomId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
   }
   scheduleHistorySave(conn) {
-    if (!conn.local.loopback || conn.historyTimer) return;
+    if (!conn.local.loopback && !conn.local.agents.length || conn.historyTimer) return;
     conn.historyTimer = setTimeout(() => {
       conn.historyTimer = void 0;
-      void this.saveLocalHistory(conn);
+      void this.saveLocalHistory(conn).catch((e) => this.log("error", `save history ${conn.meta.roomId}: ${e.message}`));
     }, 500);
     conn.historyTimer.unref?.();
   }
-  async saveLocalHistory(conn) {
+  saveLocalHistory(conn) {
+    clearTimeout(conn.historyTimer);
+    conn.historyTimer = void 0;
     const f = this.historyPath(conn.meta.roomId);
-    await mkdir5(dirname4(f), { recursive: true, mode: 448 }).catch(() => {
-    });
-    await writeFile4(f, JSON.stringify(conn.messages.slice(-MESSAGES_MAX)), { mode: 384 }).catch(() => {
+    const body = JSON.stringify(conn.messages.slice(-MESSAGES_MAX));
+    const save = (conn.historySave ?? Promise.resolve()).catch(() => {
+    }).then(async () => {
+      await mkdir5(dirname4(f), { recursive: true, mode: 448 });
+      const tmp = `${f}.${randomUUID3()}.tmp`;
+      try {
+        await writeFile4(tmp, body, { mode: 384, flag: "wx" });
+        await rename2(tmp, f);
+      } finally {
+        await rm3(tmp, { force: true });
+      }
     });
+    conn.historySave = save;
+    return save;
   }
   async loadLocalHistory(conn) {
     try {
@@ -4001,7 +4265,7 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
       tasks: opts.tasks
     };
     if (a.approvalRequired) {
-      req.gate = async () => await this.approvals.request({ roomId: conn.meta.roomId, action: "shell.exec", summary: `Run local agent ${a.name} (${a.agentId})`, detail: summary, from: a.agentId, timeoutMs: 10 * 6e4 }) === "allow";
+      req.gate = async (signal) => await this.approvals.request({ roomId: conn.meta.roomId, action: "shell.exec", summary: `Run local agent ${a.name} (${a.agentId})`, detail: summary, from: a.agentId, timeoutMs: 10 * 6e4, signal }) === "allow";
     }
     this.scheduler.enqueue(req);
   }
@@ -4030,13 +4294,14 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     conn.runThread.set(a.agentId, run.threadId);
     try {
       const cwd = await this.agentCwd(conn, a);
+      signal.throwIfAborted();
       const prompt = this.buildLocalPrompt(conn, a, mode, req.trigger, run.threadId, cwd, req.tasks);
       const ctx = { bridge: this, roomId: conn.meta.roomId, agent: a, prompt, mode, trigger: req.trigger, threadId: run.threadId, cwd, signal };
       const wtBefore = conn.worktrees.get(a.agentId);
       const before = wtBefore ? await mainStatus(wtBefore.repo).catch(() => null) : null;
       try {
         if (this.localRunner) await this.localRunner(ctx);
-        else if (this.config.localAgentRunner === "mock" || !this.agentServices()) await mockLocalRunner(ctx);
+        else if (this.config.localAgentRunner === "mock") await mockLocalRunner(ctx);
         else await this.runInSession(conn, a, ctx);
       } finally {
         if (wtBefore && before) {
@@ -4080,49 +4345,59 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
     return root;
   }
   async runInSession(conn, a, ctx, retried = false) {
+    ctx.signal.throwIfAborted();
     const handle = await this.agentSessionFor(conn, a, ctx.cwd);
+    ctx.signal.throwIfAborted();
     const agent = handle.agent;
-    if (agent.whenIdle) await Promise.race([agent.whenIdle(), new Promise((r) => setTimeout(r, 3e4))]);
-    const seq0 = agent.session?.seq;
-    agent.followup(this.notice(conn, ctx.prompt, ctx.trigger?.sender ?? "room", ctx.trigger?.messageId ?? randomUUID2(), `${ctx.mode} \u2192 ${a.name}`));
-    if (!agent.whenIdle) return;
-    const aborted = new Promise((resolve3) => ctx.signal.addEventListener("abort", () => resolve3(), { once: true }));
-    const timeout = new Promise((resolve3) => {
-      const t = setTimeout(resolve3, 20 * 6e4);
-      t.unref?.();
-    });
-    const settled = (async () => {
-      for (let i = 0; i < 40; i++) {
-        await agent.whenIdle();
-        if (seq0 === void 0 || agent.session?.seq !== seq0) return;
-        await new Promise((r) => setTimeout(r, 250));
-      }
-    })();
-    await Promise.race([settled, aborted, timeout]);
-    this.log("info", `run ${a.agentId}: seq ${seq0} -> ${agent.session?.seq}`);
-    if (process.env.DSH_ROOM_DEBUG_LOG && seq0 !== void 0) {
-      const sess = agent.session;
-      for (let i = seq0; i < (sess.seq ?? seq0); i++) this.log("info", `  ev ${i}: ${JSON.stringify(sess.eventAt?.(i)).slice(0, 700)}`);
-    }
-    if (!ctx.signal.aborted && seq0 !== void 0 && agent.session?.seq === seq0) throw new Error("agent session did not start a turn");
-    const failure = !ctx.signal.aborted && seq0 !== void 0 ? this.turnError(agent.session, seq0) : void 0;
-    if (failure) {
-      const key = `${conn.meta.roomId}:${a.agentId}`;
-      if (!retried && failure.code === "UNSUPPORTED_REASONING_EFFORT" && a.reasoningEffort) {
-        this.log("warn", `${a.agentId}: ${failure.message}; recreating its session with the model's default effort`);
-        this.noEffort.add(key);
-        conn.meta.agentNoEffort = [.../* @__PURE__ */ new Set([...conn.meta.agentNoEffort ?? [], a.agentId])];
-        this.agentHandles.delete(key);
-        if (conn.meta.agentSessions) delete conn.meta.agentSessions[a.agentId];
-        return this.runInSession(conn, a, ctx, true);
-      }
-      throw new Error(failure.message);
-    }
-    if (ctx.signal.aborted) {
+    const cancel = () => {
       try {
         agent.cancel?.({ kind: "user" });
       } catch {
       }
+    };
+    ctx.signal.addEventListener("abort", cancel, { once: true });
+    try {
+      if (agent.whenIdle) await withTimeout(agent.whenIdle(), 3e4, `session idle ${a.agentId}`, ctx.signal);
+      ctx.signal.throwIfAborted();
+      const seq0 = agent.session?.seq;
+      agent.followup(this.notice(conn, ctx.prompt, ctx.trigger?.sender ?? "room", ctx.trigger?.messageId ?? randomUUID3(), `${ctx.mode} \u2192 ${a.name}`));
+      if (!agent.whenIdle) return;
+      const settled = (async () => {
+        for (let i = 0; i < 40; i++) {
+          ctx.signal.throwIfAborted();
+          await agent.whenIdle();
+          ctx.signal.throwIfAborted();
+          if (seq0 === void 0 || agent.session?.seq !== seq0) return;
+          await sleep2(250, ctx.signal);
+        }
+      })();
+      await withTimeout(settled, 20 * 6e4, `agent turn ${a.agentId}`, ctx.signal);
+      this.log("info", `run ${a.agentId}: seq ${seq0} -> ${agent.session?.seq}`);
+      if (process.env.DSH_ROOM_DEBUG_LOG && seq0 !== void 0) {
+        const sess = agent.session;
+        for (let i = seq0; i < (sess.seq ?? seq0); i++) this.log("info", `  ev ${i}: ${JSON.stringify(sess.eventAt?.(i)).slice(0, 700)}`);
+      }
+      if (!ctx.signal.aborted && seq0 !== void 0 && agent.session?.seq === seq0) throw new Error("agent session did not start a turn");
+      const failure = !ctx.signal.aborted && seq0 !== void 0 ? this.turnError(agent.session, seq0) : void 0;
+      if (failure) {
+        const key = `${conn.meta.roomId}:${a.agentId}`;
+        if (!retried && failure.code === "UNSUPPORTED_REASONING_EFFORT" && this.selectedModel(conn, a).reasoningEffort) {
+          this.log("warn", `${a.agentId}: ${failure.message}; recreating its session with the model's default effort`);
+          this.noEffort.add(key);
+          conn.meta.agentNoEffort = [.../* @__PURE__ */ new Set([...conn.meta.agentNoEffort ?? [], a.agentId])];
+          this.agentHandles.delete(key);
+          if (conn.meta.agentSessions) delete conn.meta.agentSessions[a.agentId];
+          return this.runInSession(conn, a, ctx, true);
+        }
+        throw new Error(failure.message);
+      }
+    } catch (e) {
+      cancel();
+      if (agent.whenIdle) await withTimeout(agent.whenIdle(), 3e4, `agent stop ${a.agentId}`).catch(() => {
+      });
+      throw e;
+    } finally {
+      ctx.signal.removeEventListener("abort", cancel);
     }
   }
   /** Last turn/end error since `from`, if the agent's turn failed (provider/model errors). */
@@ -4160,15 +4435,15 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
       try {
         const root = conn.meta.memberConfig?.workspacePath?.trim() || this.config.workspacePath;
         const workspace = await svc.workspaceRegistry.create(root, root === this.config.workspacePath ? "collab" : void 0);
-        const selected = svc.agentDefaultModel.currentSelection();
-        const base = { provider: a.provider ?? selected.provider, model: a.model ?? selected.model };
-        const withEffort = a.reasoningEffort && !this.noEffort.has(key) && !conn.meta.agentNoEffort?.includes(a.agentId);
+        const effective = this.selectedModel(conn, a);
+        const base = { provider: effective.provider, model: effective.model };
+        const withEffort = effective.reasoningEffort && !this.noEffort.has(key) && !conn.meta.agentNoEffort?.includes(a.agentId);
         const resume = svc.agents.resume;
         if (prevSid && resume) {
           try {
             const h = await resume.call(svc.agents, {
               resumeSessionId: prevSid,
-              agentOptions: withEffort ? { ...base, reasoningEffort: a.reasoningEffort } : base,
+              agentOptions: withEffort ? { ...base, reasoningEffort: effective.reasoningEffort } : base,
               setup: async (agentCtx) => {
                 await svc.agentPresets.mount(agentCtx, preset.id);
               }
@@ -4186,7 +4461,7 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
             this.log("warn", `resume ${prevSid} for ${a.agentId} failed (${e.message}); creating a new session`);
           }
         }
-        const sessionId = `room-${conn.meta.roomId.slice(-8)}-${a.id}-${randomUUID2().slice(0, 6)}`;
+        const sessionId = `room-${conn.meta.roomId.slice(-8)}-${a.id}-${randomUUID3().slice(0, 6)}`;
         const create = (agentOptions, cwdPath) => svc.agents.create({
           sessionId,
           signal: this.abort.signal,
@@ -4198,7 +4473,7 @@ Do what is asked using your tools. Answer in the room by calling collab_send wit
         });
         let handle;
         try {
-          handle = await create(withEffort ? { ...base, reasoningEffort: a.reasoningEffort } : base, root);
+          handle = await create(withEffort ? { ...base, reasoningEffort: effective.reasoningEffort } : base, root);
         } catch (e) {
           this.log("warn", `session for ${a.agentId} with reasoning effort failed (${e.message}); retrying with defaults`);
           handle = await create(base, root);
@@ -4317,6 +4592,7 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
       this.emit({ type: "message", roomId: conn.meta.roomId, message: m });
       this.routeLocal(conn, full);
     }
+    if (conn.local.loopback || conn.local.agents.length) await this.saveLocalHistory(conn);
     return { roomId: conn.meta.roomId, ...r };
   }
   // ── merge view: per-agent worktree diffs ─────────────────────────────────
@@ -4353,7 +4629,7 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
     if (!approved) throw new Error("merge needs explicit approval");
     const conn = this.room(roomId);
     const a = this.localAgent(conn, agentId);
-    if (this.scheduler.list(conn.meta.roomId).some((r2) => r2.agentId === a.agentId && r2.state === "running")) throw new Error(`${a.name} is still running \u2014 stop it or wait`);
+    if (this.scheduler.isExecuting(conn.meta.roomId, a.agentId)) throw new Error(`${a.name} is still running \u2014 wait for it to finish stopping`);
     const wt = conn.worktrees.get(a.agentId) ?? await this.findWorktree(conn, a);
     if (!wt) throw new Error(`${a.name} has no worktree yet`);
     const r = await mergeWorktree(wt, a.agentId);
@@ -4367,7 +4643,7 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
     if (!approved) throw new Error("discard needs explicit approval");
     const conn = this.room(roomId);
     const a = this.localAgent(conn, agentId);
-    if (this.scheduler.list(conn.meta.roomId).some((r) => r.agentId === a.agentId && r.state === "running")) throw new Error(`${a.name} is still running \u2014 stop it or wait`);
+    if (this.scheduler.isExecuting(conn.meta.roomId, a.agentId)) throw new Error(`${a.name} is still running \u2014 wait for it to finish stopping`);
     const wt = conn.worktrees.get(a.agentId) ?? await this.findWorktree(conn, a);
     if (!wt) return { ok: true, discarded: false };
     await discardWorktree(wt);
@@ -4401,6 +4677,7 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
         const wt = conn.worktrees.get(a.agentId);
         return {
           ...a,
+          resolvedModel: this.resolvedModel(conn, a),
           sessionId: conn.meta.agentSessions?.[a.agentId],
           online: online.has(a.agentId) || !!conn.agents.get(a.agentId)?.isJoined(),
           state: r?.state ?? "idle",
@@ -4426,8 +4703,10 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
     for (const conn of this.rooms.values()) {
       if (conn.heartbeat) clearInterval(conn.heartbeat);
       if (conn.presenceTimer) clearInterval(conn.presenceTimer);
+      clearTimeout(conn.announceTimer);
+      clearTimeout(conn.historyTimer);
       this.scheduler.stop(conn.meta.roomId);
-      if (conn.local.loopback) await this.saveLocalHistory(conn);
+      if (conn.local.loopback || conn.local.agents.length) await this.saveLocalHistory(conn);
       await this.disconnectAgents(conn);
       await conn.client?.dispose().catch(() => {
       });
@@ -4454,7 +4733,7 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
         }
         const who = bridge.callerAgent(exec);
         bridge.log("info", `tool ${name2} by ${who?.agent.agentId ?? "host"}`);
-        return await run(a, who) ?? { ok: true };
+        return JSON.parse(JSON.stringify(await run(a, who) ?? { ok: true }));
       }
     });
     const str2 = (v) => typeof v === "string" && v ? v : void 0;
@@ -4516,8 +4795,8 @@ Do what is asked, then answer with collab_send replyTo "${p.messageId}".`;
     ];
   }
 };
-var sleep2 = (ms, signal) => new Promise((resolve3, reject) => {
-  const t = setTimeout(resolve3, ms);
+var sleep2 = (ms, signal) => new Promise((resolve4, reject) => {
+  const t = setTimeout(resolve4, ms);
   signal?.addEventListener("abort", () => {
     clearTimeout(t);
     reject(new Error("stopped"));
@@ -4565,7 +4844,7 @@ Written by ${a.agentId} (${a.name}) at ${(/* @__PURE__ */ new Date()).toISOStrin
 
 // src/config.ts
 import { homedir } from "node:os";
-import { join as join4, isAbsolute as isAbsolute2 } from "node:path";
+import { join as join4, isAbsolute as isAbsolute3 } from "node:path";
 var AUTO = /* @__PURE__ */ new Set(["off", "mention", "mention-or-task"]);
 function expand(p) {
   return p.startsWith("~/") ? join4(homedir(), p.slice(2)) : p;
@@ -4578,7 +4857,7 @@ function normalizeConfig(raw) {
   const relayUrl = str2("relayUrl") ?? DEFAULT_RELAY_URL;
   if (!/^wss?:\/\//.test(relayUrl)) throw new Error(`dsh-room: relayUrl must be ws:// or wss://, got ${relayUrl}`);
   const workspacePath = expand(str2("workspacePath") ?? "~/.collab/workspace");
-  if (!isAbsolute2(workspacePath)) throw new Error("dsh-room: workspacePath must be absolute");
+  if (!isAbsolute3(workspacePath)) throw new Error("dsh-room: workspacePath must be absolute");
   return {
     relayUrl,
     invite: str2("invite"),
@@ -4794,6 +5073,27 @@ async function readJson2(req) {
 }
 var str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
 var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : typeof v === "string" ? v.split(/[\s,]+/).filter(Boolean) : void 0;
+function peerGrants(value) {
+  const object = (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v)) throw new HttpError(400, "peerGrants must contain objects");
+    return v;
+  };
+  const grants = (v) => {
+    const input2 = object(v), out = {};
+    for (const cap of ["read", "write", "exec", "delete"]) {
+      if (!(cap in input2)) continue;
+      const grant = input2[cap];
+      if (grant !== "auto" && grant !== "ask" && grant !== "deny") throw new HttpError(400, `invalid peer grant for ${cap}`);
+      out[cap] = grant;
+    }
+    return out;
+  };
+  const input = object(value);
+  return {
+    default: "default" in input ? grants(input.default) : {},
+    byAgent: "byAgent" in input ? Object.fromEntries(Object.entries(object(input.byAgent)).map(([id, v]) => [id, grants(v)])) : {}
+  };
+}
 function createApiHandler(bridge, connection) {
   return async (req, res) => {
     const conn = connection();
@@ -4810,6 +5110,7 @@ function createApiHandler(bridge, connection) {
       await bridge.start();
       if (method === "GET" && path === "/stream") return stream(bridge, req, res);
       if (method === "GET" && path === "/state") return sendJson2(res, 200, bridge.state());
+      if (method === "GET" && path === "/version") return sendJson2(res, 200, { name: "@cecwxf/dsh-room", version: bridge.state().version ?? "unknown" });
       if (method === "GET" && path === "/directory") return sendJson2(res, 200, { rooms: await bridge.search(str(url.searchParams.get("q")), str(url.searchParams.get("tag"))) });
       if (method === "POST" && path === "/rooms") {
         const b = await readJson2(req);
@@ -4916,6 +5217,7 @@ function createApiHandler(bridge, connection) {
             if (k in b) patch[k] = b[k];
           }
           if (b.permissions && typeof b.permissions === "object") patch.permissions = b.permissions;
+          if ("peerGrants" in b) patch.peerGrants = peerGrants(b.peerGrants);
           return sendJson2(res, 200, await bridge.updateMemberConfig(roomId, patch));
         }
         if (method === "GET" && action === "mcp") return sendJson2(res, 200, { tools: (await Promise.resolve().then(() => (init_mcp_workspace(), mcp_workspace_exports))).MCP_TOOL_DEFS });
@@ -4931,7 +5233,7 @@ function createApiHandler(bridge, connection) {
       }
       throw new HttpError(404, `no route ${method} ${API}${path}`);
     } catch (e) {
-      const status = e instanceof HttpError ? e.status : /not in room|not in a collab room|no local agent/.test(e.message) ? 404 : /needs explicit approval/.test(e.message) ? 403 : 500;
+      const status = e instanceof HttpError ? e.status : /not in room|not in a collab room|no local agent/.test(e.message) ? 404 : /needs explicit approval|peer grant deny|^denied:/.test(e.message) ? 403 : 500;
       if (!res.headersSent) sendJson2(res, status, { error: e.message });
     }
   };
@@ -4982,6 +5284,9 @@ function apply(ctx, config) {
   ctx.inject?.(["webServer"], (c) => {
     c.effect(() => registerRoutes(bridge, c.webServer, () => c.get("connection")), "dsh-room: /api/collab routes");
   });
+  ctx.inject?.(["llm", "agentDefaultModel"], () => {
+    void bridge.refreshModels().catch((e) => bridge.log("warn", `model catalog: ${e.message}`));
+  });
   bridge.start().catch((e) => bridge.log("error", `start failed: ${e.message}`));
   bridge.log("info", `loaded (relay ${bridge.config.relayUrl}, autoReply ${bridge.config.autoReply}, ${unregister.length} tools)`);
 }
@@ -4989,6 +5294,7 @@ export {
   AGENT_PRESETS,
   CollabBridge,
   Config,
+  PLUGIN_VERSION,
   apply,
   inject,
   mockLocalRunner,