viberoom 0.5.8 → 0.6.0

package/dist/persona.js

@@ -9,40 +9,107 @@ export function skillPull(reply) {
     return match && match[0] === reply.trim() ? match[1] : null;
 }
 export const SKILL_WRITER_NAME = "skill-writer";
-export const DEFAULT_ROOM_SETTINGS = {
-    topic: "",
-    humanDescription: "",
-    language: { mode: "follow-human" },
-    tools: "on-request",
-    maxSentences: null,
-    hopLimit: 100,
-    fullBriefEveryTurns: 8,
-    fullBriefEveryTokens: 20_000,
-    headerRules: true,
-    replayAfterRestart: 10,
-    backlogCap: 50,
-    showVendorInRoster: false,
-    customRules: "",
-    emoji: "",
-    humanDescriptionMode: "inherit",
-    refereeAction: "next-header",
-    turnTaking: "parallel",
-    replyDelay: 4,
-    waitWhileHumanTypes: true,
-    agentsWakeEachOther: true,
+export const ROOM_DESIGNER_NAME = "room-designer";
+export const NAME_PATTERN = /^[\p{L}\p{N}][\p{L}\p{N}_-]{0,23}$/u;
+export const ROOM_SETTINGS_SPEC = {
+    name: { kind: "own-path", brief: true, agent: false, doc: "The room's name; changed with rename." },
+    humanName: { kind: "own-path", brief: true, agent: false, doc: "The human's name; a program-level setting." },
+    topic: { kind: "text", max: 2000, default: "", brief: true, agent: true, doc: "One line about what the room is for; the brief repeats it to every vibemate." },
+    emoji: { kind: "text", max: 8, default: "", brief: false, agent: true, doc: "The room's emoji, shown in its title and tile." },
+    humanDescription: { kind: "text", max: 200, default: "", brief: true, agent: false, doc: "This room's description of the human, composed with the program-level one by humanDescriptionMode." },
+    humanDescriptionMode: { kind: "enum", values: ["inherit", "override", "append", "none"], default: "inherit", brief: true, agent: false, doc: "How the human's description is composed: the program-level text, this room's, both, or nothing." },
+    language: { kind: "language", default: { mode: "follow-human" }, brief: true, agent: true, doc: "follow-human: reply in the language of the human's latest message; or a fixed language name." },
+    tools: { kind: "enum", values: ["on-request", "never"], default: "on-request", brief: true, agent: true, doc: "on-request: tools only when a participant explicitly asks for something that needs them; never: a talk-only room." },
+    maxSentences: { kind: "integer-or-null", min: 1, max: 100, default: null, brief: true, agent: true, doc: "A hard length rule for every reply, in sentences; empty for no rule." },
+    hopLimit: { kind: "integer", min: 0, max: 10_000, default: 100, brief: false, agent: true, doc: "Agent-to-agent turns allowed before the hub waits for the human; a chain of three vibemates needs about three times its length." },
+    fullBriefEveryTurns: { kind: "integer", min: 1, max: 10_000, default: 8, brief: false, agent: true, doc: "The full brief is re-sent to a vibemate after this many of its turns." },
+    fullBriefEveryTokens: { kind: "integer", min: 1000, max: 10_000_000, default: 20_000, brief: false, agent: true, doc: "The full brief is re-sent once a vibemate's context grew by this many tokens." },
+    headerRules: { kind: "boolean", default: true, brief: false, agent: true, doc: "The per-turn header repeats the three core rules (addressing, silent, character)." },
+    replayAfterRestart: { kind: "integer", min: 0, max: 200, default: 10, brief: false, agent: true, doc: "Messages replayed to a vibemate whose session restarts." },
+    backlogCap: { kind: "integer", min: 1, max: 1000, default: 50, brief: false, agent: true, doc: "Most missed messages a vibemate reads on its next turn; older ones are dropped with a note." },
+    showVendorInRoster: { kind: "boolean", default: false, brief: true, agent: true, doc: "The roster in the brief names each vibemate's vendor (Claude, Codex, ...)." },
+    customRules: { kind: "text", max: 4000, default: "", brief: true, agent: true, doc: "The room rules, one per line; every vibemate gets them under 'Room rules (set by the human)'. @Name inside a rule is a live reference." },
+    refereeAction: { kind: "enum", values: ["next-header", "retry-hidden"], default: "next-header", brief: false, agent: true, doc: "On a mechanical violation (wrong language, too long): remind in the next header, or hold the reply and ask for a corrected one in a hidden turn." },
+    turnTaking: { kind: "enum", values: ["parallel", "one-at-a-time"], default: "parallel", brief: false, agent: true, doc: "parallel: every addressed vibemate answers at once; one-at-a-time: one speaks, the others queue and see the earlier replies first." },
+    waitWhileHumanTypes: { kind: "boolean", default: true, brief: false, agent: true, doc: "A vibemate about to start a turn waits while the human is typing." },
+    agentsWakeEachOther: { kind: "boolean", default: true, brief: true, agent: true, doc: "A vibemate's message without @ wakes the others, as the human's does; off: only @Name wakes a vibemate." },
+    replyDelay: { kind: "number", min: 0, max: 120, default: 4, brief: false, agent: true, doc: "Seconds (a random 0..N) every vibemate waits before a turn, so replies cross less; a vibemate's own delay overrides it." },
 };
-export const BRIEF_AFFECTING_SETTINGS = [
-    "topic",
-    "humanDescription",
-    "humanDescriptionMode",
-    "language",
-    "tools",
-    "maxSentences",
-    "showVendorInRoster",
-    "customRules",
-    "agentsWakeEachOther",
-];
+function defaultsFromSpec() {
+    const out = {};
+    for (const [key, spec] of Object.entries(ROOM_SETTINGS_SPEC))
+        if (spec.kind !== "own-path")
+            out[key] = spec.default;
+    return out;
+}
+export const DEFAULT_ROOM_SETTINGS = defaultsFromSpec();
+export const BRIEF_AFFECTING_SETTINGS = Object.keys(ROOM_SETTINGS_SPEC).filter((key) => ROOM_SETTINGS_SPEC[key].brief);
+export const AGENT_SETTINGS = Object.keys(ROOM_SETTINGS_SPEC).filter((key) => ROOM_SETTINGS_SPEC[key].agent);
+export function coerceSetting(key, raw) {
+    const spec = ROOM_SETTINGS_SPEC[key];
+    switch (spec.kind) {
+        case "own-path":
+            throw new Error(`${key} is not a settings field`);
+        case "integer": {
+            const value = Number(raw);
+            if (!Number.isInteger(value) || value < spec.min || value > spec.max)
+                throw new Error(`${key} must be an integer between ${spec.min} and ${spec.max}`);
+            return value;
+        }
+        case "integer-or-null": {
+            const value = raw === null || raw === "" ? null : Number(raw);
+            if (value !== null && (!Number.isInteger(value) || value < spec.min || value > spec.max))
+                throw new Error(`${key} must be ${spec.min}-${spec.max} or empty`);
+            return value;
+        }
+        case "number": {
+            const value = Number(raw);
+            if (!Number.isFinite(value) || value < spec.min || value > spec.max)
+                throw new Error(`${key} must be between ${spec.min} and ${spec.max} seconds`);
+            return value;
+        }
+        case "boolean":
+            return (raw === true || raw === "true");
+        case "enum": {
+            const value = String(raw);
+            if (!spec.values.includes(value))
+                throw new Error(`${key} must be ${spec.values.join(" or ")}`);
+            return value;
+        }
+        case "text":
+            return String(raw).slice(0, spec.max);
+        case "language": {
+            if (raw && typeof raw === "object") {
+                const o = raw;
+                if (o.mode === "fixed" && typeof o.language === "string" && o.language.trim())
+                    return { mode: "fixed", language: o.language.trim() };
+                return { mode: "follow-human" };
+            }
+            const text = String(raw ?? "").trim();
+            return (!text || text === "follow-human" ? { mode: "follow-human" } : { mode: "fixed", language: text });
+        }
+    }
+}
+export function describeSettings(current) {
+    return AGENT_SETTINGS.map((key) => {
+        const spec = ROOM_SETTINGS_SPEC[key];
+        const range = spec.kind === "integer" || spec.kind === "number"
+            ? `${spec.min}..${spec.max}`
+            : spec.kind === "integer-or-null"
+                ? `${spec.min}..${spec.max} or null`
+                : spec.kind === "enum"
+                    ? spec.values.join(" | ")
+                    : spec.kind === "text"
+                        ? `up to ${spec.max} characters`
+                        : spec.kind === "language"
+                            ? '"follow-human" or a language name'
+                            : undefined;
+        return { key, doc: spec.doc, kind: spec.kind, range, default: spec.kind === "own-path" ? undefined : spec.default, value: current[key], affectsBrief: spec.brief };
+    });
+}
 export const IMAGE_MARKER_PATTERN = /\[img\s+(\d+)\]/gi;
+export const QUOTE_MARKER_PATTERN = /\[quote\s+(\d+)\]/gi;
+const MARKER_PATTERN = /\[(img|quote)\s+(\d+)\]/gi;
 export function promptText(parts) {
     return parts.map((p) => (p.type === "text" ? p.text : "")).join("");
 }
@@ -52,6 +119,18 @@ function imageMarker(image) {
     const who = image.forNames.length ? ` · for ${image.forNames.join(", ")}` : "";
     return `[img ${image.n} · ${image.ref}${who} · ${image.path}]`;
 }
+export function formatQuoteTime(ts) {
+    const d = new Date(ts);
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+export function quoteBlock(quote) {
+    const head = `> ${quote.fromName} (#${quote.seq}, ${formatQuoteTime(quote.ts)}):`;
+    const lines = quote.text.split(/\r?\n/);
+    if (lines.length === 1)
+        return `${head} ${lines[0]}`;
+    return [head, ...lines.map((l) => `> ${l}`)].join("\n");
+}
 function messageParts(line) {
     const parts = [];
     let text = "";
@@ -60,32 +139,70 @@ function messageParts(line) {
             parts.push({ type: "text", text });
         text = "";
     };
-    const place = (image) => {
-        text += imageMarker(image);
+    const images = line.images ?? [];
+    const quotes = line.quotes ?? [];
+    const placedImages = new Set();
+    const placedQuotes = new Set();
+    let breakAfterQuote = false;
+    const append = (s) => {
+        if (!s)
+            return;
+        if (breakAfterQuote) {
+            if (!s.startsWith("\n"))
+                text += "\n";
+            s = s.replace(/^[ \t]+/, "");
+            breakAfterQuote = false;
+        }
+        text += s;
+    };
+    const placeImage = (image) => {
+        append(imageMarker(image));
         if (image.attached) {
             flush();
             parts.push({ type: "image", image });
         }
     };
-    const images = line.images ?? [];
-    const placed = new Set();
+    const placeQuote = (quote) => {
+        if (breakAfterQuote)
+            text += "\n";
+        text = text.replace(/[ \t]+$/, "");
+        if (text && !text.endsWith("\n"))
+            text += "\n";
+        text += quoteBlock(quote);
+        breakAfterQuote = true;
+    };
     let last = 0;
-    for (const match of line.text.matchAll(IMAGE_MARKER_PATTERN)) {
-        const image = images.find((i) => i.n === Number(match[1]));
-        if (!image || placed.has(image.n))
-            continue;
-        placed.add(image.n);
-        text += line.text.slice(last, match.index);
-        place(image);
+    for (const match of line.text.matchAll(MARKER_PATTERN)) {
+        const n = Number(match[2]);
+        if (match[1].toLowerCase() === "img") {
+            const image = images.find((i) => i.n === n);
+            if (!image || placedImages.has(n))
+                continue;
+            placedImages.add(n);
+            append(line.text.slice(last, match.index));
+            placeImage(image);
+        }
+        else {
+            const quote = quotes.find((q) => q.n === n);
+            if (!quote || placedQuotes.has(n))
+                continue;
+            placedQuotes.add(n);
+            append(line.text.slice(last, match.index));
+            placeQuote(quote);
+        }
         last = (match.index ?? 0) + match[0].length;
     }
-    text += line.text.slice(last);
+    append(line.text.slice(last));
+    for (const quote of quotes)
+        if (!placedQuotes.has(quote.n))
+            placeQuote(quote);
+    breakAfterQuote = false;
     for (const image of images) {
-        if (placed.has(image.n))
+        if (placedImages.has(image.n))
             continue;
         if (!text.endsWith("\n") && (text || parts.length))
             text += "\n";
-        place(image);
+        placeImage(image);
     }
     flush();
     return parts;
@@ -129,6 +246,7 @@ function skillsSection(skills) {
     }
     if (skills.canCreate) {
         lines.push(`You may also create skills for the shared library when a procedure is worth reusing (by you later, or by other agents): first load the built-in skill "${SKILL_WRITER_NAME}" with the viberoom ${SKILL_TOOL_NAME} tool for the rules of a good skill, then call the viberoom tools create_skill (name, description, instructions) and attach_skill to give it to yourself or to other agents. These are MCP tools of the "viberoom" server, not your own skill commands. The human sees every new skill in Settings.`);
+        lines.push(`You may also design rooms: load the built-in skill "${ROOM_DESIGNER_NAME}" first, then describe_room for the facts, lint_room_design to check a draft (it previews the brief the vibemates would read), create_template to save a template the human can pick under New room, and propose_room_changes to suggest a change to this room: it becomes a card the human applies or rejects, so nothing here changes without their click.`);
     }
     else if (skills.items.length) {
         lines.push("Skills are created by the human or by agents that have the hub's tools; if you want a new one, describe it in the room.");
@@ -181,6 +299,9 @@ export function buildBrief(settings, persona, roster, previousNotes, skills) {
         lines.push(...skillsSection(skills));
     lines.push("");
     lines.push(`How prompts look: <room-header> (who you are, who is here, the hop counter, hub notes), then <messages> (everything posted since your previous turn, oldest first, as "Name -> @Target: text"; room events as "· text"), then "Reply as ${persona.name}." Your own earlier messages are not repeated. Reply with the text of your message only.`);
+    lines.push(`A line "> Name (#N, date time): …" inside a message quotes an earlier message of this room, pasted by the writer: those are Name's words, not the writer's, and #N is the hub's number of that message. ${skills?.channel === "tool"
+        ? "When the fragment is not enough, the viberoom tool read_message takes the number and returns the whole message (around: N adds its neighbours)."
+        : "When the fragment is not enough, ask in the room for the whole message."}`);
     if (previousNotes && previousNotes.trim()) {
         lines.push("");
         lines.push(`Notes from your previous session (written by you): ${previousNotes.trim()}`);

package/dist/quotes.js

@@ -0,0 +1,41 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+export const QUOTES_PER_MESSAGE = 6;
+export const QUOTE_MAX_CHARS = 4000;
+export const READ_AROUND_MAX = 5;
+export function resolveQuotes(inputs, messages) {
+    const out = [];
+    const used = new Set();
+    let next = 1;
+    for (const input of inputs.slice(0, QUOTES_PER_MESSAGE)) {
+        const seq = Number(input?.seq);
+        const source = Number.isInteger(seq) ? messages.find((m) => m.seq === seq) : undefined;
+        if (!source)
+            throw new Error(`quoted message #${String(input?.seq)} is not in this room`);
+        if (source.kind !== "chat")
+            throw new Error(`message #${seq} is not a chat message; only those can be quoted`);
+        const text = String(input.text ?? "").trim().slice(0, QUOTE_MAX_CHARS) || source.text.trim().slice(0, QUOTE_MAX_CHARS);
+        if (!text)
+            throw new Error(`message #${seq} has no text to quote`);
+        const wanted = Number(input.n);
+        let n = Number.isInteger(wanted) && wanted > 0 && !used.has(wanted) ? wanted : 0;
+        if (!n) {
+            while (used.has(next))
+                next += 1;
+            n = next;
+        }
+        used.add(n);
+        out.push({ n, seq, from: source.from, fromName: source.fromName, ts: source.ts, text });
+    }
+    return out;
+}
+export function visibleToAgents(message) {
+    return message.kind !== "hidden" && message.audience !== "human";
+}
+export function agentReadableWindow(messages, seq, around) {
+    const visible = messages.filter(visibleToAgents);
+    const index = visible.findIndex((m) => m.seq === seq);
+    if (index < 0)
+        return null;
+    const span = Math.min(READ_AROUND_MAX, Math.max(0, Math.floor(Number(around) || 0)));
+    return { message: visible[index], before: visible.slice(Math.max(0, index - span), index), after: visible.slice(index + 1, index + 1 + span) };
+}

package/dist/recipes.js

@@ -5,6 +5,7 @@ import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { loginState } from "./agent-health.js";
 const isWindows = process.platform === "win32";
 function resolvePackageEntry(packageName, relativeEntry) {
     try {
@@ -167,6 +168,9 @@ const recipes = [
         unavailableReason: claudeExe ? null : "Claude Code not found",
         installedAt: claudeExe,
         installHint: "install Claude Code (npm install -g @anthropic-ai/claude-code, or the native installer) and log in with `claude`",
+        loginCommand: "claude",
+        login: { env: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN"], files: [".claude/.credentials.json"], command: "claude", fileless: ["darwin"] },
+        loginState: "unknown",
         build: ({ model }) => ({
             command: process.execPath,
             args: [claudeAdapter],
@@ -190,6 +194,9 @@ const recipes = [
         unavailableReason: codexExe ? null : "Codex CLI not found",
         installedAt: codexExe,
         installHint: "install Codex (npm install -g @openai/codex) and log in with `codex login`",
+        loginCommand: "codex login",
+        login: { env: ["CODEX_API_KEY", "OPENAI_API_KEY"], files: [".codex/auth.json"], command: "codex login" },
+        loginState: "unknown",
         build: () => ({
             command: process.execPath,
             args: [codexAdapter],
@@ -213,6 +220,9 @@ const recipes = [
         unavailableReason: geminiEntry ? null : "Gemini CLI not found",
         installedAt: geminiEntry,
         installHint: "npm install -g @google/gemini-cli, then sign in once (gemini)",
+        loginCommand: "gemini",
+        login: { env: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_APPLICATION_CREDENTIALS"], files: [".gemini/google_accounts.json", ".gemini/oauth_creds.json"], command: "gemini" },
+        loginState: "unknown",
         modelAtLaunch: true,
         build: ({ model }) => ({
             command: process.execPath,
@@ -237,6 +247,9 @@ const recipes = [
         unavailableReason: cursorAgent ? null : "Cursor CLI not found",
         installedAt: cursorAgent?.index ?? null,
         installHint: "install cursor-agent (cursor.com/cli), then agent login",
+        loginCommand: "cursor-agent login",
+        login: { env: ["CURSOR_API_KEY"], files: [], command: "cursor-agent login" },
+        loginState: "unknown",
         build: () => ({
             command: cursorAgent?.node ?? "",
             args: [cursorAgent?.index ?? "", "acp"],
@@ -260,6 +273,9 @@ const recipes = [
         unavailableReason: openCodeExe ? null : "OpenCode not found",
         installedAt: openCodeExe,
         installHint: "npm install -g opencode-ai (or curl -fsSL https://opencode.ai/install | bash), then opencode providers",
+        loginCommand: "opencode auth login",
+        login: { env: [], files: [".local/share/opencode/auth.json", "AppData/Local/opencode/auth.json", ".config/opencode/auth.json"], command: "opencode auth login" },
+        loginState: "unknown",
         build: () => ({
             command: openCodeExe ?? "",
             args: ["acp"],
@@ -286,6 +302,9 @@ const recipes = [
         unavailableReason: copilotExe ? null : "GitHub Copilot CLI not found",
         installedAt: copilotExe,
         installHint: "winget install GitHub.Copilot / brew install copilot-cli / npm install -g @github/copilot, then copilot login",
+        loginCommand: "copilot",
+        login: { env: ["GITHUB_TOKEN", "GH_TOKEN", "COPILOT_API_KEY"], files: [], command: "copilot" },
+        loginState: "unknown",
         modelAtLaunch: true,
         build: ({ model }) => ({
             command: copilotExe ?? "",
@@ -311,13 +330,21 @@ if (fakeAgent) {
         unavailableReason: null,
         installedAt: fakeAgent,
         installHint: "",
+        loginCommand: "",
+        loginState: "ok",
         bypassMode: null,
         build: () => ({ command: process.execPath, args: [fakeAgent], env: {} }),
     });
 }
+function loginEvidence() {
+    return { env: process.env, platform: process.platform, exists: (relative) => existsSync(join(homedir(), ...relative.split("/"))) };
+}
 export function listRecipes() {
+    const evidence = loginEvidence();
+    for (const recipe of recipes)
+        recipe.loginState = recipe.unavailableReason ? "unknown" : loginState(recipe.login, evidence);
     return recipes;
 }
 export function getRecipe(id) {
-    return recipes.find((r) => r.id === id);
+    return listRecipes().find((r) => r.id === id);
 }

package/dist/room-design.js

@@ -0,0 +1,205 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { AGENT_SETTINGS, DEFAULT_ROOM_SETTINGS, NAME_PATTERN, ROOM_SETTINGS_SPEC, SILENT_MARKER, REQUEST_BRIEF_MARKER, buildBrief, coerceSetting } from "./persona.js";
+export const TAGLINE_MAX = 80;
+export const ROLE_MAX = 4000;
+export const AVATAR_MAX = 8;
+export const RULES_SOFT_MAX = 12;
+export const ROLE_SOFT_MAX = 1200;
+export const RULES_NEAR_LIMIT = 3000;
+export function ruleLines(customRules) {
+    return customRules
+        .split(/\r?\n/)
+        .map((l) => l.trim().replace(/^[-*•]\s*/, ""))
+        .filter((l) => l.length > 0);
+}
+export const BRIEF_MECHANICS = [
+    { pattern: /\[silent\]/i, what: `the ${SILENT_MARKER} reply` },
+    { pattern: /\[request-brief\]/i, what: `the ${REQUEST_BRIEF_MARKER} reply` },
+    { pattern: /\bmarkdown\b|\bmermaid\b/i, what: "the Markdown / mermaid format" },
+    { pattern: /\buse @\w*\s*to address\b|\baddress .{0,20}with @/i, what: "how @Name addressing works" },
+    { pattern: /\bstay in character\b/i, what: "staying in character" },
+];
+export function lintRoomDesign(design, context) {
+    const errors = [];
+    const warnings = [];
+    const error = (code, message) => errors.push({ code, message });
+    const warn = (code, message) => warnings.push({ code, message });
+    const base = context.base ?? { ...DEFAULT_ROOM_SETTINGS, name: (design.name ?? context.roomName ?? "Room").trim() || "Room", humanName: context.humanName };
+    const settings = { ...base };
+    const raw = design.settings ?? {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value === undefined)
+            continue;
+        if (!(key in ROOM_SETTINGS_SPEC)) {
+            error("unknown-setting", `unknown setting "${key}" (known: ${AGENT_SETTINGS.join(", ")})`);
+            continue;
+        }
+        const k = key;
+        if (!AGENT_SETTINGS.includes(k)) {
+            error("setting-not-yours", `"${key}" is set by the human, not through a design`);
+            continue;
+        }
+        try {
+            settings[k] = coerceSetting(k, value);
+        }
+        catch (e) {
+            error("invalid-setting", e instanceof Error ? e.message : String(e));
+        }
+    }
+    if (design.emoji !== undefined && !settings.emoji)
+        settings.emoji = String(design.emoji).trim().slice(0, AVATAR_MAX);
+    const vibemates = design.vibemates ?? [];
+    if (context.kind === "template") {
+        if (!(design.name ?? "").trim())
+            error("template-no-name", "a template needs a name");
+        if (!(design.description ?? "").trim())
+            warn("template-no-description", "a template without a description is a blank card in the picker: say what the room is for and how it feels");
+        if (!vibemates.length)
+            error("template-no-vibemates", "a template needs at least one vibemate");
+    }
+    const seen = new Map();
+    const touched = context.changedVibemates ? new Set(context.changedVibemates.map((n) => n.trim().toLowerCase())) : null;
+    for (const [i, v] of vibemates.entries()) {
+        const who = v?.name?.trim() ? `"${v.name.trim()}"` : `vibemate ${i + 1}`;
+        const name = (v?.name ?? "").trim();
+        const soft = !touched || touched.has(name.toLowerCase());
+        if (!name)
+            error("vibemate-no-name", `${who} has no name`);
+        else if (!NAME_PATTERN.test(name))
+            error("vibemate-bad-name", `${who}: a name is 1-24 letters, digits, _ or -, no spaces`);
+        else {
+            const lower = name.toLowerCase();
+            if (seen.has(lower))
+                error("vibemate-duplicate-name", `two vibemates are named ${who}`);
+            seen.set(lower, i);
+            if (lower === context.humanName.trim().toLowerCase())
+                error("vibemate-human-name", `${who} is the human's name`);
+        }
+        if ((v?.tagline ?? "").length > TAGLINE_MAX)
+            error("tagline-too-long", `${who}: the tagline is at most ${TAGLINE_MAX} characters (it is the one line the others see)`);
+        else if (soft && !(v?.tagline ?? "").trim())
+            warn("vibemate-no-tagline", `${who} has no tagline: the others read it in the roster to know what this one leans to`);
+        if ((v?.role ?? "").length > ROLE_MAX)
+            error("role-too-long", `${who}: the role is at most ${ROLE_MAX} characters`);
+        else if (soft && !(v?.role ?? "").trim())
+            warn("vibemate-no-role", `${who} has no role: without one it is the agent's default self, not a character`);
+        else if (soft && (v.role ?? "").length > ROLE_SOFT_MAX)
+            warn("role-restates-rules", `${who}: a role of ${v.role.length} characters is probably restating the protocol; a role says who this one is and which way it leans, the rules say how they work together`);
+        if ((v?.avatar ?? "").length > AVATAR_MAX)
+            error("avatar-too-long", `${who}: the avatar is one emoji`);
+        if (context.knownSkills) {
+            for (const skill of v?.skills ?? [])
+                if (!context.knownSkills.includes(skill))
+                    error("unknown-skill", `${who}: no skill named "${skill}" in the library`);
+        }
+        if (context.kind === "template" && (v?.agentType || v?.model))
+            warn("vendor-pinned", `${who} names an agent or model: a template cannot know what this machine has, so they are suggestions at best; leave them out unless the design depends on a capability tier`);
+    }
+    const initials = new Map();
+    for (const v of vibemates) {
+        const name = (v?.name ?? "").trim();
+        if (!name)
+            continue;
+        const initial = name[0].toLowerCase();
+        initials.set(initial, [...(initials.get(initial) ?? []), name]);
+    }
+    for (const names of initials.values())
+        if (names.length > 1)
+            warn("names-share-initial", `${names.join(" and ")} start with the same letter: @-autocomplete and the human's eye tell them apart slower`);
+    const rules = ruleLines(settings.customRules);
+    if (rules.length > RULES_SOFT_MAX)
+        warn("too-many-rules", `${rules.length} rules: every vibemate carries them on every turn; ${RULES_SOFT_MAX} is a full protocol, longer belongs in a skill`);
+    if (settings.customRules.length > RULES_NEAR_LIMIT)
+        warn("rules-near-limit", `the rules are ${settings.customRules.length} characters; the hub stores at most 4000`);
+    for (const rule of rules) {
+        for (const m of BRIEF_MECHANICS)
+            if (m.pattern.test(rule))
+                warn("rule-repeats-brief", `the brief already explains ${m.what}; the rule "${rule.slice(0, 60)}${rule.length > 60 ? "…" : ""}" repeats it`);
+    }
+    if (vibemates.length >= 2 && !rules.length)
+        warn("no-rules", "two or more vibemates and no rules: name the situations this room will meet and answer them, for example who takes a task that names nobody, and when one of them stays quiet");
+    if (vibemates.length >= 2 && settings.agentsWakeEachOther && settings.hopLimit < 3 * vibemates.length)
+        warn("hop-limit-low", `hopLimit ${settings.hopLimit} with ${vibemates.length} vibemates who wake each other: one exchange around the room already uses ${vibemates.length}; about ${3 * vibemates.length} or more lets a handoff finish`);
+    if (errors.length)
+        return { errors, warnings };
+    const first = vibemates[0];
+    const persona = first ? { name: first.name.trim(), tagline: (first.tagline ?? "").trim(), role: (first.role ?? "").trim() } : { name: "Vibemate", tagline: "", role: "" };
+    const roster = [{ name: context.humanName, kind: "human" }, ...vibemates.map((v) => ({ name: v.name.trim(), kind: "agent", tagline: (v.tagline ?? "").trim() || undefined }))];
+    const skills = context.skills && {
+        items: (first?.skills ?? []).map((name) => context.skills.library.find((s) => s.name === name)).filter((s) => !!s),
+        channel: context.skills.channel,
+        canCreate: context.skills.canCreate,
+    };
+    return { errors, warnings, settings, preview: buildBrief(settings, persona, roster, undefined, skills) };
+}
+export function applyVibemateChanges(current, changes) {
+    const next = current.map((v) => ({ ...v }));
+    const ops = [];
+    const errors = [];
+    const find = (name) => next.findIndex((v) => v.name.toLowerCase() === name.trim().toLowerCase());
+    for (const name of changes?.remove ?? []) {
+        const i = find(String(name));
+        if (i < 0)
+            errors.push(`no vibemate named "${name}" to remove`);
+        else {
+            ops.push({ op: "remove", name: next[i].name });
+            next.splice(i, 1);
+        }
+    }
+    for (const u of changes?.update ?? []) {
+        const i = find(String(u?.name ?? ""));
+        if (i < 0) {
+            errors.push(`no vibemate named "${u?.name}" to update`);
+            continue;
+        }
+        const before = next[i];
+        const after = { ...before };
+        const fields = [];
+        const set = (field, value) => {
+            if (value === undefined)
+                return;
+            const from = before[field];
+            const fromText = Array.isArray(from) ? from.join(", ") : String(from ?? "");
+            const toText = Array.isArray(value) ? value.join(", ") : String(value ?? "");
+            if (fromText === toText)
+                return;
+            after[field] = value;
+            fields.push({ field, from: fromText, to: toText });
+        };
+        if (u.newName !== undefined)
+            set("name", String(u.newName).trim());
+        set("tagline", u.tagline);
+        set("role", u.role);
+        set("avatar", u.avatar);
+        set("skills", u.skills);
+        set("replyDelay", u.replyDelay);
+        if (fields.length) {
+            next[i] = after;
+            ops.push({ op: "update", name: before.name, fields });
+        }
+    }
+    for (const a of changes?.add ?? []) {
+        const v = { name: String(a?.name ?? "").trim() };
+        if (a?.tagline)
+            v.tagline = a.tagline;
+        if (a?.role)
+            v.role = a.role;
+        if (a?.avatar)
+            v.avatar = a.avatar;
+        if (a?.skills)
+            v.skills = a.skills;
+        if (typeof a?.replyDelay === "number")
+            v.replyDelay = a.replyDelay;
+        next.push(v);
+        ops.push({ op: "add", name: v.name });
+    }
+    return { next, ops, errors };
+}
+export function diffSettings(current, next) {
+    const out = [];
+    for (const key of AGENT_SETTINGS) {
+        if (JSON.stringify(current[key]) !== JSON.stringify(next[key]))
+            out.push({ key, from: current[key], to: next[key] });
+    }
+    return out;
+}