viberoom 0.5.7 → 0.5.9

package/README.md

@@ -14,7 +14,7 @@ Open a room, summon the agents you already have, give each one a role, and let t
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/todor-rusev/viberoom/main/docs/screenshots/conversation.png" width="960" alt="A Wren & Quinn room: Wren explains a git command from a screenshot, Quinn adds the part that changes whose problem it is">
+  <img src="https://raw.githubusercontent.com/todor-rusev/viberoom/main/docs/screenshots/conversation.png" width="960" alt="A room with two vibemates: one explains a git command from a screenshot, the other adds the part that changes whose problem it is">
 </p>
 
 <p align="center">
@@ -80,6 +80,16 @@ library marks it as theirs until you have read it.
 
 <br>
 
+## Let them design the room
+
+A vibemate can design a room as well as work in it. It has a built-in skill on what makes rules and
+roles good, and four hub tools: read the room's settings and rules, check a design and preview the
+brief the others would receive, save a template for you to pick under New room, or propose a change to
+the room you are in. A proposal is a card in the chat with the diff; nothing changes until you click
+Apply, and the room is told what you decided.
+
+<br>
+
 ## Talk to all, or to one
 
 <p align="center">
@@ -167,6 +177,14 @@ skills and the log.
 
 <br>
 
+## Questions, ideas, bugs
+
+- A question ("how do I ...?") goes to [Discussions → Q&A](https://github.com/todor-rusev/viberoom/discussions/categories/q-a).
+- An idea goes to [Discussions → Ideas](https://github.com/todor-rusev/viberoom/discussions/categories/ideas).
+- A bug goes to [Issues](https://github.com/todor-rusev/viberoom/issues/new/choose); the form asks for what a fix needs.
+
+<br>
+
 ## Development
 
 ```sh

package/dist/context.js

@@ -25,6 +25,12 @@ export function crossedThreshold(previousUsed, used, size, threshold = NOTES_THR
         return false;
     return used / size >= threshold && previousUsed / size < threshold;
 }
+export function emptyUsageReport(previousUsed, used) {
+    return previousUsed > 0 && used === 0;
+}
+export function looksCompacted(previousUsed, used) {
+    return previousUsed > 0 && used > 0 && used < previousUsed * 0.7;
+}
 export function overThreshold(used, size, threshold = NOTES_THRESHOLD) {
     return size > 0 && used / size >= threshold;
 }

package/dist/hub.js

@@ -10,7 +10,7 @@ import { listRecipes } from "./recipes.js";
 import { DEFAULT_ROOM_SETTINGS } from "./persona.js";
 import { Room } from "./room.js";
 import { SkillLibrary } from "./skills.js";
-import { TemplateLibrary } from "./templates.js";
+import { TemplateLibrary, roomSettingsFromTemplate } from "./templates.js";
 export const TEXT_FONTS = ["nunito", "inter", "noto-sans", "arial", "system"];
 export const MONO_FONTS = ["jetbrains-mono", "fira-code", "source-code-pro", "system"];
 export const DEFAULT_APPEARANCE = { chatFontSize: 14.5, font: "nunito", mono: "jetbrains-mono" };
@@ -45,6 +45,8 @@ export class Hub extends EventEmitter {
             library: this.skills,
             serverScript: fileURLToPath(new URL("./mcp-skills-server.js", import.meta.url)),
             hubUrl: () => this.hubUrl,
+            templates: this.templates,
+            templatesChanged: () => this.emit("event", { type: "templates" }),
             needApproval: () => this.settings.agentSkillsNeedApproval === true,
             save: (draft) => {
                 const { body: _b, ...meta } = this.saveSkillInternal(draft);
@@ -332,7 +334,7 @@ export class Hub extends EventEmitter {
         const template = this.templates.get(input.templateId);
         if (!template)
             throw new Error(`no such template: ${input.templateId}`);
-        const { room, notices } = this.createRoom({ name: input.name, dir: input.dir || template.dir || null, settings: template.settings });
+        const { room, notices } = this.createRoom({ name: input.name, dir: input.dir || template.dir || null, settings: roomSettingsFromTemplate(template) });
         const installed = new Set(listRecipes().filter((r) => !r.unavailableReason).map((r) => r.id));
         for (const [i, tv] of template.vibemates.entries()) {
             const choice = { ...(input.vibemates[i] ?? { name: tv.name, agentType: "" }) };

package/dist/main.js

@@ -192,7 +192,8 @@ function openWindow(url, options, log) {
         }
         catch {
         }
-        spawn(chromium, args, { detached: true, stdio: "ignore" }).unref();
+        mkdirSync(options.dataDir, { recursive: true });
+        spawn(chromium, args, { cwd: options.dataDir, detached: true, stdio: "ignore" }).unref();
         if (process.platform === "win32") {
             const shortcuts = windowsShortcutPaths(homedir(), process.env, true).filter((p) => existsSync(p));
             if (shortcuts.length)
@@ -325,7 +326,7 @@ async function startBackground(options, log, info) {
     const args = [fileURLToPath(import.meta.url), "serve", "--port", String(options.port), "--data-dir", options.dataDir, "--no-open"];
     if (options.name)
         args.push("--name", options.name);
-    const child = spawn(process.execPath, args, { detached: true, stdio: ["ignore", fd, fd], windowsHide: true });
+    const child = spawn(process.execPath, args, { cwd: options.dataDir, detached: true, stdio: ["ignore", fd, fd], windowsHide: true });
     child.unref();
     closeSync(fd);
     log.info(`hub started in the background (pid ${child.pid}); log: ${logPath}`);

package/dist/mcp-skills-server.js

@@ -13,6 +13,33 @@ const SKILL_FIELDS = {
     agent_invocable: { type: "boolean", description: "optional (default true): agents may load it themselves" },
     dry_run: { type: "boolean", description: "optional: only lint, write nothing" },
 };
+const DESIGN_FIELDS = {
+    kind: { type: "string", enum: ["template", "room"], description: "template: a whole template (name, description, vibemates); room: a change to this room, starting from its current settings" },
+    name: { type: "string", description: "the template's name (1-40 characters; the id is derived from it)" },
+    description: { type: "string", description: "what the room is for and how it feels, two sentences; shown in the picker" },
+    emoji: { type: "string", description: "optional: the room's emoji" },
+    settings: {
+        type: "object",
+        description: "room settings by key, only the ones you set; describe_room lists the keys with their meaning, bounds and defaults. Rules go in customRules, one per line.",
+        additionalProperties: true,
+    },
+    vibemates: {
+        type: "array",
+        description: "the vibemates: name (1-24 letters, digits, _ or -), tagline (the one line the others see, up to 80 characters), role (who this one is and which way it leans; private), avatar (one emoji), skills (names from the library)",
+        items: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                tagline: { type: "string" },
+                role: { type: "string" },
+                avatar: { type: "string" },
+                skills: { type: "array", items: { type: "string" } },
+                replyDelay: { type: "number", description: "optional: seconds this vibemate waits before a turn, overriding the room's delay" },
+            },
+            required: ["name"],
+        },
+    },
+};
 const TOOLS = [
     {
         name: TOOL_NAME,
@@ -45,6 +72,58 @@ const TOOLS = [
             required: ["name"],
         },
     },
+    {
+        name: "describe_room",
+        description: "The facts about this room before you design anything: its settings with their meaning, bounds, defaults and current values; the rules; the vibemates (name, tagline, role, avatar, skills); the skill library; the templates that exist; and the brief you yourself receive. Read-only. Load the built-in skill \"room-designer\" for what makes rules and roles good.",
+        inputSchema: { type: "object", properties: {} },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "lint_room_design",
+        description: "Check a room design without saving anything: the same errors and warnings create_template / propose_room_changes would give, plus a preview of the brief the first vibemate would receive (exactly what the room will read). kind \"template\" checks a whole template; kind \"room\" checks a change to this room, starting from its current settings.",
+        inputSchema: { type: "object", properties: DESIGN_FIELDS, required: ["kind"] },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "create_template",
+        description: "Save a room template into the human's library: a file the human picks under New room to create a room with these settings, rules and vibemates. No effect on any existing room. The hub checks the design first (errors stop the save, warnings come back with it). A taken name gets a numbered id unless replace is true and the template is one you or the human made.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: DESIGN_FIELDS.name,
+                description: DESIGN_FIELDS.description,
+                emoji: DESIGN_FIELDS.emoji,
+                settings: DESIGN_FIELDS.settings,
+                vibemates: DESIGN_FIELDS.vibemates,
+                replace: { type: "boolean", description: "optional: overwrite the template with this name instead of saving a numbered copy (never a template viberoom ships)" },
+            },
+            required: ["name", "description", "vibemates"],
+        },
+    },
+    {
+        name: "propose_room_changes",
+        description: "Propose changes to this room: settings by key (rules in customRules, one per line) and vibemates to add, update or remove. The hub checks the change set like a template, then shows the human a card with the diff and the warnings; nothing changes until the human clicks Apply, and the room gets a line with the outcome. A new vibemate is added waiting for the human to pick its coding agent. Say in why what the change fixes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                why: { type: "string", description: "one or two sentences: what this change fixes or enables; shown on the card" },
+                settings: DESIGN_FIELDS.settings,
+                vibemates: {
+                    type: "object",
+                    description: "optional: vibemates to add (full entries), update (by name; give only the fields that change; newName renames) or remove (names)",
+                    properties: {
+                        add: DESIGN_FIELDS.vibemates,
+                        update: {
+                            type: "array",
+                            items: { type: "object", properties: { name: { type: "string" }, newName: { type: "string" }, tagline: { type: "string" }, role: { type: "string" }, avatar: { type: "string" }, skills: { type: "array", items: { type: "string" } }, replyDelay: { type: "number" } }, required: ["name"] },
+                        },
+                        remove: { type: "array", items: { type: "string" } },
+                    },
+                },
+            },
+            required: ["why"],
+        },
+    },
 ];
 let readySent = false;
 function send(message) {
@@ -144,6 +223,46 @@ async function handle(message) {
                 reply(id, { content: [{ type: "text", text: String(res.body.message ?? "attached") }] });
                 return;
             }
+            if (name === "describe_room") {
+                const res = await hub(`/api/mcp/room?token=${encodeURIComponent(TOKEN)}`);
+                if (!res.ok)
+                    return errorResult("the room could not be described", res);
+                reply(id, { content: [{ type: "text", text: JSON.stringify(res.body, null, 2) }] });
+                return;
+            }
+            if (name === "lint_room_design") {
+                const res = await hub("/api/mcp/design/lint", {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ token: TOKEN, ...args }),
+                });
+                if (!res.ok)
+                    return errorResult("the design could not be checked", res);
+                reply(id, { content: [{ type: "text", text: JSON.stringify(res.body, null, 2) }], isError: res.body.ok === false ? true : undefined });
+                return;
+            }
+            if (name === "create_template") {
+                const res = await hub("/api/mcp/templates", {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ token: TOKEN, ...args }),
+                });
+                if (!res.ok)
+                    return errorResult("the template could not be saved", res);
+                reply(id, { content: [{ type: "text", text: String(res.body.message ?? "saved") }] });
+                return;
+            }
+            if (name === "propose_room_changes") {
+                const res = await hub("/api/mcp/propose", {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ token: TOKEN, ...args }),
+                });
+                if (!res.ok)
+                    return errorResult("the proposal could not be made", res);
+                reply(id, { content: [{ type: "text", text: String(res.body.message ?? "proposed") }] });
+                return;
+            }
             fail(id, -32602, `unknown tool: ${name}`);
             return;
         }

package/dist/persona.js

@@ -9,39 +9,104 @@ 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 function promptText(parts) {
     return parts.map((p) => (p.type === "text" ? p.text : "")).join("");
@@ -129,6 +194,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.");

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;
+}