viberoom 0.5.9 → 0.6.0

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.js

@@ -4,12 +4,16 @@ import { randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { writeFileAtomic } from "./atomic.js";
 import { NOTES_ONLY_PROMPT, NOTES_REQUEST, crossedThreshold, emptyUsageReport, extractNotes, isBareContextFullError, isContextFullError, looksCompacted, overThreshold, visibleChunk } from "./context.js";
+import { formatDuration } from "./duration.js";
 import { affectedByEdit, editNotice, partitionHistory, rewriteNotice } from "./edit.js";
 import { saveImages } from "./files.js";
+import { agentReadableWindow, resolveQuotes } from "./quotes.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 { classifyStartFailure } from "./agent-health.js";
+import { legacyRowTone } from "./rows.js";
 import { composeSkillBlock, skillPull, SKILL_TOOL_NAME } from "./persona.js";
 import { BUILTIN_AUTHOR, parseSkillInvocation, renderSkillBody, SKILL_NAME_PATTERN, } from "./skills.js";
 import { templateId } from "./templates.js";
@@ -93,6 +97,11 @@ export class Room extends EventEmitter {
         for (const line of lines) {
             try {
                 const message = JSON.parse(line);
+                if (message.kind === "system" && !message.details?.tone) {
+                    const tone = legacyRowTone(message.text);
+                    if (tone)
+                        message.details = { ...(message.details ?? {}), tone };
+                }
                 this.messages.push(message);
                 if (message.seq > this.seq)
                     this.seq = message.seq;
@@ -212,6 +221,19 @@ export class Room extends EventEmitter {
         appendFileSync(this.historyPath(), JSON.stringify(message) + "\n");
         this.push({ type: "message", message });
     }
+    messagesWithLiveDrafts() {
+        const live = [...this.runtimes.values()].filter((r) => r.turn?.published).map((r) => r.turn.message);
+        if (!live.length)
+            return [...this.messages];
+        const out = [...this.messages];
+        for (const draft of live) {
+            let at = out.length;
+            while (at > 0 && out[at - 1].ts > draft.ts)
+                at--;
+            out.splice(at, 0, draft);
+        }
+        return out;
+    }
     get humanName() {
         return this.settings.humanName;
     }
@@ -232,7 +254,7 @@ export class Room extends EventEmitter {
             settings: this.settings,
             customRulesText: this.renderRuleReferences(this.settings.customRules),
             participants: [...this.participants.values()],
-            messages: [...this.messages, ...this.drafts.values()],
+            messages: this.messagesWithLiveDrafts(),
             permissions: [...this.permissions.values()].map(({ resolve: _r, ...p }) => p),
             proposals: [...this.proposals.values()],
             recipes: listRecipes().map(({ build: _b, ...r }) => r),
@@ -296,13 +318,14 @@ export class Room extends EventEmitter {
     unstaffed() {
         return [...this.participants.values()].filter((p) => p.kind === "agent" && p.status === "unstaffed");
     }
-    postHumanMessage(text, images = []) {
+    postHumanMessage(text, images = [], quotes = []) {
         const waiting = this.unstaffed();
         if (waiting.length)
             throw new Error(`${waiting.map((p) => p.name).join(", ")} ${waiting.length === 1 ? "has" : "have"} no coding agent yet: summon ${waiting.length === 1 ? "it" : "them"} from the roster to start the conversation`);
         const trimmed = text.trim();
-        if (!trimmed && !images.length)
+        if (!trimmed && !images.length && !quotes.length)
             throw new Error("empty message");
+        const quoted = quotes.length ? resolveQuotes(quotes, this.messages) : [];
         const attachments = images.length ? saveImages(ensureDir(this.filesDir()), images) : [];
         this.humanTypingUntil = 0;
         const human = this.participants.get("human");
@@ -319,6 +342,8 @@ export class Room extends EventEmitter {
         };
         if (attachments.length)
             message.images = attachments;
+        if (quoted.length)
+            message.quotes = quoted;
         this.decorateHumanMessage(message);
         human.turns += 1;
         if (this.focused) {
@@ -470,6 +495,7 @@ export class Room extends EventEmitter {
         const memory = !!options.memory;
         const replay = memory ? Math.max(0, options.replay ?? this.settings.replayAfterRestart) : 0;
         const withNotes = memory && !!participant.notes;
+        const why = options.reason ?? "its context was cleared";
         this.dropScheduledTurn(id);
         this.cancelPermissionsOf(id);
         if (this.speaking === id)
@@ -480,18 +506,38 @@ export class Room extends EventEmitter {
         this.restoredSeen.set(id, this.seq);
         this.push({ type: "participant", participant });
         if (!online) {
-            participant.statusDetail = withNotes ? "its context was cleared; a reconnect starts it with its notes" : "its context was cleared; a reconnect starts it with an empty head";
-            this.postSystem(withNotes ? `${participant.name} was respawned while offline: it comes back with its notes.` : `${participant.name} was respawned while offline: it comes back knowing nothing from before.`);
+            participant.statusDetail = withNotes ? `${why}; a reconnect starts it with its notes` : `${why}; a reconnect starts it with an empty head`;
+            const comesBack = withNotes ? "it comes back with its notes" : "it comes back knowing nothing from before";
+            this.postSystem(options.reason ? `${participant.name} was respawned while offline (${why}): ${comesBack}.` : `${participant.name} was respawned while offline: ${comesBack}.`);
             this.push({ type: "participant", participant });
             this.log.info(`respawn of ${participant.name} (offline): stored session dropped`);
             return participant;
         }
         await this.reconnect(id, memory
-            ? { mode: "replay", replay, memory: withNotes, reason: `its context was cleared; it comes back with ${withNotes ? "its notes and " : ""}the last ${replay} messages` }
-            : { mode: "replay", replay: 0, reason: "its context was cleared, it remembers nothing from before" });
+            ? { mode: "replay", replay, memory: withNotes, reason: `${why}; it comes back with ${withNotes ? "its notes and " : ""}the last ${replay} messages` }
+            : { mode: "replay", replay: 0, reason: `${why}, it remembers nothing from before` });
         this.log.info(`respawn of ${participant.name}: fresh session, ${memory ? `${withNotes ? "notes + " : ""}replay ${replay}` : "no replay"}`);
         return participant;
     }
+    async restartWithPersona(id, patch) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        const runtime = this.runtimes.get(id);
+        const online = !!runtime && runtime.agent.alive;
+        if (online && runtime.turnActive)
+            throw new Error(`${participant.name} is in the middle of a reply; try again when it is idle`);
+        if (online) {
+            try {
+                await this.takeNotes(id);
+            }
+            catch (error) {
+                this.log.warn(`${participant.name}: notes before the restart failed (${describeError(error)}); it restarts with the notes it had`);
+            }
+        }
+        this.updatePersona(id, patch);
+        return this.respawnAgent(id, { memory: true, reason: "its role changed" });
+    }
     updateNotes(id, notes) {
         const participant = this.participants.get(id);
         if (!participant || participant.kind !== "agent")
@@ -514,7 +560,15 @@ export class Room extends EventEmitter {
             throw new Error(`${participant.name} is in the middle of a reply; try again when it is idle`);
         const header = buildHeader(this.effectiveSettings(), this.personaOf(participant), this.roster(), this.hops, ["hidden turn: notes only, nothing is posted"]);
         runtime.log.info("notes: hidden turn");
-        await this.executeTurn(participant, runtime, [{ type: "text", text: `${header}\n\n${NOTES_ONLY_PROMPT}` }], null, true);
+        participant.notesTurn = true;
+        this.push({ type: "participant", participant });
+        try {
+            await this.executeTurn(participant, runtime, [{ type: "text", text: `${header}\n\n${NOTES_ONLY_PROMPT}` }], null, true);
+        }
+        finally {
+            participant.notesTurn = undefined;
+            this.push({ type: "participant", participant });
+        }
         return participant;
     }
     keepNotes(participant, runtime, notes, via) {
@@ -536,14 +590,14 @@ export class Room extends EventEmitter {
             participant.status = "error";
             participant.statusDetail = "its context filled up again right after a respawn; it needs you (respawn it by hand, with fewer replayed messages)";
             this.push({ type: "participant", participant });
-            this.postSystem(`${participant.name} ran out of context again (${detail.slice(0, 120)}); it was respawned once already and now needs you.`, "human");
+            this.postSystem(`${participant.name} ran out of context again (${detail.slice(0, 120)}); it was respawned once already and now needs you.`, "human", false, { tone: "error" });
             runtime.log.warn(`context full again within 10 minutes: no automatic respawn`);
             return;
         }
         participant.autoRespawnAt = Date.now();
         this.push({ type: "participant", participant });
         const memory = !!participant.notes;
-        this.postSystem(`${participant.name} ran out of context (${detail.slice(0, 120)}); it is respawned ${memory ? `with its notes and the last ${this.settings.replayAfterRestart} messages` : `with the last ${this.settings.replayAfterRestart} messages (it had no notes)`}.`, "human");
+        this.postSystem(`${participant.name} ran out of context (${detail.slice(0, 120)}); it is respawned ${memory ? `with its notes and the last ${this.settings.replayAfterRestart} messages` : `with the last ${this.settings.replayAfterRestart} messages (it had no notes)`}.`, "human", false, { tone: "error" });
         runtime.log.warn(`context full: ${detail}; respawn with ${memory ? "notes" : "no notes"}`);
         setImmediate(() => {
             void (memory ? this.respawnAgent(participant.id, { memory: true }) : this.reconnectAfterFull(participant.id)).catch((error) => this.notice(`${participant.name}: respawn after a full context failed: ${describeError(error)}`, "error"));
@@ -599,7 +653,7 @@ export class Room extends EventEmitter {
         }
         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.`);
+        this.postSystem(`Hush: ${stopped ? `${stopped} repl${stopped > 1 ? "ies" : "y"} stopped; ` : ""}everyone waits until ${this.humanName} writes again.`, undefined, false, { tone: "hush" });
     }
     rename(name) {
         const trimmed = name.trim();
@@ -887,20 +941,25 @@ export class Room extends EventEmitter {
         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}`);
+        const stderrTail = [];
         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}`),
+                onStderr: (line) => {
+                    log.info(`stderr: ${line}`);
+                    stderrTail.push(line);
+                    if (stderrTail.length > 10)
+                        stderrTail.shift();
+                },
                 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;
+            throw this.failStart(participant, error, fresh, stderrTail);
         }
         try {
             const init = await agent.initialize({ name: "viberoom", version: "0.2.0" });
@@ -993,6 +1052,7 @@ export class Room extends EventEmitter {
                 this.notice(`${name}: ${w}`, "warn");
             participant.status = "idle";
             participant.statusDetail = undefined;
+            participant.trouble = undefined;
             this.push({ type: "participant", participant });
             if (fresh) {
                 const detail = this.settings.showVendorInRoster ? `${recipe.label}${participant.model ? `, model ${participant.model}` : ""}` : "agent";
@@ -1024,8 +1084,7 @@ export class Room extends EventEmitter {
         catch (error) {
             agent.kill();
             this.forgetRuntime(id);
-            this.failStart(participant, error, fresh);
-            throw error;
+            throw this.failStart(participant, error, fresh, stderrTail);
         }
     }
     async removeParticipant(id) {
@@ -1069,11 +1128,20 @@ export class Room extends EventEmitter {
         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");
+        if (runtime.turnActive) {
+            runtime.agent.cancel(runtime.sessionId);
+            this.cancelPermissionsOf(id);
+            this.notice(`${participant.name}: stop requested.`, "info");
+            return "turn";
+        }
+        if (runtime.pendingTurn || runtime.delayTimer || this.floorQueue.includes(id)) {
+            this.dropScheduledTurn(id);
+            this.notice(`${participant.name}: stopped before it began; the turn is dropped.`, "info");
+            this.postSystem(`${participant.name} was stopped by ${this.humanName} before it began.`, undefined, false, { tone: "attention" });
+            return "queued";
+        }
+        this.notice(`${participant.name}: nothing to stop, it is not writing.`, "info");
+        return "nothing";
     }
     async setConfig(id, configId, value) {
         const runtime = this.runtimes.get(id);
@@ -1160,7 +1228,7 @@ export class Room extends EventEmitter {
             if (wanted.length) {
                 if (this.hops >= this.hopLimit) {
                     const who = agentTargets.length ? message.toNames.join(", ") : "the other vibemates";
-                    this.postSystem(`Hop limit ${this.hopLimit} reached: ${who} will not be prompted until ${this.humanName} writes again.`);
+                    this.postSystem(`Hop limit ${this.hopLimit} reached: ${who} will not be prompted until ${this.humanName} writes again.`, undefined, false, { tone: "attention" });
                 }
                 else {
                     this.hops += 1;
@@ -1245,6 +1313,25 @@ export class Room extends EventEmitter {
         const result = lintRoomDesign(design, { ...this.designContext(kind), skills: this.skillsForDesign(participantId) });
         return { ok: !result.errors.length, errors: result.errors.map((e) => e.message), warnings: result.warnings.map((w) => w.message), preview: result.preview };
     }
+    readMessageForAgent(participantId, seq, around) {
+        const participant = this.agentInRoom(participantId);
+        const window = agentReadableWindow(this.messages, seq, around);
+        if (!window)
+            throw new Error(`no message #${seq} in this room (or it is one the vibemates do not see)`);
+        const view = (m) => ({
+            seq: m.seq,
+            from: m.fromName,
+            to: m.toNames,
+            at: new Date(m.ts).toISOString(),
+            text: m.text,
+            ...(m.kind === "system" ? { kind: "system" } : {}),
+            ...(m.edited ? { edited: true } : {}),
+            ...(m.images && m.images.length ? { images: m.images.map((a, i) => ({ ref: `#${m.seq}.${a.n ?? i + 1}`, name: a.name, path: this.imagePath(a) })) } : {}),
+            ...(m.quotes && m.quotes.length ? { quotes: m.quotes.map((q) => ({ n: q.n, seq: q.seq, from: q.fromName, text: q.text })) } : {}),
+        });
+        this.log.info(`read_message: ${participant.name} read #${seq}${around ? ` (around ${around})` : ""}`);
+        return { message: view(window.message), before: window.before.map(view), after: window.after.map(view) };
+    }
     designContext(kind) {
         return {
             kind,
@@ -1347,7 +1434,7 @@ export class Room extends EventEmitter {
         this.proposals.set(proposal.key, proposal);
         this.push({ type: "proposal", proposal });
         const what = [...settingChanges.map((c) => c.key), ...vibes.ops.map((o) => `${o.op} ${o.name}`)].join(", ");
-        this.postSystem(`${participant.name} proposes changes to the room (${what}); apply or reject them on the card.`, "human");
+        this.postSystem(`${participant.name} proposes changes to the room (${what}); apply or reject them on the card.`, "human", false, { tone: "attention" });
         this.log.info(`proposal ${proposal.key} from ${participant.name}: ${what}`);
         return {
             ok: true,
@@ -1839,6 +1926,7 @@ export class Room extends EventEmitter {
             const attached = seesImages && (m.to.length === 0 || m.to.includes(id));
             return m.images.map((a, i) => ({ n: a.n ?? i + 1, ref: `#${m.seq}.${a.n ?? i + 1}`, name: a.name, path: this.imagePath(a), mimeType: a.mimeType, attached, forNames: m.to.length ? m.toNames : [] }));
         };
+        const backlogQuotes = (m) => m.quotes && m.quotes.length ? m.quotes.map((q) => ({ n: q.n, seq: q.seq, fromName: q.fromName, ts: q.ts, text: q.text })) : undefined;
         const prompt = composePrompt({
             brief: briefReason ? buildBrief(settings, persona, roster, runtime.notesForBrief ?? (participant.notes && (participant.notesSeq ?? -1) >= runtime.lastBriefSeq ? participant.notes : undefined), skillsForPrompt) : undefined,
             header: buildHeader(settings, persona, roster, this.hops, notes, skillsForPrompt),
@@ -1851,6 +1939,7 @@ export class Room extends EventEmitter {
                     toNames: m.toNames,
                     text: m.text,
                     images: backlogImages(m),
+                    quotes: backlogQuotes(m),
                 }),
             omitted,
             personaName: participant.name,
@@ -1950,7 +2039,7 @@ export class Room extends EventEmitter {
             if (isContextFullError(failure))
                 this.contextFull(participant, runtime, failure ?? "");
             else
-                this.postSystem(`${participant.name} could not answer: ${(failure ?? "no result").slice(0, 240)}`);
+                this.postSystem(`${participant.name} could not answer: ${(failure ?? "no result").slice(0, 240)}`, undefined, false, { tone: "error" });
             return null;
         }
         return this.finalizeTurn(participant, runtime, draft, result, Date.now() - startedAt, retry, published, publishedAt);
@@ -2012,10 +2101,13 @@ export class Room extends EventEmitter {
             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.`);
+                    this.postSystem(`${participant.name} was stopped by ${this.humanName}.`, undefined, false, { tone: "attention" });
+            }
+            else if (cancelled) {
+                this.postSystem(`${participant.name} was stopped by ${this.humanName}.`, undefined, false, { tone: "attention" });
             }
             else {
-                this.postSystem(cancelled ? `${participant.name} was stopped.` : `${participant.name} read the room and has nothing to add.`);
+                this.postSystem(`${participant.name} read the room and has nothing to add.`);
             }
             return null;
         }
@@ -2025,7 +2117,7 @@ export class Room extends EventEmitter {
             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 ? "…" : ""}`);
+            this.postSystem(`${participant.name}'s agent reported an error instead of a reply: ${text.slice(0, 200)}${text.length > 200 ? "…" : ""}`, undefined, false, { tone: "error" });
             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");
@@ -2076,6 +2168,7 @@ export class Room extends EventEmitter {
             text,
             streaming: false,
             stopReason: result.stopReason,
+            ...(cancelled ? { stoppedBy: this.humanName } : {}),
             usage: result.usage ?? null,
             durationMs,
         };
@@ -2083,17 +2176,17 @@ export class Room extends EventEmitter {
         if (publishedAt !== null && this.messages.some((x) => x.kind === "chat" && x.id !== message.id && x.ts > publishedAt)) {
             const at = new Date(draft.ts);
             const hhmm = `${String(at.getHours()).padStart(2, "0")}:${String(at.getMinutes()).padStart(2, "0")}`;
-            this.postSystem(`${participant.name} finished the reply started at ${hhmm} · ${Math.round(durationMs / 1000)} s`, "human", false, { refId: message.id, agentId: participant.id });
+            this.postSystem(`${participant.name} finished the reply started at ${hhmm} · ${formatDuration(durationMs)}`, "human", false, { refId: message.id, agentId: participant.id });
         }
         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.`);
+            this.postSystem(`${participant.name} was stopped mid-reply by ${this.humanName}; what it had written stays in the room.`, "agents", false, { tone: "attention" });
             return null;
         }
         if (result.stopReason !== "end_turn") {
-            this.postSystem(`${participant.name} stopped with ${result.stopReason}.`);
+            this.postSystem(`${participant.name} stopped with ${result.stopReason}.`, undefined, false, { tone: "attention" });
         }
         this.route(message);
         return null;
@@ -2271,12 +2364,12 @@ export class Room extends EventEmitter {
                     runtime.log.info(`usage dropped ${runtime.lastUsed} -> ${u.used}; brief scheduled`);
                     participant.contextEvent = { kind: "compacted", at: Date.now(), used: u.used, size: u.size };
                     runtime.notesDue = overThreshold(u.used, u.size);
-                    this.postSystem(`${participant.name} compacted its context (${Math.round(runtime.lastUsed / 1000)}k → ${Math.round(u.used / 1000)}k tokens); the room rules are re-sent with its next turn${participant.notes ? ", with its notes" : ""}.`, "human");
+                    this.postSystem(`${participant.name} compacted its context (${Math.round(runtime.lastUsed / 1000)}k → ${Math.round(u.used / 1000)}k tokens); the room rules are re-sent with its next turn${participant.notes ? ", with its notes" : ""}.`, "human", false, { tone: "attention" });
                 }
                 if (crossedThreshold(runtime.lastUsed, u.used, u.size)) {
                     runtime.notesDue = true;
                     participant.contextEvent = { kind: "threshold", at: Date.now(), used: u.used, size: u.size };
-                    this.postSystem(`${participant.name} is at ${Math.round((100 * u.used) / u.size)}% of its context; it will leave notes with its next reply. You can respawn it with memory from its panel.`, "human");
+                    this.postSystem(`${participant.name} is at ${Math.round((100 * u.used) / u.size)}% of its context; it will leave notes with its next reply. You can respawn it with memory from its panel.`, "human", false, { tone: "attention" });
                     runtime.log.info(`context at ${u.used}/${u.size}: notes due`);
                 }
                 runtime.lastUsed = u.used;
@@ -2443,8 +2536,17 @@ export class Room extends EventEmitter {
         participant.effort = pick("thought_level") ?? participant.effort;
         participant.mode = pick("mode") ?? participant.mode;
     }
-    failStart(participant, error, fresh) {
+    failStart(participant, error, fresh, stderr = []) {
         participant.statusDetail = error instanceof Error ? error.message : String(error);
+        const recipe = getRecipe(participant.agentType ?? "");
+        participant.trouble = classifyStartFailure({
+            error: participant.statusDetail,
+            stderr,
+            vendor: recipe?.vendor ?? participant.agentVendor ?? "The coding agent",
+            loginCommand: recipe?.loginCommand || undefined,
+            installHint: recipe?.installHint || undefined,
+            loginState: recipe?.loginState,
+        });
         this.notice(`${participant.name}: failed to start: ${participant.statusDetail}`, "error");
         if (fresh) {
             participant.status = "error";
@@ -2456,6 +2558,7 @@ export class Room extends EventEmitter {
             participant.status = "offline";
             this.push({ type: "participant", participant });
         }
+        return new Error(`${participant.trouble.what} ${participant.trouble.advice} (${participant.statusDetail})`);
     }
     cancelPermissionsOf(id) {
         for (const [key, entry] of this.permissions) {

package/dist/rows.js

@@ -0,0 +1,19 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+const LEGACY = [
+    [/^(Hush|Focus):/, "hush"],
+    [/ could not answer: /, "error"],
+    [/'s agent reported an error instead of a reply/, "error"],
+    [/ ran out of context/, "error"],
+    [/ was stopped\b/, "attention"],
+    [/^Hop limit \d+ reached/, "attention"],
+    [/ is at \d+% of its context/, "attention"],
+    [/ compacted its context/, "attention"],
+    [/ proposes changes to the room/, "attention"],
+    [/ was respawned while offline/, "attention"],
+];
+export function legacyRowTone(text) {
+    for (const [pattern, tone] of LEGACY)
+        if (pattern.test(text))
+            return tone;
+    return undefined;
+}