viberoom 0.2.0

package/dist/room.js

@@ -0,0 +1,2124 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { affectedByEdit, editNotice, partitionHistory, rewriteNotice } from "./edit.js";
+import { join, resolve } from "node:path";
+import { AcpAgent } from "./acp-client.js";
+import { RemoteError } from "./jsonrpc.js";
+import { getRecipe, listRecipes } from "./recipes.js";
+import { composeSkillBlock, SKILL_MARKER_PATTERN, SKILL_TOOL_NAME } from "./persona.js";
+import { BUILTIN_AUTHOR, parseSkillInvocation, renderSkillBody, SKILL_NAME_PATTERN, } from "./skills.js";
+import { BRIEF_AFFECTING_SETTINGS, DEFAULT_ROOM_SETTINGS, REQUEST_BRIEF_MARKER, SILENT_MARKER, buildBrief, buildHeader, composeCorrectionPrompt, composePrompt, countSentences, ensureDir, } from "./persona.js";
+import { Transcript } from "./log.js";
+const SKILL_TOOL_READY_MS = 5000;
+const COLORS = ["#6d5dfc", "#16a34a", "#d97706", "#dc2626", "#0891b2", "#be185d", "#4d7c0f", "#7c3aed"];
+const NAME_PATTERN = /^[\p{L}\p{N}][\p{L}\p{N}_-]{0,23}$/u;
+const MENTION_PATTERN = /@([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
+const RULE_REF_TOKEN = /@\{p:([^}]+)\}/g;
+const ADAPTER_ERROR_PATTERN = /^(?:Warning: Falling back from WebSockets|unexpected status \d{3}|Error when talking to|API Error|You have exhausted your (?:daily )?quota|Rate limit|429 |5\d\d )/i;
+export class Room extends EventEmitter {
+    id;
+    name;
+    dir;
+    dataDir;
+    createdAt;
+    settings;
+    hops = 0;
+    focused = false;
+    participants = new Map();
+    messages = [];
+    seq = 0;
+    programHumanDescription;
+    bypassPermissionsByDefault;
+    skills;
+    earlySkillReady = new Set();
+    speaking = null;
+    floorQueue = [];
+    humanTypingUntil = 0;
+    typingTimer = null;
+    closing = false;
+    runtimes = new Map();
+    drafts = new Map();
+    permissions = new Map();
+    optionCache;
+    log;
+    colorIndex = 0;
+    departed = new Map();
+    restoredSeen = new Map();
+    constructor(options) {
+        super();
+        this.id = options.id;
+        this.name = options.name;
+        this.dir = options.dir;
+        this.dataDir = options.dataDir;
+        this.createdAt = options.createdAt;
+        this.programHumanDescription = options.programHumanDescription;
+        this.bypassPermissionsByDefault = options.bypassPermissionsByDefault;
+        this.skills = options.skills;
+        this.settings = { ...DEFAULT_ROOM_SETTINGS, ...(options.settings ?? {}), name: options.name, humanName: options.humanName };
+        this.log = options.log;
+        this.optionCache = options.optionCache ?? new Map();
+        mkdirSync(this.dataDir, { recursive: true });
+        this.participants.set("human", {
+            id: "human",
+            name: options.humanName,
+            kind: "human",
+            status: "idle",
+            turns: 0,
+            color: "#111827",
+        });
+        this.loadHistory();
+    }
+    historyPath() {
+        return join(this.dataDir, "history.jsonl");
+    }
+    loadHistory() {
+        if (!existsSync(this.historyPath()))
+            return;
+        const lines = readFileSync(this.historyPath(), "utf8").split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            try {
+                const message = JSON.parse(line);
+                this.messages.push(message);
+                if (message.seq > this.seq)
+                    this.seq = message.seq;
+            }
+            catch {
+            }
+        }
+    }
+    restore(stored) {
+        for (const s of stored) {
+            const recipe = getRecipe(s.agentType);
+            this.participants.set(s.id, {
+                id: s.id,
+                name: s.name,
+                kind: "agent",
+                agentType: s.agentType,
+                agentLabel: recipe?.label ?? s.agentType,
+                agentVendor: recipe?.vendor ?? s.agentType,
+                status: "offline",
+                statusDetail: "not connected since the hub restarted",
+                turns: 0,
+                color: s.color,
+                tagline: s.tagline,
+                role: s.role,
+                avatar: s.avatar || undefined,
+                muted: s.muted,
+                replyDelay: s.replyDelay,
+                skills: normalizeSkillList(s.skills),
+                launch: s.launch,
+                sessionId: s.sessionId,
+                supportsLoad: s.supportsLoad,
+                sawFromSeq: s.sawFromSeq,
+                violations: 0,
+                briefsSent: 0,
+                failedTurns: 0,
+            });
+            if (s.lastSeenSeq !== undefined)
+                this.restoredSeen.set(s.id, s.lastSeenSeq);
+            this.colorIndex++;
+        }
+    }
+    toStored() {
+        const { name: _n, humanName: _h, ...settings } = this.settings;
+        return {
+            id: this.id,
+            name: this.name,
+            dir: this.dir,
+            createdAt: this.createdAt,
+            settings,
+            participants: [...this.participants.values()]
+                .filter((p) => p.kind === "agent" && p.agentType)
+                .map((p) => ({
+                id: p.id,
+                name: p.name,
+                agentType: p.agentType,
+                tagline: p.tagline ?? "",
+                role: p.role ?? "",
+                avatar: p.avatar ?? "",
+                color: p.color,
+                launch: p.launch ?? { model: p.model ?? null, effort: p.effort ?? null, mode: p.mode ?? null },
+                muted: !!p.muted,
+                replyDelay: p.replyDelay,
+                skills: p.skills && p.skills.length ? [...p.skills] : undefined,
+                sessionId: p.sessionId,
+                supportsLoad: p.supportsLoad,
+                lastSeenSeq: this.runtimes.get(p.id)?.lastSeenSeq ?? this.restoredSeen.get(p.id),
+                sawFromSeq: p.sawFromSeq,
+            })),
+        };
+    }
+    commit(message) {
+        this.messages.push(message);
+        appendFileSync(this.historyPath(), JSON.stringify(message) + "\n");
+        this.push({ type: "message", message });
+    }
+    get humanName() {
+        return this.settings.humanName;
+    }
+    get hopLimit() {
+        return this.settings.hopLimit;
+    }
+    snapshot() {
+        const last = this.messages.length ? this.messages[this.messages.length - 1] : null;
+        return {
+            id: this.id,
+            name: this.name,
+            dir: this.dir,
+            createdAt: this.createdAt,
+            humanName: this.humanName,
+            hopLimit: this.hopLimit,
+            hops: this.hops,
+            focused: this.focused,
+            settings: this.settings,
+            customRulesText: this.renderRuleReferences(this.settings.customRules),
+            participants: [...this.participants.values()],
+            messages: [...this.messages, ...this.drafts.values()],
+            permissions: [...this.permissions.values()].map(({ resolve: _r, ...p }) => p),
+            recipes: listRecipes().map(({ build: _b, ...r }) => r),
+            lastMessageAt: last?.ts ?? this.createdAt,
+        };
+    }
+    applyProgramSettings(program) {
+        const changed = [];
+        this.bypassPermissionsByDefault = program.bypassPermissionsByDefault;
+        if (program.humanName !== this.settings.humanName) {
+            this.settings = { ...this.settings, humanName: program.humanName };
+            const human = this.participants.get("human");
+            human.name = program.humanName;
+            this.push({ type: "participant", participant: human });
+            changed.push("human name");
+        }
+        if (program.humanDescription !== this.programHumanDescription) {
+            this.programHumanDescription = program.humanDescription;
+            if (this.settings.humanDescriptionMode !== "override")
+                changed.push("human description");
+        }
+        if (changed.length) {
+            for (const runtime of this.runtimes.values())
+                runtime.briefPending = `room rules: ${changed.join(", ")}`;
+            this.push(this.roomEvent());
+        }
+    }
+    effectiveSettings() {
+        const own = this.settings.humanDescription.trim();
+        const program = this.programHumanDescription.trim();
+        let humanDescription = own;
+        if (this.settings.humanDescriptionMode === "inherit")
+            humanDescription = program;
+        else if (this.settings.humanDescriptionMode === "append")
+            humanDescription = [program, own].filter(Boolean).join(" ");
+        else if (this.settings.humanDescriptionMode === "none")
+            humanDescription = "";
+        return { ...this.settings, humanDescription, customRules: this.renderRuleReferences(this.settings.customRules) };
+    }
+    resolveRuleReferences(text) {
+        const unknown = [];
+        const stored = text.replace(MENTION_PATTERN, (whole, name) => {
+            const p = this.findByName(name);
+            if (p)
+                return `@{p:${p.id}}`;
+            if (!unknown.includes(name))
+                unknown.push(name);
+            return whole;
+        });
+        return { stored, unknown };
+    }
+    renderRuleReferences(stored) {
+        return stored.replace(RULE_REF_TOKEN, (_whole, id) => {
+            const p = this.participants.get(id);
+            if (p)
+                return `@${p.name}`;
+            const gone = this.departed.get(id);
+            return gone ? `@${gone} (no longer in the room)` : "@(a participant who left)";
+        });
+    }
+    postHumanMessage(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            throw new Error("empty message");
+        this.humanTypingUntil = 0;
+        const human = this.participants.get("human");
+        const message = {
+            id: randomUUID(),
+            seq: ++this.seq,
+            from: human.id,
+            fromName: human.name,
+            to: [],
+            toNames: [],
+            text: trimmed,
+            ts: Date.now(),
+            kind: "chat",
+        };
+        this.decorateHumanMessage(message);
+        human.turns += 1;
+        if (this.focused) {
+            this.focused = false;
+            this.push(this.roomEvent());
+        }
+        this.commit(message);
+        this.route(message);
+        return message;
+    }
+    decorateHumanMessage(message) {
+        const mentions = this.parseMentions(message.text);
+        message.to = mentions.ids;
+        message.toNames = mentions.names;
+        delete message.skill;
+        const invocation = parseSkillInvocation(message.text);
+        if (invocation) {
+            const skill = this.skills?.library.get(invocation.name);
+            if (!skill)
+                this.notice(`No skill named "${invocation.name}" in the library; sent as plain text.`, "warn");
+            else if (!skill.userInvocable)
+                this.notice(`Skill "${skill.name}" is not user-invocable; sent as plain text.`, "warn");
+            else if (skill.problems.length)
+                this.notice(`Skill "${skill.name}" has problems (${skill.problems.join("; ")}); sent as plain text.`, "warn");
+            else
+                message.skill = { name: skill.name, args: invocation.args };
+        }
+    }
+    agentReadStates() {
+        const out = [];
+        for (const p of this.participants.values()) {
+            if (p.kind !== "agent" || p.status === "left")
+                continue;
+            const runtime = this.runtimes.get(p.id);
+            if (runtime)
+                out.push({ id: p.id, name: p.name, lastSeenSeq: runtime.lastSeenSeq, active: runtime.turnActive, online: true });
+            else
+                out.push({ id: p.id, name: p.name, lastSeenSeq: this.restoredSeen.get(p.id) ?? -1, active: false, online: false });
+        }
+        return out;
+    }
+    editableMessage(messageId) {
+        const message = this.messages.find((m) => m.id === messageId);
+        if (!message || message.kind !== "chat" || message.from !== "human")
+            throw new Error("only your own chat messages can be edited");
+        return message;
+    }
+    previewEdit(messageId) {
+        const message = this.editableMessage(messageId);
+        const { removed } = partitionHistory(this.messages, message.seq);
+        const { restart, untouched, offline } = affectedByEdit(this.agentReadStates(), message.seq);
+        return {
+            seq: message.seq,
+            laterMessages: removed.filter((m) => m.kind === "chat").length,
+            laterRecords: removed.length,
+            restart: restart.map((a) => a.name),
+            untouched: untouched.map((a) => a.name),
+            offline: offline.map((a) => a.name),
+        };
+    }
+    async editMessage(messageId, text, mode) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            throw new Error("empty message");
+        const message = this.editableMessage(messageId);
+        if (trimmed === message.text)
+            throw new Error("the text is unchanged");
+        const { restart, offline } = affectedByEdit(this.agentReadStates(), message.seq);
+        const previous = message.text;
+        message.edited = { ts: Date.now(), previous };
+        message.text = trimmed;
+        this.decorateHumanMessage(message);
+        this.humanTypingUntil = 0;
+        if (this.focused) {
+            this.focused = false;
+            this.push(this.roomEvent());
+        }
+        if (mode === "notify") {
+            this.rewriteHistory();
+            this.push({ type: "message", message });
+            if (restart.length || offline.length)
+                this.postSystem(editNotice(this.humanName, previous, trimmed), "agents");
+            this.log.info(`edit (notify) of #${message.seq}: ${restart.length} agents had the old version`);
+            this.route(message);
+            return { restarted: [], removed: 0 };
+        }
+        const { kept, removed } = partitionHistory(this.messages, message.seq);
+        for (const a of restart) {
+            const runtime = this.runtimes.get(a.id);
+            if (!runtime)
+                continue;
+            this.dropScheduledTurn(a.id);
+            this.cancelPermissionsOf(a.id);
+        }
+        this.messages.splice(0, this.messages.length, ...kept);
+        this.appendDeleted(removed, message.seq);
+        this.rewriteHistory();
+        this.push({ type: "messages.truncated", fromSeq: message.seq });
+        this.push({ type: "message", message });
+        if (this.speaking && restart.some((a) => a.id === this.speaking))
+            this.speaking = null;
+        const restarted = [];
+        for (const a of restart) {
+            await this.retireRuntime(a.id);
+            try {
+                await this.reconnect(a.id, { mode: "replay", reason: "the conversation was rewritten" });
+                restarted.push(a.name);
+            }
+            catch (error) {
+                this.notice(`${a.name} could not be restarted after the rewrite: ${describeError(error)}`, "error");
+            }
+        }
+        for (const a of offline) {
+            const p = this.participants.get(a.id);
+            if (!p)
+                continue;
+            p.sessionId = undefined;
+            p.statusDetail = "the conversation was rewritten while it was offline; reconnect replays the new history";
+            this.restoredSeen.set(a.id, Math.max(0, message.seq - 1));
+            this.push({ type: "participant", participant: p });
+        }
+        this.postSystem(rewriteNotice(this.humanName, removed.filter((m) => m.kind === "chat").length, restarted));
+        this.log.info(`edit (rewrite) of #${message.seq}: ${removed.length} records removed; restarted ${restarted.join(", ") || "nobody"}`);
+        this.startNext();
+        this.route(message);
+        return { restarted, removed: removed.length };
+    }
+    async retireRuntime(id) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (!runtime || !participant)
+            return;
+        runtime.retiring = true;
+        if (runtime.turnActive)
+            runtime.agent.cancel(runtime.sessionId);
+        try {
+            await Promise.race([runtime.agent.closeSession(runtime.sessionId), delay(1500)]);
+        }
+        catch {
+        }
+        runtime.agent.kill();
+        this.forgetRuntime(id);
+        participant.status = "offline";
+        participant.statusDetail = undefined;
+    }
+    rewriteHistory() {
+        const path = this.historyPath();
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, this.messages.map((m) => JSON.stringify(m)).join("\n") + (this.messages.length ? "\n" : ""));
+        renameSync(tmp, path);
+    }
+    appendDeleted(records, editedSeq) {
+        if (!records.length)
+            return;
+        const lines = [JSON.stringify({ deletedAt: Date.now(), reason: "rewrite", editedSeq }), ...records.map((m) => JSON.stringify(m))];
+        appendFileSync(join(this.dataDir, "history.deleted.jsonl"), lines.join("\n") + "\n");
+    }
+    focus() {
+        let stopped = 0;
+        for (const [id, runtime] of this.runtimes) {
+            this.dropScheduledTurn(id);
+            if (runtime.turnActive) {
+                runtime.agent.cancel(runtime.sessionId);
+                this.cancelPermissionsOf(id);
+                stopped++;
+            }
+        }
+        this.focused = true;
+        this.push(this.roomEvent());
+        this.postSystem(`Hush: ${stopped ? `${stopped} repl${stopped > 1 ? "ies" : "y"} stopped; ` : ""}everyone waits until ${this.humanName} writes again.`);
+    }
+    rename(name) {
+        const trimmed = name.trim();
+        if (!trimmed || trimmed.length > 60)
+            throw new Error("room name must be 1-60 characters");
+        if (trimmed === this.name)
+            return;
+        this.name = trimmed;
+        this.settings = { ...this.settings, name: trimmed };
+        for (const runtime of this.runtimes.values())
+            runtime.briefPending = "room rules: name";
+        this.push(this.roomEvent());
+    }
+    updateSettings(patch) {
+        const next = { ...this.settings };
+        const changed = [];
+        const setNumber = (key, min, max) => {
+            if (patch[key] === undefined)
+                return;
+            const value = Number(patch[key]);
+            if (!Number.isInteger(value) || value < min || value > max)
+                throw new Error(`${key} must be an integer between ${min} and ${max}`);
+            if (value !== next[key]) {
+                next[key] = value;
+                changed.push(key);
+            }
+        };
+        setNumber("hopLimit", 0, 10_000);
+        setNumber("fullBriefEveryTurns", 1, 10_000);
+        setNumber("fullBriefEveryTokens", 1000, 10_000_000);
+        setNumber("replayAfterRestart", 0, 200);
+        setNumber("backlogCap", 1, 1000);
+        if (patch.replyDelay !== undefined) {
+            const value = Number(patch.replyDelay);
+            if (!Number.isFinite(value) || value < 0 || value > 120)
+                throw new Error("replyDelay must be between 0 and 120 seconds");
+            next.replyDelay = value;
+        }
+        const setText = (key, max) => {
+            if (patch[key] === undefined)
+                return;
+            const value = String(patch[key]).slice(0, max);
+            if (value !== next[key]) {
+                next[key] = value;
+                changed.push(key);
+            }
+        };
+        setText("topic", 2000);
+        setText("emoji", 8);
+        setText("humanDescription", 200);
+        let unknownRefs = [];
+        if (patch.customRules !== undefined) {
+            const resolved = this.resolveRuleReferences(String(patch.customRules).slice(0, 4000));
+            unknownRefs = resolved.unknown;
+            if (resolved.stored !== next.customRules) {
+                next.customRules = resolved.stored;
+                changed.push("customRules");
+            }
+        }
+        if (patch.humanDescriptionMode !== undefined) {
+            const mode = String(patch.humanDescriptionMode);
+            if (mode !== "inherit" && mode !== "override" && mode !== "append" && mode !== "none")
+                throw new Error("humanDescriptionMode must be inherit, override, append or none");
+            if (mode !== next.humanDescriptionMode) {
+                next.humanDescriptionMode = mode;
+                changed.push("humanDescriptionMode");
+            }
+        }
+        if (patch.refereeAction !== undefined) {
+            const action = String(patch.refereeAction);
+            if (action !== "next-header" && action !== "retry-hidden")
+                throw new Error("refereeAction must be next-header or retry-hidden");
+            if (action !== next.refereeAction) {
+                next.refereeAction = action;
+                changed.push("refereeAction");
+            }
+        }
+        if (patch.turnTaking !== undefined) {
+            const mode = String(patch.turnTaking);
+            if (mode !== "parallel" && mode !== "one-at-a-time")
+                throw new Error("turnTaking must be parallel or one-at-a-time");
+            if (mode !== next.turnTaking) {
+                next.turnTaking = mode;
+                changed.push("turnTaking");
+            }
+        }
+        if (patch.waitWhileHumanTypes !== undefined) {
+            const on = patch.waitWhileHumanTypes === true || patch.waitWhileHumanTypes === "true";
+            if (on !== next.waitWhileHumanTypes) {
+                next.waitWhileHumanTypes = on;
+                changed.push("waitWhileHumanTypes");
+            }
+        }
+        if (patch.language !== undefined) {
+            const raw = String(patch.language).trim();
+            const language = !raw || raw === "follow-human" ? { mode: "follow-human" } : { mode: "fixed", language: raw };
+            if (JSON.stringify(language) !== JSON.stringify(next.language)) {
+                next.language = language;
+                changed.push("language");
+            }
+        }
+        if (patch.tools !== undefined) {
+            const tools = String(patch.tools);
+            if (tools !== "on-request" && tools !== "never")
+                throw new Error("tools must be on-request or never");
+            if (tools !== next.tools) {
+                next.tools = tools;
+                changed.push("tools");
+            }
+        }
+        if (patch.maxSentences !== undefined) {
+            const value = patch.maxSentences === null || patch.maxSentences === "" ? null : Number(patch.maxSentences);
+            if (value !== null && (!Number.isInteger(value) || value < 1 || value > 100))
+                throw new Error("maxSentences must be 1-100 or empty");
+            if (value !== next.maxSentences) {
+                next.maxSentences = value;
+                changed.push("maxSentences");
+            }
+        }
+        for (const key of ["headerRules", "showVendorInRoster"]) {
+            if (patch[key] !== undefined) {
+                const value = patch[key] === true || patch[key] === "true";
+                if (value !== next[key]) {
+                    next[key] = value;
+                    changed.push(key);
+                }
+            }
+        }
+        this.settings = next;
+        this.push(this.roomEvent());
+        const briefChanges = changed.filter((c) => BRIEF_AFFECTING_SETTINGS.includes(c));
+        if (briefChanges.length) {
+            for (const runtime of this.runtimes.values())
+                runtime.briefPending = `room rules: ${briefChanges.join(", ")}`;
+            this.postSystem(`Room settings updated (${briefChanges.join(", ")}); agents get refreshed instructions on their next turn.`);
+        }
+        if (unknownRefs.length) {
+            this.notice(`Custom rules mention ${unknownRefs.map((n) => `@${n}`).join(", ")}, who ${unknownRefs.length > 1 ? "are" : "is"} not in the room; left as plain text.`, "warn");
+        }
+        return this.settings;
+    }
+    updatePersona(id, patch) {
+        const participant = this.participants.get(id);
+        const runtime = this.runtimes.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        const changed = [];
+        if (patch.name !== undefined) {
+            const name = patch.name.trim();
+            if (!NAME_PATTERN.test(name))
+                throw new Error("name must be 1-24 letters, digits, _ or - (no spaces)");
+            const taken = this.findByName(name);
+            if (taken && taken.id !== id)
+                throw new Error(`name "${name}" is already taken`);
+            if (name !== participant.name) {
+                this.postSystem(`${participant.name} is now called ${name}.`);
+                participant.name = name;
+                changed.push("name");
+                if (this.settings.customRules.includes(`@{p:${id}}`)) {
+                    for (const other of this.runtimes.values())
+                        other.briefPending = other.briefPending ?? "room rules: a referenced participant was renamed";
+                }
+            }
+        }
+        if (patch.tagline !== undefined && patch.tagline.trim() !== (participant.tagline ?? "")) {
+            participant.tagline = patch.tagline.trim().slice(0, 80);
+            changed.push("tagline");
+        }
+        if (patch.role !== undefined && patch.role.trim() !== (participant.role ?? "")) {
+            participant.role = patch.role.trim().slice(0, 4000);
+            changed.push("role");
+        }
+        if (patch.avatar !== undefined) {
+            participant.avatar = patch.avatar.trim().slice(0, 8) || undefined;
+        }
+        if (patch.replyDelay !== undefined) {
+            if (patch.replyDelay === null)
+                participant.replyDelay = undefined;
+            else {
+                const value = Number(patch.replyDelay);
+                if (!Number.isFinite(value) || value < 0 || value > 120)
+                    throw new Error("replyDelay must be between 0 and 120 seconds");
+                participant.replyDelay = value;
+            }
+        }
+        if (patch.skills !== undefined) {
+            const next = normalizeSkillList(patch.skills) ?? [];
+            const current = participant.skills ?? [];
+            if (next.join("\n") !== current.join("\n")) {
+                participant.skills = next;
+                changed.push("skills");
+            }
+        }
+        if (changed.length && runtime)
+            runtime.briefPending = `your persona: ${changed.join(", ")}`;
+        this.push({ type: "participant", participant });
+        return participant;
+    }
+    setMuted(id, muted) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        if (!!participant.muted === muted)
+            return participant;
+        participant.muted = muted;
+        const runtime = this.runtimes.get(id);
+        if (muted && runtime) {
+            this.dropScheduledTurn(id);
+            if (runtime.turnActive) {
+                runtime.agent.cancel(runtime.sessionId);
+                this.cancelPermissionsOf(id);
+            }
+        }
+        this.push({ type: "participant", participant });
+        this.postSystem(muted ? `${participant.name} is muted and receives no prompts.` : `${participant.name} is unmuted.`);
+        return participant;
+    }
+    async discoverOptions(recipeId, refresh = false) {
+        const recipe = getRecipe(recipeId);
+        if (!recipe)
+            throw new Error(`unknown agent type: ${recipeId}`);
+        if (recipe.unavailableReason)
+            throw new Error(`${recipe.label}: ${recipe.unavailableReason}`);
+        const cached = this.optionCache.get(recipeId);
+        if (cached && !refresh)
+            return cached;
+        const cwd = ensureDir(join(this.dataDir, ".probe"));
+        const log = this.log.child(`probe:${recipeId}`);
+        const launch = recipe.build({ model: null });
+        const agent = new AcpAgent({ ...launch, cwd }, {
+            onSessionUpdate: () => undefined,
+            onPermissionRequest: async () => ({ outcome: { outcome: "cancelled" } }),
+            onStderr: (line) => log.info(`stderr: ${line}`),
+            onExit: () => undefined,
+        });
+        const started = Date.now();
+        try {
+            const info = await Promise.race([
+                (async () => {
+                    const init = await agent.initialize({ name: "viberoom", version: "0.2.0" });
+                    const session = await this.openSession(agent, cwd, log);
+                    const result = {
+                        recipeId,
+                        agentInfo: { name: init.agentInfo?.name ?? null, version: init.agentInfo?.version ?? null },
+                        authMethods: agent.authMethods.map((m) => m.id),
+                        modes: session.modes ?? null,
+                        configOptions: session.configOptions ?? [],
+                        modelAtLaunch: !!recipe.modelAtLaunch,
+                        discoveredAt: Date.now(),
+                        durationMs: 0,
+                    };
+                    try {
+                        await Promise.race([agent.closeSession(session.sessionId), delay(1500)]);
+                    }
+                    catch {
+                    }
+                    return result;
+                })(),
+                delay(30_000).then(() => {
+                    throw new Error("agent did not answer initialize/session/new within 30 s");
+                }),
+            ]);
+            info.durationMs = Date.now() - started;
+            this.optionCache.set(recipeId, info);
+            log.info(`options discovered in ${info.durationMs} ms: ${info.configOptions.map((o) => o.id).join(", ") || "none"}`);
+            return info;
+        }
+        finally {
+            agent.kill();
+        }
+    }
+    async inviteAgent(options) {
+        const recipe = getRecipe(options.agentType);
+        if (!recipe)
+            throw new Error(`unknown agent type: ${options.agentType}`);
+        if (recipe.unavailableReason)
+            throw new Error(`${recipe.label}: ${recipe.unavailableReason}`);
+        const name = options.name.trim();
+        if (!NAME_PATTERN.test(name))
+            throw new Error("name must be 1-24 letters, digits, _ or - (no spaces)");
+        if (this.findByName(name))
+            throw new Error(`name "${name}" is already taken`);
+        const id = `${recipe.id}-${name.toLowerCase()}`;
+        const launch = {
+            model: options.model ?? recipe.defaultModel,
+            effort: options.effort ?? recipe.defaultEffort,
+            mode: options.mode ?? (this.bypassPermissionsByDefault ? recipe.bypassMode ?? recipe.defaultMode : recipe.defaultMode),
+        };
+        const participant = {
+            id,
+            name,
+            kind: "agent",
+            agentType: recipe.id,
+            agentLabel: recipe.label,
+            agentVendor: recipe.vendor,
+            status: "starting",
+            turns: 0,
+            color: COLORS[this.colorIndex++ % COLORS.length],
+            tagline: (options.tagline ?? "").trim().slice(0, 80),
+            role: (options.role ?? "").trim().slice(0, 4000),
+            avatar: (options.avatar ?? "").trim().slice(0, 8) || undefined,
+            replyDelay: options.replyDelay === undefined || options.replyDelay === null ? undefined : Math.max(0, Math.min(120, Number(options.replyDelay) || 0)),
+            skills: normalizeSkillList(options.skills ?? undefined),
+            launch,
+            violations: 0,
+            briefsSent: 0,
+            failedTurns: 0,
+        };
+        this.participants.set(id, participant);
+        this.push({ type: "participant", participant });
+        await this.startAgent(participant, launch, true);
+        return participant;
+    }
+    async reconnect(id, options = { mode: "replay" }) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        if (this.runtimes.has(id) || participant.status === "starting")
+            return participant;
+        participant.status = "starting";
+        participant.statusDetail = undefined;
+        this.push({ type: "participant", participant });
+        const launch = participant.launch ?? { model: participant.model ?? null, effort: participant.effort ?? null, mode: participant.mode ?? null };
+        await this.startAgent(participant, launch, false, options);
+        return participant;
+    }
+    async startAgent(participant, launch, fresh, reconnectOptions) {
+        const recipe = getRecipe(participant.agentType ?? "");
+        if (!recipe)
+            throw new Error(`unknown agent type: ${participant.agentType}`);
+        const id = participant.id;
+        const name = participant.name;
+        const log = this.log.child(name);
+        const cwd = ensureDir(this.dir);
+        const spec = recipe.build({ model: launch.model });
+        const transcript = new Transcript(join(this.dataDir, "transcripts"), name);
+        log.info(`spawning ${spec.command} ${spec.args.join(" ")} (cwd ${cwd}); transcript ${transcript.path}`);
+        let agent;
+        try {
+            agent = new AcpAgent({ ...spec, cwd }, {
+                onSessionUpdate: (_sessionId, update) => this.onSessionUpdate(id, update),
+                onPermissionRequest: (params) => this.onPermissionRequest(id, params),
+                onStderr: (line) => log.info(`stderr: ${line}`),
+                onExit: (code, signal) => this.onAgentExit(id, code, signal, agent),
+                onRaw: (direction, message) => transcript.record(direction, message),
+                onProtocolError: (text) => log.warn(`protocol: ${text}`),
+            });
+        }
+        catch (error) {
+            this.failStart(participant, error, fresh);
+            throw error;
+        }
+        try {
+            const init = await agent.initialize({ name: "viberoom", version: "0.2.0" });
+            participant.agentInfo = { name: init.agentInfo?.name, version: init.agentInfo?.version };
+            if (agent.authMethods.length) {
+                log.info(`auth methods advertised: ${agent.authMethods.map((m) => m.id).join(", ")}`);
+            }
+            participant.supportsLoad = agent.supportsLoadSession;
+            const mcp = this.skillMcpServers(id);
+            const mcpToken = mcp ? mcp.token : null;
+            const mcpServers = mcp ? [mcp.server] : [];
+            let session = null;
+            let origin = fresh ? "new" : "replayed";
+            if (!fresh && reconnectOptions?.mode === "load") {
+                if (!participant.sessionId)
+                    this.notice(`${name}: no stored session to load; starting a new one with replayed history.`, "warn");
+                else if (!agent.supportsLoadSession)
+                    this.notice(`${name}: this agent does not support session/load; starting a new session with replayed history.`, "warn");
+                else {
+                    try {
+                        log.info(`session/load ${participant.sessionId}`);
+                        session = await agent.loadSession(participant.sessionId, cwd, mcpServers);
+                        origin = "loaded";
+                    }
+                    catch (error) {
+                        this.notice(`${name}: session/load failed (${describeError(error)}); starting a new session with replayed history.`, "warn");
+                    }
+                }
+            }
+            if (!session)
+                session = await this.openSession(agent, cwd, log, mcpServers);
+            participant.sessionId = session.sessionId;
+            participant.sessionOrigin = origin;
+            const storedSeen = this.restoredSeen.get(id);
+            const runtime = {
+                agent,
+                sessionId: session.sessionId,
+                transcript,
+                log,
+                firstTurnDone: false,
+                lastSeenSeq: this.seq,
+                turnStartSeq: this.seq,
+                turnActive: false,
+                pendingTurn: false,
+                turn: null,
+                turnsSinceBrief: 0,
+                usedAtBrief: 0,
+                briefSentThisTurn: false,
+                lastUsed: 0,
+                briefPending: null,
+                headerNotes: [],
+                briefRequestedAtSeq: -1,
+                replayOwnUntilSeq: fresh || origin === "loaded" ? -1 : this.seq,
+                delayTimer: null,
+                addressed: false,
+                retiring: false,
+                mcpToken,
+                sessionStartedAt: Date.now(),
+                skillChannel: mcp ? "pending" : "marker",
+                skillReadyWaiters: [],
+                pendingSkills: [],
+                skillPulledAtSeq: -1,
+                skillPulledName: "",
+            };
+            participant.skillChannel = runtime.skillChannel;
+            this.runtimes.set(id, runtime);
+            if (mcpToken && this.earlySkillReady.delete(mcpToken))
+                this.skillToolReady(id, mcpToken);
+            this.restoredSeen.delete(id);
+            participant.configOptions = session.configOptions ?? undefined;
+            if (session.modes) {
+                participant.mode = session.modes.currentModeId;
+                participant.modes = session.modes.availableModes;
+            }
+            this.applyConfigSummary(participant);
+            const warnings = await this.applyConfig(runtime, participant, {
+                model: recipe.modelAtLaunch ? null : launch.model,
+                effort: launch.effort,
+                mode: launch.mode,
+            });
+            if (recipe.modelAtLaunch && launch.model)
+                participant.model = launch.model;
+            for (const w of warnings)
+                this.notice(`${name}: ${w}`, "warn");
+            participant.status = "idle";
+            participant.statusDetail = undefined;
+            this.push({ type: "participant", participant });
+            if (fresh) {
+                const detail = this.settings.showVendorInRoster ? `${recipe.label}${participant.model ? `, model ${participant.model}` : ""}` : "agent";
+                this.postSystem(`${name} joined the room (${detail}${participant.tagline ? `; "${participant.tagline}"` : ""}).`);
+                runtime.lastSeenSeq = this.seq;
+                participant.sawFromSeq = this.seq + 1;
+            }
+            else if (origin === "loaded") {
+                runtime.lastSeenSeq = storedSeen ?? Math.max(0, this.seq - this.settings.replayAfterRestart);
+                runtime.firstTurnDone = true;
+                runtime.briefPending = "reconnected: your stored session was restored";
+                this.postSystem(`${name} is back in the room (session restored).`);
+                if (participant.sawFromSeq === undefined)
+                    participant.sawFromSeq = runtime.lastSeenSeq + 1;
+            }
+            else {
+                this.postSystem(reconnectOptions?.reason ? `${name} restarted: ${reconnectOptions.reason}.` : `${name} is back in the room.`);
+                const replay = Math.max(0, reconnectOptions?.replay ?? this.settings.replayAfterRestart);
+                const chats = this.messages.filter((m) => m.kind === "chat");
+                const firstReplayed = replay > 0 && chats.length ? chats[Math.max(0, chats.length - replay)] : undefined;
+                runtime.lastSeenSeq = firstReplayed ? Math.max(0, firstReplayed.seq - 1) : this.seq;
+                participant.sawFromSeq = runtime.lastSeenSeq + 1;
+            }
+            this.restoredSeen.delete(id);
+            this.push({ type: "participant", participant });
+            runtime.turnStartSeq = runtime.lastSeenSeq;
+            log.info(`ready: session ${session.sessionId}`);
+        }
+        catch (error) {
+            agent.kill();
+            this.forgetRuntime(id);
+            this.failStart(participant, error, fresh);
+            throw error;
+        }
+    }
+    async removeParticipant(id) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        const runtime = this.runtimes.get(id);
+        if (runtime) {
+            this.dropScheduledTurn(id);
+            if (runtime.turnActive)
+                runtime.agent.cancel(runtime.sessionId);
+            this.cancelPermissionsOf(id);
+            try {
+                await Promise.race([runtime.agent.closeSession(runtime.sessionId), delay(2000)]);
+            }
+            catch (error) {
+                runtime.log.warn(`session/close failed: ${String(error)}`);
+            }
+            runtime.agent.kill();
+            this.forgetRuntime(id);
+            if (this.speaking === id) {
+                this.speaking = null;
+                this.startNext();
+            }
+        }
+        participant.status = "left";
+        this.participants.delete(id);
+        this.departed.set(id, participant.name);
+        this.push({ type: "participant.removed", id });
+        this.postSystem(`${participant.name} left the room.`);
+        if (RULE_REF_TOKEN.test(this.settings.customRules)) {
+            RULE_REF_TOKEN.lastIndex = 0;
+            if (this.settings.customRules.includes(`@{p:${id}}`)) {
+                for (const runtime of this.runtimes.values())
+                    runtime.briefPending = "room rules: a referenced participant left";
+            }
+        }
+    }
+    cancelTurn(id) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (!runtime || !participant)
+            throw new Error("no such agent");
+        if (!runtime.turnActive)
+            return;
+        runtime.agent.cancel(runtime.sessionId);
+        this.cancelPermissionsOf(id);
+        this.notice(`${participant.name}: stop requested.`, "info");
+    }
+    async setConfig(id, configId, value) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (!runtime || !participant)
+            throw new Error("no such agent (offline?)");
+        const hasOption = participant.configOptions?.some((o) => o.id === configId);
+        if (!hasOption && configId === "mode" && participant.modes?.some((m) => m.id === value)) {
+            await runtime.agent.setMode(runtime.sessionId, String(value));
+            participant.mode = String(value);
+        }
+        else {
+            participant.configOptions = await runtime.agent.setConfigOption(runtime.sessionId, configId, value);
+            this.applyConfigSummary(participant);
+        }
+        participant.launch = { model: participant.model ?? null, effort: participant.effort ?? null, mode: participant.mode ?? null };
+        this.push({ type: "participant", participant });
+    }
+    resolvePermission(key, optionId) {
+        const entry = this.permissions.get(key);
+        if (!entry)
+            throw new Error("no such pending permission");
+        this.permissions.delete(key);
+        entry.resolve(optionId ? { outcome: { outcome: "selected", optionId } } : { outcome: { outcome: "cancelled" } });
+        this.push({ type: "permission.resolved", key, optionId });
+    }
+    postNotice(text) {
+        this.postSystem(text);
+    }
+    async shutdown() {
+        this.closing = true;
+        if (this.typingTimer) {
+            clearTimeout(this.typingTimer);
+            this.typingTimer = null;
+        }
+        for (const [id, runtime] of this.runtimes) {
+            if (runtime.delayTimer)
+                clearTimeout(runtime.delayTimer);
+            runtime.delayTimer = null;
+            runtime.pendingTurn = false;
+            try {
+                if (runtime.turnActive)
+                    runtime.agent.cancel(runtime.sessionId);
+                await Promise.race([runtime.agent.closeSession(runtime.sessionId), delay(1000)]);
+            }
+            catch {
+            }
+            runtime.agent.kill();
+            this.forgetRuntime(id);
+        }
+    }
+    route(message) {
+        const from = this.participants.get(message.from);
+        const live = (id) => this.runtimes.has(id) && !this.participants.get(id)?.muted;
+        const agentTargets = message.to.filter(live);
+        let targets = [];
+        if (from?.kind === "human") {
+            this.hops = 0;
+            targets = message.to.length ? agentTargets : [...this.runtimes.keys()].filter(live);
+            if (message.skill) {
+                const skill = this.skills?.library.get(message.skill.name);
+                if (!message.to.length)
+                    targets = targets.filter((id) => this.hasSkill(this.participants.get(id), message.skill.name));
+                if (!targets.length)
+                    this.notice(`Nobody in this room has the skill "${message.skill.name}"; attach it to an agent first, or address one with @.`, "warn");
+                if (skill) {
+                    for (const id of targets) {
+                        const runtime = this.runtimes.get(id);
+                        if (runtime)
+                            runtime.pendingSkills.push({ name: skill.name, text: renderSkillBody(skill.body, message.skill.args), invokedBy: from.name, extraFiles: skill.extraFiles });
+                    }
+                }
+                targets = [...targets];
+            }
+            if (!message.to.length && !message.skill && this.settings.turnTaking === "one-at-a-time" && targets.length > 1)
+                targets = shuffle(targets);
+        }
+        else if (this.focused) {
+            targets = [];
+        }
+        else if (agentTargets.length) {
+            if (this.hops >= this.hopLimit) {
+                this.postSystem(`Hop limit ${this.hopLimit} reached: ${message.toNames.join(", ")} will not be prompted until ${this.humanName} writes again.`);
+            }
+            else {
+                this.hops += 1;
+                targets = agentTargets;
+            }
+        }
+        this.push(this.roomEvent());
+        for (const id of targets)
+            this.requestTurn(id, message.to.includes(id) || !!message.skill);
+    }
+    hasSkill(participant, name) {
+        if (!participant?.skills)
+            return false;
+        const lower = name.toLowerCase();
+        return participant.skills.some((s) => s.toLowerCase() === lower);
+    }
+    attachedSkills(participant) {
+        if (!this.skills || !participant.skills?.length)
+            return [];
+        return this.skills.library.list().filter((s) => !s.problems.length && !s.draft && this.hasSkill(participant, s.name));
+    }
+    skillsForPrompt(participant, runtime) {
+        if (!this.skills)
+            return undefined;
+        const items = this.attachedSkills(participant)
+            .filter((s) => s.agentInvocable)
+            .map((s) => ({ name: s.name, description: s.description }));
+        const channel = runtime.skillChannel === "tool" ? "tool" : "marker";
+        if (!items.length && channel !== "tool")
+            return undefined;
+        return { items, channel, canCreate: channel === "tool" };
+    }
+    createSkillForAgent(participantId, input) {
+        const participant = this.participants.get(participantId);
+        if (!participant || !this.runtimes.has(participantId))
+            throw new Error("this agent is not in the room any more");
+        if (!this.skills)
+            throw new Error("skills are not available in this hub");
+        const library = this.skills.library;
+        const name = String(input.name ?? "").trim();
+        const existing = library.get(name);
+        if (input.op === "create" && existing) {
+            throw new Error(`a skill named "${existing.name}" already exists (author ${existing.author}); use update_skill for an agent-made skill, or pick another name`);
+        }
+        if (input.op === "update") {
+            if (!existing)
+                throw new Error(`no skill named "${name}" to update; use create_skill`);
+            if (!existing.author.startsWith("agent:"))
+                throw new Error(`skill "${existing.name}" was written by the human and is read-only for agents; ask in the room or create a new one`);
+        }
+        const draft = {
+            name: existing?.name ?? name,
+            description: String(input.description ?? ""),
+            argumentHint: input.argumentHint ? String(input.argumentHint) : "",
+            body: String(input.instructions ?? ""),
+            userInvocable: input.userInvocable,
+            agentInvocable: input.agentInvocable,
+            author: existing?.author ?? `agent:${participant.name}@${this.id}`,
+            reviewed: false,
+            draft: existing ? existing.draft : this.skills.needApproval(),
+        };
+        const lint = library.lint(draft);
+        if (lint.errors.length)
+            throw new Error(`not saved: ${lint.errors.map((e) => e.message).join("; ")}`);
+        const warnings = lint.warnings.map((w) => w.message);
+        if (input.dryRun)
+            return { ok: true, message: `dry run: "${draft.name}" would be ${input.op === "create" ? "created" : "updated"}${warnings.length ? ` with warnings: ${warnings.join("; ")}` : ""}`, warnings };
+        const saved = this.skills.save(draft);
+        const awaiting = saved.draft ? " It is a draft until the human approves it in Settings; it cannot be attached or loaded before that." : "";
+        this.postSystem(`${participant.name} ${input.op === "create" ? "created" : "updated"} the skill "${saved.name}" (${saved.description.slice(0, 80)}${saved.description.length > 80 ? "…" : ""}).${saved.draft ? " Awaiting the human's approval." : ""}`);
+        this.log.info(`skills: ${participant.name} ${input.op}d "${saved.name}"${saved.draft ? " (draft)" : ""}`);
+        return {
+            ok: true,
+            message: `Skill "${saved.name}" ${input.op === "create" ? "created" : "updated"} in the shared library.${awaiting}${warnings.length ? ` Warnings: ${warnings.join("; ")}` : ""}${saved.draft ? "" : " Use attach_skill to give it to yourself or to other agents."}`,
+            warnings,
+        };
+    }
+    attachSkillForAgent(participantId, name, to) {
+        const participant = this.participants.get(participantId);
+        if (!participant || !this.runtimes.has(participantId))
+            throw new Error("this agent is not in the room any more");
+        if (!this.skills)
+            throw new Error("skills are not available in this hub");
+        const skill = this.skills.library.get(String(name ?? "").trim());
+        if (!skill)
+            throw new Error(`no skill named "${name}" in the library`);
+        if (skill.problems.length)
+            throw new Error(`skill "${skill.name}" cannot be attached (${skill.problems.join("; ")})`);
+        if (skill.draft)
+            throw new Error(`skill "${skill.name}" is a draft awaiting the human's approval; it cannot be attached yet`);
+        const targets = [];
+        const unknown = [];
+        if (to === "me" || (Array.isArray(to) && to.length === 0))
+            targets.push(participant);
+        else {
+            for (const raw of Array.isArray(to) ? to : [String(to)]) {
+                const wanted = String(raw).trim();
+                if (!wanted || wanted.toLowerCase() === "me" || wanted.toLowerCase() === participant.name.toLowerCase()) {
+                    if (!targets.includes(participant))
+                        targets.push(participant);
+                    continue;
+                }
+                const other = this.findByName(wanted.replace(/^@/, ""));
+                if (!other || other.kind !== "agent" || other.status === "left")
+                    unknown.push(wanted);
+                else if (!targets.includes(other))
+                    targets.push(other);
+            }
+        }
+        if (unknown.length)
+            throw new Error(`no such agent in this room: ${unknown.join(", ")} (agents here: ${[...this.participants.values()].filter((p) => p.kind === "agent" && p.status !== "left").map((p) => p.name).join(", ")})`);
+        const attached = [];
+        for (const target of targets) {
+            if (this.hasSkill(target, skill.name))
+                continue;
+            target.skills = [...(target.skills ?? []), skill.name];
+            attached.push(target.name);
+            const runtime = this.runtimes.get(target.id);
+            if (runtime)
+                runtime.briefPending = runtime.briefPending ?? `your skills: "${skill.name}" attached${target.id === participant.id ? "" : ` by ${participant.name}`}`;
+            this.push({ type: "participant", participant: target });
+        }
+        const others = attached.filter((n) => n !== participant.name);
+        if (others.length)
+            this.postSystem(`${participant.name} attached the skill "${skill.name}" to ${others.join(", ")}.`);
+        this.log.info(`skills: ${participant.name} attached "${skill.name}" to ${attached.join(", ") || "nobody new"}`);
+        const already = targets.filter((t) => !attached.includes(t.name)).map((t) => t.name);
+        return {
+            ok: true,
+            message: `${attached.length ? `Skill "${skill.name}" attached to ${attached.map((n) => (n === participant.name ? "you" : n)).join(", ")}.` : ""}${already.length ? ` ${already.map((n) => (n === participant.name ? "You" : n)).join(", ")} already had it.` : ""}`.trim(),
+        };
+    }
+    skillMcpServers(participantId) {
+        const hubUrl = this.skills?.hubUrl();
+        if (!this.skills || !hubUrl)
+            return null;
+        const token = this.skills.issueToken(this.id, participantId);
+        return {
+            token,
+            server: {
+                name: "viberoom",
+                command: process.execPath,
+                args: [this.skills.serverScript],
+                env: [
+                    { name: "VIBEROOM_HUB", value: hubUrl },
+                    { name: "VIBEROOM_TOKEN", value: token },
+                ],
+            },
+        };
+    }
+    skillToolReady(participantId, token) {
+        const runtime = this.runtimes.get(participantId);
+        const participant = this.participants.get(participantId);
+        if (!runtime || runtime.mcpToken !== token) {
+            this.earlySkillReady.add(token);
+            return;
+        }
+        if (!participant)
+            return;
+        const late = runtime.skillChannel === "marker";
+        runtime.skillChannel = "tool";
+        participant.skillChannel = "tool";
+        for (const wake of runtime.skillReadyWaiters.splice(0))
+            wake();
+        runtime.log.info(`skills: the ${SKILL_TOOL_NAME} tool is available${late ? " (late; brief will be refreshed)" : ""}`);
+        if (late && this.attachedSkills(participant).length)
+            runtime.briefPending = runtime.briefPending ?? "your skills: the load_skill tool became available";
+        this.push({ type: "participant", participant });
+    }
+    async awaitSkillChannel(participant, runtime) {
+        if (runtime.skillChannel !== "pending")
+            return;
+        const remaining = runtime.sessionStartedAt + SKILL_TOOL_READY_MS - Date.now();
+        if (remaining > 0) {
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, remaining);
+                runtime.skillReadyWaiters.push(() => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+        }
+        if (runtime.skillChannel === "pending") {
+            runtime.skillChannel = "marker";
+            participant.skillChannel = "marker";
+            runtime.log.info("skills: no MCP tools listed in time; using the [skill:name] marker");
+            this.push({ type: "participant", participant });
+        }
+    }
+    loadSkillForAgent(participantId, name) {
+        const participant = this.participants.get(participantId);
+        const runtime = this.runtimes.get(participantId);
+        if (!participant || !runtime)
+            throw new Error("this agent is not in the room any more");
+        const skill = this.resolveAgentSkill(participant, name);
+        if (!skill.ok)
+            throw new Error(skill.reason);
+        const text = composeSkillBlock({ name: skill.skill.name, text: renderSkillBody(skill.skill.body, ""), extraFiles: skill.skill.extraFiles });
+        this.commit({
+            id: randomUUID(),
+            seq: ++this.seq,
+            from: participant.id,
+            fromName: participant.name,
+            to: [],
+            toNames: [],
+            text: `loaded skill "${skill.skill.name}"`,
+            ts: Date.now(),
+            kind: "hidden",
+            details: { skill: skill.skill.name, via: "tool", outcome: "delivered as a tool result" },
+        });
+        runtime.log.info(`skills: "${skill.skill.name}" loaded through the tool`);
+        return { name: skill.skill.name, text };
+    }
+    resolveAgentSkill(participant, name) {
+        if (!this.skills)
+            return { ok: false, reason: "skills are not available in this hub" };
+        const skill = this.skills.library.get(name);
+        const builtin = !!skill && skill.author === BUILTIN_AUTHOR && !skill.draft;
+        const mine = this.attachedSkills(participant).filter((s) => s.agentInvocable).map((s) => s.name);
+        const list = mine.length ? `your skills: ${mine.join(", ")}` : "you have no skills";
+        if (!builtin && (!this.hasSkill(participant, name) || !mine.some((s) => s.toLowerCase() === name.toLowerCase()))) {
+            return { ok: false, reason: `"${name}" is not one of your skills (${list})` };
+        }
+        if (!skill || skill.problems.length)
+            return { ok: false, reason: `skill "${name}" cannot be loaded right now (${skill ? skill.problems.join("; ") : "missing"})` };
+        return { ok: true, skill };
+    }
+    skillChanged(name) {
+        for (const [id, runtime] of this.runtimes) {
+            const participant = this.participants.get(id);
+            if (participant && this.hasSkill(participant, name))
+                runtime.briefPending = runtime.briefPending ?? `your skills: "${name}" changed`;
+        }
+    }
+    isSkillToolCall(runtime, params) {
+        const pattern = /load_skill/i;
+        const call = params.toolCall;
+        if (pattern.test(call.title ?? ""))
+            return true;
+        if (call.rawInput && pattern.test(JSON.stringify(call.rawInput)))
+            return true;
+        const known = runtime.turn?.message.toolCalls?.find((t) => t.toolCallId === call.toolCallId);
+        return !!known && pattern.test(known.title ?? "");
+    }
+    forgetRuntime(id) {
+        const runtime = this.runtimes.get(id);
+        if (runtime?.mcpToken)
+            this.skills?.revokeToken(runtime.mcpToken);
+        if (runtime?.delayTimer)
+            clearTimeout(runtime.delayTimer);
+        this.runtimes.delete(id);
+    }
+    requestTurn(id, addressed = false) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (!runtime || !participant)
+            return;
+        runtime.pendingTurn = true;
+        if (addressed && !runtime.addressed) {
+            runtime.addressed = true;
+            if (this.floorQueue.includes(id)) {
+                this.floorQueue.splice(this.floorQueue.indexOf(id), 1);
+                this.enqueueForFloor(id);
+            }
+        }
+        if (runtime.turnActive || runtime.delayTimer || this.floorQueue.includes(id))
+            return;
+        const others = [...this.runtimes.keys()].filter((otherId) => otherId !== id && this.participants.get(otherId)?.status !== "left").length;
+        const roomDelay = others >= 1 ? (this.settings.replyDelay ?? 0) : 0;
+        const maxMs = Math.max(0, participant.replyDelay ?? roomDelay) * 1000;
+        const waitMs = maxMs > 0 ? Math.round(Math.random() * maxMs) : 0;
+        if (participant.status === "idle") {
+            participant.status = "queued";
+            this.push({ type: "participant", participant });
+        }
+        runtime.delayTimer = setTimeout(() => {
+            runtime.delayTimer = null;
+            this.tryStartTurn(id);
+        }, waitMs);
+        if (waitMs)
+            runtime.log.info(`reply delay ${waitMs} ms`);
+    }
+    tryStartTurn(id) {
+        const runtime = this.runtimes.get(id);
+        if (!runtime || !runtime.pendingTurn)
+            return;
+        if (this.humanIsTyping()) {
+            this.enqueueForFloor(id);
+            this.armTypingTimer();
+            return;
+        }
+        if (this.settings.turnTaking === "one-at-a-time" && this.speaking && this.speaking !== id) {
+            this.enqueueForFloor(id);
+            return;
+        }
+        void this.runTurn(id);
+    }
+    enqueueForFloor(id) {
+        if (this.floorQueue.includes(id))
+            return;
+        const runtime = this.runtimes.get(id);
+        if (runtime?.addressed) {
+            const firstPlain = this.floorQueue.findIndex((other) => !this.runtimes.get(other)?.addressed);
+            if (firstPlain >= 0) {
+                this.floorQueue.splice(firstPlain, 0, id);
+                return;
+            }
+        }
+        this.floorQueue.push(id);
+    }
+    humanIsTyping() {
+        return this.settings.waitWhileHumanTypes && Date.now() < this.humanTypingUntil;
+    }
+    humanTyping() {
+        this.humanTypingUntil = Date.now() + 4000;
+        this.armTypingTimer();
+    }
+    armTypingTimer() {
+        if (this.typingTimer)
+            return;
+        const wait = Math.max(50, this.humanTypingUntil - Date.now() + 20);
+        this.typingTimer = setTimeout(() => {
+            this.typingTimer = null;
+            if (this.humanIsTyping()) {
+                this.armTypingTimer();
+                return;
+            }
+            if (!this.speaking)
+                this.startNext();
+        }, wait);
+    }
+    startNext() {
+        if (this.humanIsTyping()) {
+            this.armTypingTimer();
+            return;
+        }
+        while (this.floorQueue.length) {
+            const id = this.floorQueue.shift();
+            const runtime = this.runtimes.get(id);
+            const participant = this.participants.get(id);
+            if (!runtime || !participant || !runtime.pendingTurn || participant.muted || this.focused)
+                continue;
+            void this.runTurn(id);
+            return;
+        }
+    }
+    dropScheduledTurn(id) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (runtime) {
+            runtime.pendingTurn = false;
+            runtime.addressed = false;
+            if (runtime.delayTimer) {
+                clearTimeout(runtime.delayTimer);
+                runtime.delayTimer = null;
+            }
+        }
+        const i = this.floorQueue.indexOf(id);
+        if (i >= 0)
+            this.floorQueue.splice(i, 1);
+        if (participant && participant.status === "queued") {
+            participant.status = "idle";
+            this.push({ type: "participant", participant });
+        }
+    }
+    async runTurn(id) {
+        const participant = this.participants.get(id);
+        const runtime = this.runtimes.get(id);
+        if (!participant || !runtime)
+            return;
+        this.speaking = id;
+        runtime.addressed = false;
+        try {
+            await this.runTurnInner(id, participant, runtime);
+        }
+        finally {
+            if (this.speaking === id)
+                this.speaking = null;
+            if (participant.status === "queued") {
+                participant.status = "idle";
+                this.push({ type: "participant", participant });
+            }
+            if (runtime.pendingTurn && runtime.agent.alive)
+                this.requestTurn(id);
+            this.startNext();
+        }
+    }
+    async runTurnInner(id, participant, runtime) {
+        runtime.pendingTurn = false;
+        if (!runtime.agent.alive || participant.muted || this.focused)
+            return;
+        await this.awaitSkillChannel(participant, runtime);
+        if (!runtime.agent.alive || participant.muted || this.focused)
+            return;
+        const unreadAll = this.messages.filter((m) => m.kind !== "hidden" && m.seq > runtime.lastSeenSeq && (m.kind === "system" || m.from !== id || m.seq <= runtime.replayOwnUntilSeq));
+        if (!unreadAll.some((m) => m.kind === "chat"))
+            return;
+        const cap = this.settings.backlogCap;
+        const omitted = Math.max(0, unreadAll.length - cap);
+        const unread = omitted ? unreadAll.slice(omitted) : unreadAll;
+        runtime.turnStartSeq = runtime.lastSeenSeq;
+        runtime.lastSeenSeq = this.seq;
+        const persona = this.personaOf(participant);
+        const roster = this.roster();
+        const settings = this.effectiveSettings();
+        const tokensSinceBrief = runtime.lastUsed - runtime.usedAtBrief;
+        let briefReason = null;
+        if (!runtime.firstTurnDone)
+            briefReason = "first turn";
+        else if (runtime.briefPending)
+            briefReason = runtime.briefPending;
+        else if (runtime.turnsSinceBrief >= this.settings.fullBriefEveryTurns)
+            briefReason = `every ${this.settings.fullBriefEveryTurns} turns`;
+        else if (tokensSinceBrief >= this.settings.fullBriefEveryTokens)
+            briefReason = `${tokensSinceBrief} tokens since last brief`;
+        const notes = [...runtime.headerNotes];
+        runtime.headerNotes = [];
+        if (briefReason && runtime.firstTurnDone) {
+            if (briefReason.startsWith("requested"))
+                notes.push("full brief re-sent as requested");
+            else if (briefReason.startsWith("room rules") || briefReason.startsWith("your persona") || briefReason.startsWith("your skills"))
+                notes.push(`instructions updated (${briefReason})`);
+            else
+                notes.push(`full brief re-attached (${briefReason})`);
+        }
+        const attached = runtime.pendingSkills.splice(0);
+        for (const s of attached) {
+            notes.push(s.invokedBy ? `${s.invokedBy} invoked your skill "${s.name}"; its instructions are attached below, follow them` : `skill "${s.name}" attached below as you asked; the same messages follow`);
+        }
+        const skillsForPrompt = this.skillsForPrompt(participant, runtime);
+        const promptText = composePrompt({
+            brief: briefReason ? buildBrief(settings, persona, roster, undefined, skillsForPrompt) : undefined,
+            header: buildHeader(settings, persona, roster, this.hops, notes, skillsForPrompt),
+            skills: attached.map((s) => composeSkillBlock({ name: s.name, text: s.text, invokedBy: s.invokedBy, extraFiles: s.extraFiles })),
+            backlog: unread.map((m) => m.kind === "system"
+                ? { kind: "event", text: m.text }
+                : { kind: "message", fromName: m.from === id ? `${m.fromName} (you, earlier)` : m.fromName, toNames: m.toNames, text: m.text }),
+            omitted,
+            personaName: participant.name,
+        });
+        if (briefReason) {
+            runtime.briefPending = null;
+            runtime.turnsSinceBrief = 0;
+            runtime.briefSentThisTurn = true;
+            participant.briefsSent = (participant.briefsSent ?? 0) + 1;
+        }
+        runtime.firstTurnDone = true;
+        runtime.replayOwnUntilSeq = -1;
+        runtime.log.info(`turn: ${unread.length} unread (${omitted} omitted), brief=${briefReason ?? "no"}, notes=${notes.length}`);
+        const retry = await this.executeTurn(participant, runtime, promptText, null);
+        if (retry) {
+            await this.executeTurn(participant, runtime, retry.prompt, retry);
+        }
+    }
+    async executeTurn(participant, runtime, promptText, retry) {
+        const id = participant.id;
+        runtime.turnActive = true;
+        participant.status = "thinking";
+        participant.statusDetail = undefined;
+        this.push({ type: "participant", participant });
+        const draft = {
+            id: randomUUID(),
+            seq: 0,
+            from: id,
+            fromName: participant.name,
+            to: [],
+            toNames: [],
+            text: "",
+            ts: Date.now(),
+            kind: "chat",
+            streaming: true,
+            toolCalls: [],
+        };
+        this.drafts.set(draft.id, draft);
+        runtime.turn = { message: draft, messageId: null, sawMessageId: false, startedAt: Date.now() };
+        this.push({ type: "message", message: draft });
+        let result = null;
+        let failure = null;
+        try {
+            result = await runtime.agent.prompt(runtime.sessionId, [{ type: "text", text: promptText }]);
+        }
+        catch (error) {
+            failure = error instanceof Error ? error.message : String(error);
+        }
+        const startedAt = runtime.turn.startedAt;
+        runtime.turn = null;
+        runtime.turnActive = false;
+        this.drafts.delete(draft.id);
+        participant.turns += 1;
+        if (!retry)
+            runtime.turnsSinceBrief += 1;
+        if (runtime.briefSentThisTurn) {
+            runtime.usedAtBrief = runtime.lastUsed;
+            runtime.briefSentThisTurn = false;
+        }
+        if (runtime.retiring) {
+            this.push({ type: "message.removed", id: draft.id });
+            if (retry)
+                this.closeRetry(retry, "the session was replaced; nothing was posted");
+            return null;
+        }
+        if (failure || !result) {
+            participant.status = runtime.agent.alive ? "idle" : "error";
+            participant.statusDetail = `last turn failed: ${(failure ?? "no result").replace(/\s+/g, " ").slice(0, 120)}`;
+            participant.failedTurns = (participant.failedTurns ?? 0) + 1;
+            this.push({ type: "participant", participant });
+            this.push({ type: "message.removed", id: draft.id });
+            this.notice(`${participant.name}: turn failed: ${failure ?? "no result"}`, "error");
+            this.postSystem(`${participant.name} could not answer: ${(failure ?? "no result").slice(0, 240)}`);
+            runtime.log.error(`turn failed: ${failure}`);
+            if (retry)
+                this.closeRetry(retry, "the correction turn failed; nothing was posted");
+            return null;
+        }
+        return this.finalizeTurn(participant, runtime, draft, result, Date.now() - startedAt, retry);
+    }
+    finalizeTurn(participant, runtime, draft, result, durationMs, retry) {
+        participant.status = "idle";
+        this.push({ type: "participant", participant });
+        const text = draft.text.trim();
+        const cancelled = result.stopReason === "cancelled";
+        if (cancelled)
+            runtime.briefPending = runtime.briefPending ?? "previous turn was cancelled";
+        if (!retry && text.toLowerCase() === REQUEST_BRIEF_MARKER) {
+            this.push({ type: "message.removed", id: draft.id });
+            if (runtime.briefRequestedAtSeq === runtime.lastSeenSeq) {
+                this.notice(`${participant.name} asked for the brief twice on the same messages; treated as silent.`, "warn");
+                return null;
+            }
+            runtime.briefRequestedAtSeq = runtime.lastSeenSeq;
+            runtime.lastSeenSeq = runtime.turnStartSeq;
+            runtime.briefPending = "requested by the agent";
+            this.notice(`${participant.name} asked for the room brief (hidden turn); re-sending with the same messages.`, "info");
+            this.requestTurn(participant.id);
+            return null;
+        }
+        const pull = !retry ? text.match(SKILL_MARKER_PATTERN) : null;
+        if (pull) {
+            this.push({ type: "message.removed", id: draft.id });
+            return this.handleSkillPull(participant, runtime, text, pull[1]);
+        }
+        if (!text || text.toLowerCase() === SILENT_MARKER) {
+            this.push({ type: "message.removed", id: draft.id });
+            if (retry) {
+                this.closeRetry(retry, cancelled ? "the correction turn was stopped; nothing was posted" : "the agent withdrew the reply");
+                if (cancelled)
+                    this.postSystem(`${participant.name} was stopped.`);
+            }
+            else {
+                this.postSystem(cancelled ? `${participant.name} was stopped.` : `${participant.name} read the room and has nothing to add.`);
+            }
+            return null;
+        }
+        if (!(draft.toolCalls?.length) && ADAPTER_ERROR_PATTERN.test(text)) {
+            this.push({ type: "message.removed", id: draft.id });
+            participant.failedTurns = (participant.failedTurns ?? 0) + 1;
+            participant.statusDetail = `agent error: ${text.replace(/\s+/g, " ").slice(0, 120)}${text.length > 120 ? "…" : ""}`;
+            this.push({ type: "participant", participant });
+            this.postSystem(`${participant.name}'s agent reported an error instead of a reply: ${text.slice(0, 200)}${text.length > 200 ? "…" : ""}`);
+            runtime.log.warn(`adapter error text treated as failed turn: ${text.slice(0, 200)}`);
+            if (retry)
+                this.closeRetry(retry, "the agent reported an error instead of a corrected reply");
+            return null;
+        }
+        const mentions = this.parseMentions(text);
+        const corrections = this.referee(participant, text, mentions);
+        if (corrections.length) {
+            participant.violations = (participant.violations ?? 0) + corrections.length;
+            runtime.log.info(`referee${retry ? " (after retry)" : ""}: ${corrections.join(" | ")}`);
+            if (!retry && this.settings.refereeAction === "retry-hidden" && !cancelled) {
+                this.push({ type: "message.removed", id: draft.id });
+                participant.retries = (participant.retries ?? 0) + 1;
+                this.push({ type: "participant", participant });
+                const record = {
+                    id: randomUUID(),
+                    seq: ++this.seq,
+                    from: participant.id,
+                    fromName: participant.name,
+                    to: [],
+                    toNames: [],
+                    text: `Reply held back; correction requested: ${corrections.map((c) => c.replace(/^reminder:\s*/i, "")).join("; ")}`,
+                    ts: Date.now(),
+                    kind: "hidden",
+                    details: { original: text, corrections },
+                };
+                this.commit(record);
+                const header = buildHeader(this.effectiveSettings(), this.personaOf(participant), this.roster(), this.hops, [
+                    "your last reply was not posted; see the correction below",
+                ]);
+                return {
+                    prompt: composeCorrectionPrompt({ header, originalText: text, corrections, personaName: participant.name }),
+                    original: text,
+                    corrections,
+                    record,
+                };
+            }
+            runtime.headerNotes.push(...corrections);
+            this.push({ type: "participant", participant });
+        }
+        const message = {
+            ...draft,
+            seq: ++this.seq,
+            to: mentions.ids,
+            toNames: mentions.names,
+            text,
+            streaming: false,
+            stopReason: result.stopReason,
+            usage: result.usage ?? null,
+            durationMs,
+        };
+        this.commit(message);
+        if (retry) {
+            this.closeRetry(retry, corrections.length ? `corrected reply posted, but it still breaks: ${corrections.map((c) => c.replace(/^reminder:\s*/i, "")).join("; ")}` : "corrected reply posted");
+        }
+        if (cancelled) {
+            this.postSystem(`${participant.name} was stopped mid-reply; the partial reply stays in the log.`);
+            return null;
+        }
+        if (result.stopReason !== "end_turn") {
+            this.postSystem(`${participant.name} stopped with ${result.stopReason}.`);
+        }
+        this.route(message);
+        return null;
+    }
+    handleSkillPull(participant, runtime, original, name) {
+        const record = {
+            id: randomUUID(),
+            seq: ++this.seq,
+            from: participant.id,
+            fromName: participant.name,
+            to: [],
+            toNames: [],
+            text: `asked for skill "${name}"`,
+            ts: Date.now(),
+            kind: "hidden",
+            details: { original, skill: name, via: "marker" },
+        };
+        const resolved = this.resolveAgentSkill(participant, name);
+        if (!resolved.ok) {
+            record.details = { ...record.details, outcome: `not delivered: ${resolved.reason}` };
+            this.commit(record);
+            runtime.headerNotes.push(`you asked for skill "${name}" but ${resolved.reason}`);
+            runtime.log.info(`skills: pull of "${name}" refused: ${resolved.reason}`);
+            return null;
+        }
+        if (runtime.skillPulledAtSeq === runtime.lastSeenSeq && runtime.skillPulledName === resolved.skill.name) {
+            record.details = { ...record.details, outcome: "not delivered: asked twice on the same messages; treated as silent" };
+            this.commit(record);
+            this.notice(`${participant.name} asked for skill "${name}" twice on the same messages; treated as silent.`, "warn");
+            return null;
+        }
+        runtime.skillPulledAtSeq = runtime.lastSeenSeq;
+        runtime.skillPulledName = resolved.skill.name;
+        runtime.pendingSkills.push({ name: resolved.skill.name, text: renderSkillBody(resolved.skill.body, ""), extraFiles: resolved.skill.extraFiles });
+        runtime.lastSeenSeq = runtime.turnStartSeq;
+        record.details = { ...record.details, outcome: "delivered in a hidden turn" };
+        this.commit(record);
+        runtime.log.info(`skills: "${resolved.skill.name}" pulled with the marker; re-running the turn`);
+        this.requestTurn(participant.id);
+        return null;
+    }
+    closeRetry(retry, outcome) {
+        retry.record.details = { ...(retry.record.details ?? { original: retry.original, corrections: retry.corrections }), outcome };
+        this.push({ type: "message", message: retry.record });
+    }
+    referee(participant, text, mentions) {
+        const corrections = [];
+        const unknown = [];
+        for (const match of text.matchAll(MENTION_PATTERN)) {
+            if (!this.findByName(match[1]) && !unknown.includes(match[1]))
+                unknown.push(match[1]);
+        }
+        if (unknown.length) {
+            const known = [...this.participants.values()].map((p) => p.name).join(", ");
+            corrections.push(`reminder: ${unknown.map((u) => `@${u}`).join(", ")} ${unknown.length > 1 ? "are" : "is"} not in the room; participants are ${known}`);
+        }
+        if (mentions.ids.includes(participant.id)) {
+            corrections.push("reminder: do not address yourself with @");
+        }
+        if (this.settings.maxSentences) {
+            const sentences = countSentences(text);
+            if (sentences > this.settings.maxSentences) {
+                corrections.push(`reminder: keep replies to at most ${this.settings.maxSentences} sentences (last reply had ${sentences})`);
+            }
+        }
+        return corrections;
+    }
+    onSessionUpdate(id, update) {
+        const runtime = this.runtimes.get(id);
+        const participant = this.participants.get(id);
+        if (!runtime || !participant)
+            return;
+        const turn = runtime.turn;
+        switch (update.sessionUpdate) {
+            case "agent_message_chunk": {
+                if (!turn)
+                    return;
+                const u = update;
+                let text = contentText(u.content);
+                const messageId = u.messageId ?? null;
+                if (messageId && !turn.sawMessageId && turn.message.text) {
+                    const notices = (turn.message.notices ??= []);
+                    notices.push(turn.message.text.trim());
+                    turn.message.text = "";
+                    this.push({ type: "message", message: turn.message });
+                }
+                else if (messageId !== turn.messageId && turn.message.text) {
+                    text = "\n\n" + text;
+                }
+                if (messageId)
+                    turn.sawMessageId = true;
+                turn.messageId = messageId;
+                turn.message.text += text;
+                this.push({ type: "chunk", id: turn.message.id, text });
+                return;
+            }
+            case "agent_thought_chunk": {
+                if (!turn)
+                    return;
+                const text = contentText(update.content);
+                turn.message.thought = (turn.message.thought ?? "") + text;
+                this.push({ type: "thought", id: turn.message.id, text });
+                return;
+            }
+            case "tool_call":
+            case "tool_call_update": {
+                if (!turn)
+                    return;
+                const u = update;
+                const calls = (turn.message.toolCalls ??= []);
+                let view = calls.find((c) => c.toolCallId === u.toolCallId);
+                if (!view) {
+                    view = { toolCallId: u.toolCallId, title: u.title ?? u.name ?? "tool call" };
+                    calls.push(view);
+                }
+                if (u.title)
+                    view.title = u.title;
+                if (u.kind !== undefined)
+                    view.kind = u.kind;
+                if (u.status !== undefined)
+                    view.status = u.status;
+                if (u.rawInput !== undefined)
+                    view.rawInput = u.rawInput;
+                this.push({ type: "toolcall", id: turn.message.id, toolCall: view });
+                return;
+            }
+            case "plan": {
+                if (!turn)
+                    return;
+                const entries = update.entries;
+                turn.message.plan = entries;
+                this.push({ type: "plan", id: turn.message.id, entries });
+                return;
+            }
+            case "usage_update": {
+                const u = update;
+                participant.contextUsed = u.used;
+                participant.contextSize = u.size;
+                if (u.cost)
+                    participant.cost = { amount: u.cost.amount, currency: u.cost.currency };
+                if (runtime.lastUsed > 0 && u.used < runtime.lastUsed * 0.7 && !runtime.briefPending) {
+                    runtime.briefPending = `context shrank from ${runtime.lastUsed} to ${u.used} tokens (compaction?)`;
+                    runtime.log.info(`usage dropped ${runtime.lastUsed} -> ${u.used}; brief scheduled`);
+                }
+                runtime.lastUsed = u.used;
+                this.push({ type: "participant", participant });
+                return;
+            }
+            case "config_option_update": {
+                participant.configOptions = update.configOptions;
+                this.applyConfigSummary(participant);
+                this.push({ type: "participant", participant });
+                return;
+            }
+            case "current_mode_update": {
+                participant.mode = update.currentModeId;
+                this.push({ type: "participant", participant });
+                return;
+            }
+            case "available_commands_update":
+            case "session_info_update":
+            case "user_message_chunk":
+                return;
+            default:
+                runtime.log.info(`unhandled session update: ${update.sessionUpdate}`);
+        }
+    }
+    onPermissionRequest(id, params) {
+        const participant = this.participants.get(id);
+        const runtime = this.runtimes.get(id);
+        if (runtime && this.isSkillToolCall(runtime, params)) {
+            const option = params.options.find((o) => o.kind === "allow_always") ?? params.options.find((o) => o.kind === "allow_once");
+            if (option) {
+                runtime.log.info(`skills: ${SKILL_TOOL_NAME} permission auto-approved (${option.optionId})`);
+                return Promise.resolve({ outcome: { outcome: "selected", optionId: option.optionId } });
+            }
+        }
+        return new Promise((resolve) => {
+            const entry = {
+                key: randomUUID(),
+                participantId: id,
+                toolCall: params.toolCall,
+                options: params.options,
+                ts: Date.now(),
+                resolve,
+            };
+            this.permissions.set(entry.key, entry);
+            const { resolve: _r, ...view } = entry;
+            this.push({ type: "permission", permission: view });
+            this.notice(`${participant?.name ?? id} asks for permission: ${params.toolCall.title ?? params.toolCall.toolCallId}`, "info");
+        });
+    }
+    onAgentExit(id, code, signal, agent) {
+        const participant = this.participants.get(id);
+        const runtime = this.runtimes.get(id);
+        if (!participant)
+            return;
+        if (!runtime || runtime.agent !== agent)
+            return;
+        this.cancelPermissionsOf(id);
+        if (this.closing || runtime.retiring) {
+            this.forgetRuntime(id);
+            return;
+        }
+        if (runtime) {
+            runtime.log.warn(`agent process exited (code ${code}, signal ${signal})`);
+            this.forgetRuntime(id);
+        }
+        if (participant.status !== "left") {
+            if (runtime)
+                this.restoredSeen.set(id, runtime.lastSeenSeq);
+            participant.status = "offline";
+            participant.statusDetail = `process exited (code ${code}${signal ? `, signal ${signal}` : ""}); reconnect to continue`;
+            this.push({ type: "participant", participant });
+            this.notice(`${participant.name}: agent process exited.`, "error");
+        }
+    }
+    async openSession(agent, cwd, log, mcpServers = []) {
+        try {
+            return await agent.newSession(cwd, mcpServers);
+        }
+        catch (error) {
+            if (!isAuthRequired(error) || !agent.authMethods.length)
+                throw error;
+            log.info(`session/new needs authentication: ${describeError(error)}`);
+        }
+        const failures = [];
+        for (const method of agent.authMethods) {
+            log.info(`authenticate with "${method.id}"${method.name ? ` (${method.name})` : ""}`);
+            try {
+                await agent.authenticate(method.id);
+                return await agent.newSession(cwd, mcpServers);
+            }
+            catch (error) {
+                failures.push(`${method.id}: ${describeError(error)}`);
+            }
+        }
+        throw new Error(`authentication failed; log in with the agent's own CLI first. ${failures.join("; ")}`);
+    }
+    async applyConfig(runtime, participant, wanted) {
+        const warnings = [];
+        const plan = [
+            ["model", wanted.model],
+            ["thought_level", wanted.effort],
+            ["mode", wanted.mode],
+        ];
+        for (const [category, value] of plan) {
+            if (!value)
+                continue;
+            const option = participant.configOptions?.find((o) => o.category === category);
+            if (!option || option.type !== "select") {
+                if (category === "mode" && participant.modes?.some((m) => m.id === value)) {
+                    try {
+                        await runtime.agent.setMode(runtime.sessionId, value);
+                        participant.mode = value;
+                    }
+                    catch (error) {
+                        warnings.push(`mode: set_mode failed: ${describeError(error)}`);
+                    }
+                    continue;
+                }
+                warnings.push(`${category}: the agent exposes no such config option; left at its default`);
+                continue;
+            }
+            const values = flattenOptions(option.options);
+            if (!values.some((v) => v.value === value)) {
+                warnings.push(`${category}: "${value}" is not offered (${values.map((v) => v.value).join(", ")}); left at ${String(option.currentValue)}`);
+                continue;
+            }
+            if (option.currentValue === value)
+                continue;
+            try {
+                participant.configOptions = await runtime.agent.setConfigOption(runtime.sessionId, option.id, value);
+            }
+            catch (error) {
+                warnings.push(`${category}: set_config_option failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const recipe = participant.agentType ? getRecipe(participant.agentType) : undefined;
+        if (recipe?.bypassConfig && wanted.mode && wanted.mode === recipe.bypassMode) {
+            for (const [optionId, value] of Object.entries(recipe.bypassConfig)) {
+                const option = participant.configOptions?.find((o) => o.id === optionId);
+                if (!option || option.type !== "select" || option.currentValue === value)
+                    continue;
+                if (!flattenOptions(option.options).some((v) => v.value === value))
+                    continue;
+                try {
+                    participant.configOptions = await runtime.agent.setConfigOption(runtime.sessionId, option.id, value);
+                }
+                catch (error) {
+                    warnings.push(`${optionId}: set_config_option failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        this.applyConfigSummary(participant);
+        return warnings;
+    }
+    applyConfigSummary(participant) {
+        const pick = (category) => {
+            const option = participant.configOptions?.find((o) => o.category === category);
+            return option ? String(option.currentValue) : undefined;
+        };
+        participant.model = pick("model") ?? participant.model;
+        participant.effort = pick("thought_level") ?? participant.effort;
+        participant.mode = pick("mode") ?? participant.mode;
+    }
+    failStart(participant, error, fresh) {
+        participant.statusDetail = error instanceof Error ? error.message : String(error);
+        this.notice(`${participant.name}: failed to start: ${participant.statusDetail}`, "error");
+        if (fresh) {
+            participant.status = "error";
+            this.push({ type: "participant", participant });
+            this.participants.delete(participant.id);
+            this.push({ type: "participant.removed", id: participant.id });
+        }
+        else {
+            participant.status = "offline";
+            this.push({ type: "participant", participant });
+        }
+    }
+    cancelPermissionsOf(id) {
+        for (const [key, entry] of this.permissions) {
+            if (entry.participantId !== id)
+                continue;
+            this.permissions.delete(key);
+            entry.resolve({ outcome: { outcome: "cancelled" } });
+            this.push({ type: "permission.resolved", key, optionId: null });
+        }
+    }
+    personaOf(participant) {
+        return { name: participant.name, tagline: participant.tagline ?? "", role: participant.role ?? "" };
+    }
+    roster() {
+        return [...this.participants.values()]
+            .filter((p) => p.status !== "left")
+            .map((p) => ({ name: p.name, kind: p.kind, vendor: p.agentVendor ?? p.agentLabel, tagline: p.tagline || undefined }));
+    }
+    parseMentions(text) {
+        const ids = [];
+        const names = [];
+        for (const match of text.matchAll(MENTION_PATTERN)) {
+            const participant = this.findByName(match[1]);
+            if (participant && !ids.includes(participant.id)) {
+                ids.push(participant.id);
+                names.push(participant.name);
+            }
+        }
+        return { ids, names };
+    }
+    findByName(name) {
+        const lower = name.toLowerCase();
+        for (const p of this.participants.values())
+            if (p.name.toLowerCase() === lower)
+                return p;
+        return undefined;
+    }
+    postSystem(text, audience) {
+        const message = {
+            id: randomUUID(),
+            seq: ++this.seq,
+            from: "system",
+            fromName: "",
+            to: [],
+            toNames: [],
+            text,
+            ts: Date.now(),
+            kind: "system",
+        };
+        if (audience)
+            message.audience = audience;
+        this.commit(message);
+    }
+    async setDir(dir) {
+        const next = resolve(String(dir ?? "").trim());
+        if (!dir.trim())
+            throw new Error("working directory is required");
+        if (!existsSync(next) || !statSync(next).isDirectory())
+            throw new Error(`working directory does not exist: ${next}`);
+        if (next === this.dir)
+            return { dir: next, restarted: [] };
+        const previous = this.dir;
+        this.dir = next;
+        const restarted = [];
+        for (const id of [...this.runtimes.keys()]) {
+            const p = this.participants.get(id);
+            if (!p)
+                continue;
+            await this.retireRuntime(id);
+            try {
+                await this.reconnect(id, { mode: "replay", reason: "the room moved to another folder" });
+                restarted.push(p.name);
+            }
+            catch (error) {
+                this.notice(`${p.name} could not be restarted in the new folder: ${describeError(error)}`, "error");
+            }
+        }
+        for (const p of this.participants.values()) {
+            if (p.kind === "agent" && !this.runtimes.has(p.id))
+                p.sessionId = undefined;
+        }
+        this.push(this.roomEvent());
+        this.postSystem(`The room moved to ${next}${restarted.length ? `; ${restarted.join(", ")} restarted there` : ""}.`);
+        this.log.info(`working directory: ${previous} -> ${next}`);
+        return { dir: next, restarted };
+    }
+    roomEvent() {
+        return {
+            type: "room",
+            hopLimit: this.hopLimit,
+            hops: this.hops,
+            settings: this.settings,
+            customRulesText: this.renderRuleReferences(this.settings.customRules),
+            focused: this.focused,
+            name: this.name,
+            dir: this.dir,
+        };
+    }
+    notice(text, level) {
+        if (level === "error")
+            this.log.error(text);
+        else if (level === "warn")
+            this.log.warn(text);
+        else
+            this.log.info(text);
+        this.push({ type: "notice", text, level, ts: Date.now() });
+    }
+    push(event) {
+        this.emit("event", event);
+    }
+}
+function isAuthRequired(error) {
+    if (error instanceof RemoteError)
+        return error.rpc.code === -32000 || /auth/i.test(error.rpc.message);
+    return error instanceof Error && /auth/i.test(error.message);
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function contentText(block) {
+    if (block.type === "text")
+        return block.text;
+    return `[${block.type}]`;
+}
+function flattenOptions(options) {
+    if (!options)
+        return [];
+    const out = [];
+    for (const entry of options) {
+        if ("options" in entry)
+            out.push(...entry.options);
+        else
+            out.push(entry);
+    }
+    return out;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeSkillList(list) {
+    if (!list)
+        return undefined;
+    const out = [];
+    for (const raw of list) {
+        const name = String(raw).trim();
+        if (!SKILL_NAME_PATTERN.test(name))
+            continue;
+        if (!out.some((s) => s.toLowerCase() === name.toLowerCase()))
+            out.push(name);
+    }
+    return out.length ? out : undefined;
+}
+function shuffle(items) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}