viberoom 0.5.5 → 0.5.7

package/dist/context.js

@@ -0,0 +1,42 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+export const NOTES_THRESHOLD = 0.8;
+export const NOTES_REQUEST = "end your reply with a <notes> block: up to 10 lines on this room, your task and where you are with it; the block is kept by the hub for a restart and is not posted";
+export const NOTES_ONLY_PROMPT = "Reply with a <notes> block only: up to 10 lines on this room, your task and where you are with it, written for a future you that starts with an empty head. Nothing else; nothing is posted.";
+const OPEN = /<notes>/i;
+const BLOCK = /\s*<notes>([\s\S]*?)(?:<\/notes>|$)\s*/i;
+export function extractNotes(text) {
+    const m = BLOCK.exec(text);
+    if (!m)
+        return { visible: text, notes: null };
+    const notes = m[1].trim();
+    const before = text.slice(0, m.index).replace(/\s+$/, "");
+    const after = text.slice(m.index + m[0].length).replace(/^\s+/, "");
+    const visible = before && after ? `${before} ${after}` : before || after;
+    return { visible, notes: notes || null };
+}
+export function visibleChunk(textBefore, chunk) {
+    if (OPEN.test(textBefore))
+        return "";
+    const at = chunk.search(OPEN);
+    return at < 0 ? chunk : chunk.slice(0, at);
+}
+export function crossedThreshold(previousUsed, used, size, threshold = NOTES_THRESHOLD) {
+    if (!(size > 0))
+        return false;
+    return used / size >= threshold && previousUsed / size < threshold;
+}
+export function overThreshold(used, size, threshold = NOTES_THRESHOLD) {
+    return size > 0 && used / size >= threshold;
+}
+const CONTEXT_FULL = /context (window )?(is )?(full|too long|exceeded|limit)|prompt is too long|maximum context length|input (length|is too long)|too many tokens|exceeds the (context|token) (window|limit)|context_length_exceeded/i;
+export function isContextFullError(text) {
+    return !!text && CONTEXT_FULL.test(text);
+}
+const BARE_PREFIX = /^\s*(?:\[?(?:error|api error|request failed)\]?\s*[:\-]?\s*)?(?:\d{3}\s+)?/i;
+export function isBareContextFullError(text) {
+    if (!text || text.length > 240 || text.includes("\n"))
+        return false;
+    const rest = text.replace(BARE_PREFIX, "");
+    const m = CONTEXT_FULL.exec(rest);
+    return !!m && m.index === 0;
+}

package/dist/recipes.js

@@ -1,6 +1,6 @@
 // viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
 import { execSync } from "node:child_process";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -110,6 +110,23 @@ function resolveGlobalNpmBin(name) {
     const candidates = isWindows ? [join(root, "..", `${name}.cmd`)] : [join(root, "..", "..", "bin", name)];
     return candidates.find((c) => existsSync(c)) ?? null;
 }
+function resolveGlobalPackageBin(packageName, command) {
+    const root = resolveGlobalNpmRoot();
+    if (!root)
+        return null;
+    const dir = join(root, packageName);
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        const entry = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[command];
+        if (!entry)
+            return null;
+        const file = join(dir, entry);
+        return existsSync(file) ? file : null;
+    }
+    catch {
+        return null;
+    }
+}
 function resolveClaudeCode() {
     const onPath = resolveOnPath(["claude"]);
     if (onPath && !/\.(cmd|bat)$/i.test(onPath))
@@ -117,7 +134,7 @@ function resolveClaudeCode() {
     const native = join(homedir(), ".local", "bin", isWindows ? "claude.exe" : "claude");
     if (existsSync(native))
         return native;
-    return resolveGlobalPackageEntry("@anthropic-ai/claude-code", "cli.js");
+    return resolveGlobalPackageBin("@anthropic-ai/claude-code", "claude");
 }
 function resolveCodex() {
     return resolveGlobalNpmBin("codex") ?? resolveOnPath(["codex"]);
@@ -276,6 +293,28 @@ const recipes = [
         }),
     },
 ];
+const fakeAgent = process.env.VIBEROOM_FAKE_AGENT;
+if (fakeAgent) {
+    recipes.push({
+        id: "fake",
+        label: "Fake (test agent)",
+        vendor: "Fake",
+        icon: "",
+        tested: false,
+        note: "A scripted ACP agent for the hub's own probes; present only with VIBEROOM_FAKE_AGENT.",
+        modelPresets: [],
+        defaultModel: null,
+        effortPresets: [],
+        defaultEffort: null,
+        modePresets: [],
+        defaultMode: null,
+        unavailableReason: null,
+        installedAt: fakeAgent,
+        installHint: "",
+        bypassMode: null,
+        build: () => ({ command: process.execPath, args: [fakeAgent], env: {} }),
+    });
+}
 export function listRecipes() {
     return recipes;
 }

package/dist/room.js

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 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, extractNotes, isBareContextFullError, isContextFullError, overThreshold, visibleChunk } from "./context.js";
 import { affectedByEdit, editNotice, partitionHistory, rewriteNotice } from "./edit.js";
 import { saveImages } from "./files.js";
 import { join, resolve } from "node:path";
@@ -29,6 +30,7 @@ export class Room extends EventEmitter {
     hops = 0;
     focused = false;
     participants = new Map();
+    lastTurnHidden = false;
     messages = [];
     seq = 0;
     programHumanDescription;
@@ -124,6 +126,9 @@ export class Room extends EventEmitter {
                 sessionId: s.sessionId,
                 supportsLoad: s.supportsLoad,
                 sawFromSeq: s.sawFromSeq,
+                notes: s.notes,
+                notesAt: s.notesAt,
+                notesSeq: s.notesSeq,
                 violations: 0,
                 briefsSent: 0,
                 failedTurns: 0,
@@ -193,6 +198,9 @@ export class Room extends EventEmitter {
                 supportsLoad: p.supportsLoad,
                 lastSeenSeq: this.runtimes.get(p.id)?.lastSeenSeq ?? this.restoredSeen.get(p.id),
                 sawFromSeq: p.sawFromSeq,
+                notes: p.notes,
+                notesAt: p.notesAt,
+                notesSeq: p.notesSeq,
             })),
         };
     }
@@ -450,11 +458,14 @@ export class Room extends EventEmitter {
         this.route(message);
         return { restarted, removed: removed.length };
     }
-    async respawnAgent(id) {
+    async respawnAgent(id, options = {}) {
         const participant = this.participants.get(id);
         if (!participant || participant.kind !== "agent")
             throw new Error("no such agent");
         const online = this.runtimes.has(id);
+        const memory = !!options.memory;
+        const replay = memory ? Math.max(0, options.replay ?? this.settings.replayAfterRestart) : 0;
+        const withNotes = memory && !!participant.notes;
         this.dropScheduledTurn(id);
         this.cancelPermissionsOf(id);
         if (this.speaking === id)
@@ -465,16 +476,86 @@ export class Room extends EventEmitter {
         this.restoredSeen.set(id, this.seq);
         this.push({ type: "participant", participant });
         if (!online) {
-            participant.statusDetail = "its context was cleared; a reconnect starts it with an empty head";
-            this.postSystem(`${participant.name} was respawned while offline: it comes back knowing nothing from before.`);
+            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.`);
             this.push({ type: "participant", participant });
             this.log.info(`respawn of ${participant.name} (offline): stored session dropped`);
             return participant;
         }
-        await this.reconnect(id, { mode: "replay", replay: 0, reason: "its context was cleared, it remembers nothing from before" });
-        this.log.info(`respawn of ${participant.name}: fresh session, no replay`);
+        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" });
+        this.log.info(`respawn of ${participant.name}: fresh session, ${memory ? `${withNotes ? "notes + " : ""}replay ${replay}` : "no replay"}`);
         return participant;
     }
+    updateNotes(id, notes) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        const text = notes.trim().slice(0, 4000);
+        participant.notes = text || undefined;
+        participant.notesAt = text ? this.runtimes.get(id)?.lastUsed ?? participant.notesAt : undefined;
+        participant.notesSeq = text ? this.seq : undefined;
+        this.push({ type: "participant", participant });
+        return participant;
+    }
+    async takeNotes(id) {
+        const participant = this.participants.get(id);
+        const runtime = this.runtimes.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        if (!runtime || !runtime.agent.alive)
+            throw new Error(`${participant.name} is not online`);
+        if (runtime.turnActive)
+            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);
+        return participant;
+    }
+    keepNotes(participant, runtime, notes, via) {
+        if (!notes)
+            return false;
+        participant.notes = notes.slice(0, 4000);
+        participant.notesAt = runtime.lastUsed;
+        participant.notesSeq = this.seq;
+        runtime.notesDue = false;
+        runtime.notesMisses = 0;
+        this.push({ type: "participant", participant });
+        runtime.log.info(`notes: ${notes.split("\n").length} lines kept (${via}, context ${runtime.lastUsed})`);
+        return true;
+    }
+    contextFull(participant, runtime, detail) {
+        participant.contextEvent = { kind: "full", at: Date.now(), used: runtime.lastUsed, size: participant.contextSize };
+        const recently = participant.autoRespawnAt !== undefined && Date.now() - participant.autoRespawnAt < 10 * 60_000;
+        if (recently) {
+            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");
+            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");
+        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"));
+        });
+    }
+    async reconnectAfterFull(id) {
+        const participant = this.participants.get(id);
+        if (!participant)
+            return;
+        this.dropScheduledTurn(id);
+        this.cancelPermissionsOf(id);
+        if (this.runtimes.has(id))
+            await this.retireRuntime(id);
+        participant.sessionId = undefined;
+        await this.reconnect(id, { mode: "replay", reason: "its context was full; it comes back with the last messages" });
+    }
     async retireRuntime(id) {
         const runtime = this.runtimes.get(id);
         const participant = this.participants.get(id);
@@ -973,6 +1054,11 @@ export class Room extends EventEmitter {
                 briefPending: null,
                 headerNotes: [],
                 briefRequestedAtSeq: -1,
+                notesDue: false,
+                notesMisses: 0,
+                notesAskedThisTurn: false,
+                lastBriefSeq: -1,
+                notesForBrief: reconnectOptions?.memory && participant.notes ? participant.notes : null,
                 replayOwnUntilSeq: fresh || origin === "loaded" ? -1 : this.seq,
                 delayTimer: null,
                 addressed: false,
@@ -1597,6 +1683,11 @@ export class Room extends EventEmitter {
             briefReason = `${tokensSinceBrief} tokens since last brief`;
         const notes = [...runtime.headerNotes];
         runtime.headerNotes = [];
+        if (briefReason && overThreshold(runtime.lastUsed, participant.contextSize ?? 0))
+            runtime.notesDue = true;
+        runtime.notesAskedThisTurn = runtime.notesDue;
+        if (runtime.notesDue)
+            notes.push(NOTES_REQUEST);
         if (briefReason && runtime.firstTurnDone) {
             if (briefReason.startsWith("requested"))
                 notes.push("full brief re-sent as requested");
@@ -1618,7 +1709,7 @@ export class Room extends EventEmitter {
             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 prompt = composePrompt({
-            brief: briefReason ? buildBrief(settings, persona, roster, undefined, skillsForPrompt) : undefined,
+            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),
             skills: attached.map((s) => composeSkillBlock({ name: s.name, text: s.text, invokedBy: s.invokedBy, extraFiles: s.extraFiles })),
             backlog: unread.map((m) => m.kind === "system"
@@ -1637,6 +1728,8 @@ export class Room extends EventEmitter {
             runtime.briefPending = null;
             runtime.turnsSinceBrief = 0;
             runtime.briefSentThisTurn = true;
+            runtime.lastBriefSeq = this.seq;
+            runtime.notesForBrief = null;
             participant.briefsSent = (participant.briefsSent ?? 0) + 1;
         }
         runtime.firstTurnDone = true;
@@ -1664,7 +1757,7 @@ export class Room extends EventEmitter {
         }
         return blocks;
     }
-    async executeTurn(participant, runtime, blocks, retry) {
+    async executeTurn(participant, runtime, blocks, retry, hidden = false) {
         const id = participant.id;
         runtime.turnActive = true;
         participant.status = "thinking";
@@ -1684,7 +1777,7 @@ export class Room extends EventEmitter {
             toolCalls: [],
         };
         this.drafts.set(draft.id, draft);
-        runtime.turn = { message: draft, messageId: null, sawMessageId: false, startedAt: Date.now(), published: false };
+        runtime.turn = { message: draft, messageId: null, sawMessageId: false, startedAt: Date.now(), published: false, hidden };
         let result = null;
         let failure = null;
         try {
@@ -1696,6 +1789,7 @@ export class Room extends EventEmitter {
         const startedAt = runtime.turn.startedAt;
         const published = runtime.turn.published;
         const publishedAt = runtime.turn.publishedAt ?? null;
+        this.lastTurnHidden = !!runtime.turn.hidden;
         runtime.turn = null;
         runtime.turnActive = false;
         this.drafts.delete(draft.id);
@@ -1719,10 +1813,13 @@ export class Room extends EventEmitter {
             this.push({ type: "participant", participant });
             this.push({ type: "message.removed", id: draft.id });
             this.notice(`${participant.name}: turn failed: ${failure ?? "no result"}`, "error");
-            this.postSystem(`${participant.name} could not answer: ${(failure ?? "no result").slice(0, 240)}`);
             runtime.log.error(`turn failed: ${failure}`);
             if (retry)
                 this.closeRetry(retry, "the correction turn failed; nothing was posted");
+            if (isContextFullError(failure))
+                this.contextFull(participant, runtime, failure ?? "");
+            else
+                this.postSystem(`${participant.name} could not answer: ${(failure ?? "no result").slice(0, 240)}`);
             return null;
         }
         return this.finalizeTurn(participant, runtime, draft, result, Date.now() - startedAt, retry, published, publishedAt);
@@ -1730,10 +1827,36 @@ export class Room extends EventEmitter {
     finalizeTurn(participant, runtime, draft, result, durationMs, retry, published, publishedAt = null) {
         participant.status = "idle";
         this.push({ type: "participant", participant });
-        const text = draft.text.trim();
         const cancelled = result.stopReason === "cancelled";
         if (cancelled)
             runtime.briefPending = runtime.briefPending ?? "previous turn was cancelled";
+        const extracted = extractNotes(draft.text);
+        const hadNotes = this.keepNotes(participant, runtime, extracted.notes, runtime.turn?.hidden || draft.streaming === undefined ? "hidden turn" : "reply");
+        draft.text = extracted.visible;
+        const text = draft.text.trim();
+        if (this.lastTurnHidden) {
+            this.lastTurnHidden = false;
+            this.commit({
+                id: randomUUID(),
+                seq: ++this.seq,
+                from: participant.id,
+                fromName: participant.name,
+                to: [],
+                toNames: [],
+                text: hadNotes ? `took notes (${(participant.notes ?? "").split("\n").length} lines)` : "was asked for notes and gave none",
+                ts: Date.now(),
+                kind: "hidden",
+                details: { original: draft.text, outcome: hadNotes ? "notes kept" : "no <notes> block in the reply" },
+            });
+            return null;
+        }
+        if (runtime.notesAskedThisTurn && !hadNotes && !retry && !cancelled) {
+            runtime.notesMisses += 1;
+            if (runtime.notesMisses >= 2) {
+                runtime.notesMisses = 0;
+                setImmediate(() => void this.takeNotes(participant.id).catch((error) => runtime.log.warn(`notes: hidden turn failed: ${describeError(error)}`)));
+            }
+        }
         if (!retry && text.toLowerCase() === REQUEST_BRIEF_MARKER) {
             this.push({ type: "message.removed", id: draft.id });
             if (runtime.briefRequestedAtSeq === runtime.lastSeenSeq) {
@@ -1765,7 +1888,8 @@ export class Room extends EventEmitter {
             }
             return null;
         }
-        if (!(draft.toolCalls?.length) && ADAPTER_ERROR_PATTERN.test(text)) {
+        const bareContextFull = isBareContextFullError(text);
+        if (!(draft.toolCalls?.length) && (ADAPTER_ERROR_PATTERN.test(text) || bareContextFull)) {
             this.push({ type: "message.removed", id: draft.id });
             participant.failedTurns = (participant.failedTurns ?? 0) + 1;
             participant.statusDetail = `agent error: ${text.replace(/\s+/g, " ").slice(0, 120)}${text.length > 120 ? "…" : ""}`;
@@ -1774,6 +1898,8 @@ export class Room extends EventEmitter {
             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");
+            if (bareContextFull)
+                this.contextFull(participant, runtime, text);
             return null;
         }
         const mentions = this.parseMentions(text);
@@ -1907,7 +2033,7 @@ export class Room extends EventEmitter {
         return corrections;
     }
     showDraft(turn) {
-        if (turn.published)
+        if (turn.published || turn.hidden)
             return;
         turn.published = true;
         turn.publishedAt = Date.now();
@@ -1944,13 +2070,15 @@ export class Room extends EventEmitter {
                 if (messageId)
                     turn.sawMessageId = true;
                 turn.messageId = messageId;
+                const shown = visibleChunk(turn.message.text, text);
                 turn.message.text += text;
                 if (!turn.published) {
-                    if (!looksSilent(turn.message.text))
+                    if (!looksSilent(turn.message.text) && shown)
                         this.showDraft(turn);
                     return;
                 }
-                this.push({ type: "chunk", id: turn.message.id, text });
+                if (shown)
+                    this.push({ type: "chunk", id: turn.message.id, text: shown });
                 return;
             }
             case "agent_thought_chunk": {
@@ -2006,6 +2134,15 @@ export class Room extends EventEmitter {
                 if (runtime.lastUsed > 0 && u.used < runtime.lastUsed * 0.7 && !runtime.briefPending) {
                     runtime.briefPending = `context shrank from ${runtime.lastUsed} to ${u.used} tokens (compaction?)`;
                     runtime.log.info(`usage dropped ${runtime.lastUsed} -> ${u.used}; brief scheduled`);
+                    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");
+                }
+                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");
+                    runtime.log.info(`context at ${u.used}/${u.size}: notes due`);
                 }
                 runtime.lastUsed = u.used;
                 this.push({ type: "participant", participant });

package/dist/server.js

@@ -496,15 +496,21 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, { ok: true, ...result });
             return;
         }
-        const participantAction = path.match(/^\/api\/rooms\/([^/]+)\/participants\/([^/]+)\/(cancel|remove|config|persona|reconnect|mute|unmute|respawn|staff)$/);
+        const participantAction = path.match(/^\/api\/rooms\/([^/]+)\/participants\/([^/]+)\/(cancel|remove|config|persona|reconnect|mute|unmute|respawn|staff|notes|take-notes)$/);
         if (participantAction) {
             const room = hub.getRoom(decodeURIComponent(participantAction[1]));
             const id = decodeURIComponent(participantAction[2]);
             const action = participantAction[3];
             if (action === "cancel")
                 room.cancelTurn(id);
-            else if (action === "respawn")
-                await room.respawnAgent(id);
+            else if (action === "respawn") {
+                const replay = body.replay === undefined || body.replay === null || body.replay === "" ? undefined : Number(body.replay);
+                await room.respawnAgent(id, { memory: body.memory === true || body.memory === "true", replay: replay !== undefined && Number.isFinite(replay) ? Math.max(0, Math.min(500, Math.round(replay))) : undefined });
+            }
+            else if (action === "notes")
+                room.updateNotes(id, String(body.notes ?? ""));
+            else if (action === "take-notes")
+                await room.takeNotes(id);
             else if (action === "staff") {
                 const participant = await room.staff(id, {
                     agentType: String(body.agentType ?? ""),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viberoom",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "viberoom: group chat rooms for a human and several coding agents over the Agent Client Protocol",
   "type": "module",
   "engines": {

package/ui/app.css

@@ -92,6 +92,49 @@
 .side-label { padding: 12px 20px 6px; font-size: 11px; text-transform: uppercase; letter-spacing: 0.1em; color: var(--faint); font-weight: 800; }
 .side-list { list-style: none; margin: 0; padding: 4px 14px 10px; overflow-y: auto; flex: 1; min-height: 0; display: flex; flex-direction: column; gap: 6px; }
 .side-list li { display: flex; align-items: center; gap: 12px; padding: 8px 10px; border-radius: 14px; cursor: pointer; transition: background var(--t-fast); animation: slide-in-left var(--t-base) var(--ease-out); }
+.participants .avatar.has-life { cursor: pointer; }
+.participants li { position: relative; }
+.participants .p-gear { position: absolute; top: 4px; right: 6px; width: 24px; height: 24px; opacity: 0; transition: opacity var(--t-fast); }
+.participants .p-gear .i { width: 14px; height: 14px; }
+.participants li:hover .p-gear, .participants li.selected .p-gear { opacity: 1; }
+.participants .life-q { position: absolute; top: -5px; right: -5px; width: 15px; height: 15px; border-radius: 50%; background: #fff; color: var(--muted); font-size: 10px; font-weight: 800; display: grid; place-items: center; box-shadow: var(--shadow-tile); }
+.participants .avatar .life { position: absolute; inset: -4px; width: calc(100% + 8px); height: calc(100% + 8px); pointer-events: none; overflow: visible; }
+.life path { fill: none; stroke-width: 3; }
+.life .life-track { stroke: var(--softer); }
+.life-unknown .life-track { stroke: var(--softer); stroke-width: 2; stroke-dasharray: 1 4; stroke-linecap: round; }
+.life .life-arc { stroke-linecap: round; transition: stroke-dasharray var(--t-base) var(--ease-out), stroke var(--t-fast); }
+.life-ok .life-arc, .life-fresh .life-arc { stroke: var(--st-ready-dot); }
+.life-warm .life-arc { stroke: var(--st-thinking-dot); }
+.life-hot .life-arc { stroke: var(--st-error-dot); }
+.participants .avatar.life-attn .life-track { stroke: var(--attention); animation: pulse 1.2s ease-in-out infinite; }
+.lp-event { display: flex; align-items: center; gap: 6px; font-size: 12px; font-weight: 700; color: var(--muted); }
+.lp-event.fresh { color: var(--attention-ink); }
+.lp-event .i { width: 14px; height: 14px; flex: none; }
+.life-pop { position: fixed; z-index: 60; display: flex; gap: 6px; align-items: flex-start; width: 330px; padding: 12px 8px 12px 14px; background: #fff; border-radius: 6px 18px 18px 18px; box-shadow: var(--shadow-pop); font-size: 13px; animation: bubble-in var(--t-base) var(--ease-out); }
+.life-pop::before { content: ""; position: absolute; left: -6px; top: 18px; width: 12px; height: 12px; background: #fff; border-radius: 0 0 0 3px; transform: rotate(45deg); }
+.life-pop .lp-main { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; gap: 10px; }
+.life-pop .lp-side { flex: none; display: flex; flex-direction: column; gap: 2px; }
+.life-pop .icon-btn.sm { width: 26px; height: 26px; }
+.lp-head { display: flex; align-items: center; gap: 10px; }
+.lp-head b { font-size: 14px; }
+.lp-sub { color: var(--muted); font-size: 12px; font-weight: 600; margin-top: 2px; }
+.lp-sub b { color: var(--ink); }
+.life-bar { height: 6px; border-radius: 3px; background: var(--softer); overflow: hidden; }
+.life-bar i { display: block; height: 100%; border-radius: 3px; transition: width var(--t-base) var(--ease-out); }
+.life-bar.life-ok i, .life-bar.life-fresh i { background: var(--st-ready-dot); }
+.life-bar.life-warm i { background: var(--st-thinking-dot); }
+.life-bar.life-hot i { background: var(--st-error-dot); }
+.life-bar.life-unknown { background: repeating-linear-gradient(90deg, var(--softer) 0 4px, transparent 4px 7px); }
+.lp-kv { font-size: 12.5px; }
+.lp-kv .i { width: 12px; height: 12px; vertical-align: -2px; }
+.lp-kv .link-btn { border: 0; background: none; padding: 0; font: inherit; font-weight: 700; color: var(--primary); cursor: pointer; }
+.lp-kv .link-btn:disabled { color: var(--muted); cursor: default; }
+.lp-editor { display: flex; flex-direction: column; gap: 6px; }
+.lp-editor textarea { width: 100%; box-sizing: border-box; font: 600 12px/1.45 var(--font); }
+.lp-notes { margin: 0; padding: 8px 10px; background: var(--soft); border-radius: 10px; font: 600 12px/1.45 var(--font); white-space: pre-wrap; max-height: 140px; overflow: auto; color: var(--ink-2); }
+.lp-respawn { display: flex; flex-direction: column; gap: 6px; align-items: flex-start; }
+.lp-with { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px; font-weight: 600; color: var(--muted); }
+.lp-with input { width: 58px; padding: 4px 6px; margin: 0; }
 .side-list li:hover { background: var(--soft); }
 .side-list li.selected { background: var(--lav); }
 .side-list li.offline .avatar .av-tile { filter: grayscale(0.6); opacity: 0.8; }
@@ -274,17 +317,17 @@
 .jump-latest { position: absolute; right: 30px; bottom: 96px; z-index: 5; display: inline-flex; align-items: center; gap: 6px; height: 34px; padding: 0 14px 0 10px; border: 0; border-radius: var(--r-pill); background: var(--card); color: var(--primary); font: inherit; font-size: 12px; font-weight: 800; box-shadow: var(--shadow-pop); cursor: pointer; animation: rise var(--t-base) var(--ease-out); }
 .jump-latest:hover { background: var(--soft); }
 .done-notes { position: absolute; left: 30px; bottom: 96px; z-index: 5; display: flex; flex-direction: column-reverse; gap: 6px; }
-.done-note { display: inline-flex; align-items: center; gap: 8px; max-width: 230px; padding: 6px 12px 6px 8px; border: 0; border-radius: 14px; background: var(--warm); color: var(--warm-ink); font: inherit; text-align: left; cursor: pointer; box-shadow: var(--shadow-pop); animation: rise var(--t-base) var(--ease-out); overflow: hidden; }
-.done-note:hover { background: var(--note-hover); }
+.done-note { display: inline-flex; align-items: center; gap: 8px; max-width: 230px; padding: 6px 12px 6px 8px; border: 0; border-radius: 14px; background: var(--done); color: var(--done-ink); font: inherit; text-align: left; cursor: pointer; box-shadow: var(--shadow-pop); animation: rise var(--t-base) var(--ease-out); overflow: hidden; }
+.done-note:hover { background: var(--done-hover); }
 .done-note .avatar { flex: none; }
 .done-go { display: inline-flex; align-items: center; gap: 8px; min-width: 0; padding: 6px 4px 6px 8px; border: 0; background: transparent; color: inherit; font: inherit; text-align: left; cursor: pointer; }
-.done-go:hover { background: var(--note-hover); }
+.done-go:hover { background: var(--done-hover); }
 .done-go .avatar { flex: none; }
 .done-text { display: flex; flex-direction: column; min-width: 0; line-height: 1.25; }
 .done-text b { font-size: 12px; font-weight: 800; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 .done-text small { font-size: 11px; font-weight: 600; opacity: 0.8; white-space: nowrap; }
 .done-x { border: 0; background: transparent; color: inherit; opacity: 0.6; font-size: 15px; line-height: 1; padding: 0 9px; cursor: pointer; }
-.done-x:hover { opacity: 1; background: var(--note-hover); }
+.done-x:hover { opacity: 1; background: var(--done-hover); }
 .jump-latest .i { width: 16px; height: 16px; }
 .bubble { max-width: 100%; background: #fff; border-radius: 6px 18px 18px 18px; padding: 12px 16px; min-width: 0; font-size: 14.5px; font-weight: 600; line-height: 1.55; color: var(--ink-2); box-shadow: 0 2px 0 rgba(28, 27, 51, 0.06), 0 1px 3px rgba(28, 27, 51, 0.04); }
 .msg.mine .bubble { background: var(--grad-primary); color: #fff; border-radius: 18px 18px 6px 18px; box-shadow: 0 8px 18px -10px rgba(91, 91, 240, 0.7); padding: 11px 16px; }
@@ -633,8 +676,8 @@ table.csv tbody tr:nth-child(even) td { background: rgba(91, 91, 240, 0.03); }
 .composer.gated textarea { cursor: not-allowed; }
 .check-list.locked { pointer-events: none; opacity: 0.6; }
 .msg.system.done { justify-content: center; }
-.done-row { display: inline-flex; align-items: center; gap: 8px; padding: 6px 14px 6px 8px; border: 0; border-radius: var(--r-pill); background: var(--warm); color: var(--warm-ink); font: inherit; font-size: 12px; font-weight: 800; cursor: pointer; box-shadow: var(--edge); }
-.done-row:hover { background: var(--note-hover); }
+.done-row { display: inline-flex; align-items: center; gap: 8px; padding: 6px 14px 6px 8px; border: 0; border-radius: var(--r-pill); background: var(--done); color: var(--done-ink); font: inherit; font-size: 12px; font-weight: 800; cursor: pointer; box-shadow: var(--edge); }
+.done-row:hover { background: var(--done-hover); }
 .done-notes { flex-direction: column; }
 .done-note.new { background: var(--card); color: var(--ink-2); }
 .done-note.new:hover { background: var(--soft); }

package/ui/app.js

@@ -555,7 +555,7 @@
   }
   function fmtTokens(n) {
     if (n === undefined || n === null) return "";
-    return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+    return n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
   }
   function fmtCost(cost) {
     return cost ? `${cost.amount.toFixed(3)} ${cost.currency}` : "";
@@ -1170,7 +1170,7 @@
       if (!li) {
         li = document.createElement("li");
         li.dataset.id = p.id;
-        li.innerHTML = avatarHtml + bodyHtml;
+        li.innerHTML = avatarHtml + bodyHtml + (p.kind === "agent" ? `<button type="button" class="icon-btn sm p-gear" title="Open ${esc(p.name)}'s panel">${ic("settings")}</button>` : "");
         li.dataset.avatar = avatarHtml;
         if (statusClass) li.querySelector(".avatar").insertAdjacentHTML("beforeend", `<span class="${statusClass}"></span>`);
         li.dataset.body = bodyHtml;
@@ -1189,10 +1189,12 @@
         }
       }
       if (li.className !== className) li.className = className;
+      if (p.kind === "agent" && !unstaffed) patchLifeRing(li, p);
       if (li !== els.participants.children[ordered.indexOf(p)]) els.participants.appendChild(li);
       rows.delete(p.id);
     }
     for (const li of rows.values()) li.remove();
+    renderLifePop();
     renderHushButton(room);
     els.reconnectAllBtn.hidden = offlineAgents(room).length === 0;
   }
@@ -1255,7 +1257,7 @@
     if (d.skill) {
       el.innerHTML = `
         <details class="hidden-turn">
-          <summary>${ic("skills")} hub ↔ ${esc(m.fromName)} · ${esc(m.text)}${d.via ? ` (${esc(d.via)})` : ""}${d.outcome ? ` · <em>${esc(d.outcome)}</em>` : ""}</summary>
+          <summary>${ic("skills")} room ↔ ${esc(m.fromName)} · ${esc(m.text)}${d.via ? ` (${esc(d.via)})` : ""}${d.outcome ? ` · <em>${esc(d.outcome)}</em>` : ""}</summary>
           <div class="hidden-body">
             ${d.original ? `<div class="hidden-label">Held reply (nobody in the room saw it)</div><div class="hidden-text">${esc(d.original)}</div>` : ""}
             <div class="hidden-label">What happened</div>
@@ -1266,7 +1268,7 @@
     }
     el.innerHTML = `
       <details class="hidden-turn">
-        <summary>${ic("tool")} hub ↔ ${esc(m.fromName)} · ${esc(m.text)}${d.outcome ? ` · <em>${esc(d.outcome)}</em>` : " · <em>waiting for the corrected reply…</em>"}</summary>
+        <summary>${ic("tool")} room ↔ ${esc(m.fromName)} · ${esc(m.text)}${d.outcome ? ` · <em>${esc(d.outcome)}</em>` : " · <em>waiting for the corrected reply…</em>"}</summary>
         <div class="hidden-body">
           <div class="hidden-label">Held reply (nobody in the room saw it)</div>
           <div class="hidden-text">${esc(d.original || "")}</div>
@@ -1937,7 +1939,8 @@
       <div class="section danger">
         ${sectionTitle("bolt", "Respawn")}
         <p class="hint">${esc(p.name)} comes back with an empty head: it forgets this conversation entirely. The room's history stays and you still see everything.${geekTip("A session's context cannot be erased, so the vibemate's process and session are closed and it starts a new one with no replay. Its stored session is dropped too, or a later reconnect would bring the old context back. Same thing as typing /respawn @Name in the composer.")}</p>
-        <div class="row-btns start"><button class="btn danger sm" data-act="respawn">${ic("bolt")}Respawn ${esc(p.name)}</button></div>
+        <div class="row-btns start"><button class="btn danger sm" data-act="respawn">${ic("bolt")}Respawn ${esc(p.name)}</button><label class="lp-with"><button type="button" class="btn sm" data-act="respawn-mem">With the last</button><input type="number" id="pp-respawn-n" min="0" max="500" value="${room.settings.replayAfterRestart ?? 10}"> messages</label></div>
+        <p class="hint">With memory: a new session that gets only ${p.notes ? "its own notes and " : ""}the last N messages of this room; the rest is gone.</p>
       </div>
       <div class="section">
         ${sectionTitle("info", "Stats")}
@@ -1957,17 +1960,9 @@
       )}`;
     wireDetailsClose();
     const respawnBtn = els.detailsInner.querySelector('button[data-act="respawn"]');
-    if (respawnBtn) {
-      respawnBtn.addEventListener("click", async () => {
-        const ok = await confirmDialog(`${p.name} forgets this whole conversation and starts over. You keep the history; it does not.`, { title: `Respawn ${p.name}?`, okLabel: "Respawn", danger: true });
-        if (!ok) return;
-        try {
-          await post(roomApi(`/participants/${encodeURIComponent(p.id)}/respawn`));
-        } catch (e) {
-          showError(e);
-        }
-      });
-    }
+    if (respawnBtn) respawnBtn.addEventListener("click", () => respawnWith(p, 0));
+    const respawnMem = els.detailsInner.querySelector('button[data-act="respawn-mem"]');
+    if (respawnMem) respawnMem.addEventListener("click", () => respawnWith(p, Number($("#pp-respawn-n").value) || 0));
     els.detailsInner.querySelectorAll(".action").forEach((btn) => {
       btn.addEventListener("click", async () => {
         const act = btn.dataset.act;
@@ -3657,6 +3652,13 @@
     if (!li || !room) return;
     const p = findById(room, li.dataset.id);
     if (!p) return;
+    if (p.kind === "agent" && p.status !== "unstaffed" && e.target.closest(".avatar")) {
+      if (!lifePop || lifePop.id !== p.id) openLifePop(p, li);
+      else if (lifePop.hover) lifePop.hover = false;
+      else closeLifePop();
+      return;
+    }
+    if (e.target.closest(".p-gear")) return openDetails({ kind: "participant", id: p.id });
     if (e.target.closest(".stop-btn")) return void post(roomApi(`/participants/${encodeURIComponent(p.id)}/cancel`)).catch(showError);
     if (e.target.closest(".reconnect-btn")) return openReconnectDialog(room);
     if (e.target.closest("button")) return;
@@ -4366,6 +4368,181 @@
     else scrollToBottom();
   });
 
+  function lifeOf(p) {
+    if (!p.contextSize) return (p.turns || 0) === 0 && !p.contextUsed ? { left: 100, tone: "fresh" } : { left: null, tone: "unknown" };
+    const left = Math.max(0, Math.min(100, 100 - Math.round((100 * (p.contextUsed || 0)) / p.contextSize)));
+    return { left, tone: left <= 20 ? "hot" : left <= 50 ? "warm" : "ok" };
+  }
+  const LIFE_PATH = "M26 2.5H32.5A17 17 0 0 1 49.5 19.5V32.5A17 17 0 0 1 32.5 49.5H19.5A17 17 0 0 1 2.5 32.5V19.5A17 17 0 0 1 19.5 2.5H26";
+  const LIFE_RING = `<svg class="life" viewBox="0 0 52 52" aria-hidden="true"><path class="life-track" d="${LIFE_PATH}" pathLength="100"/><path class="life-arc" d="${LIFE_PATH}" pathLength="100"/></svg>`;
+  function patchLifeRing(li, p) {
+    const av = li.querySelector(".avatar");
+    if (!av) return;
+    let ring = av.querySelector(".life");
+    if (!ring) {
+      av.insertAdjacentHTML("afterbegin", LIFE_RING);
+      ring = av.querySelector(".life");
+      av.classList.add("has-life");
+    }
+    const { left, tone } = lifeOf(p);
+    const cls = `life life-${tone}`;
+    if (ring.getAttribute("class") !== cls) ring.setAttribute("class", cls);
+    ring.querySelector(".life-arc").style.strokeDasharray = left === null ? "0 100" : `${left} 100`;
+    const q = av.querySelector(".life-q");
+    if (tone === "unknown" && !q) av.insertAdjacentHTML("beforeend", '<span class="life-q" title="This agent does not report its context">?</span>');
+    else if (tone !== "unknown" && q) q.remove();
+    const ev = recentContextEvent(p);
+    av.classList.toggle("life-attn", !!ev && ev.kind !== "threshold");
+    av.title = (tone === "fresh" ? "Context: fresh, nothing used yet." : tone === "unknown" ? "Context: not reported by this agent." : `Context ${fmtTokens(p.contextUsed)} of ${fmtTokens(p.contextSize)} used · ${left} % left.`) + (ev ? ` ${contextEventText(p, ev)}.` : "") + " Click for details.";
+  }
+  const CONTEXT_EVENT_FRESH_MS = 15 * 60 * 1000;
+  function recentContextEvent(p) {
+    const ev = p.contextEvent;
+    return ev && Date.now() - ev.at < CONTEXT_EVENT_FRESH_MS ? ev : null;
+  }
+  function contextEventText(p, ev) {
+    const when = new Date(ev.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+    if (ev.kind === "compacted") return `Compacted its context at ${when} (now ${fmtTokens(ev.used)})`;
+    if (ev.kind === "full") return `Ran out of context at ${when}; respawned with memory`;
+    return `Over 80 % since ${when}; leaves notes with its replies`;
+  }
+  let lifePop = null;
+  let hoverTimer = null;
+  function openLifePop(p, li, hover) {
+    closeLifePop();
+    const el = document.createElement("div");
+    el.className = "life-pop";
+    document.body.appendChild(el);
+    lifePop = { id: p.id, anchor: li.querySelector(".avatar"), el, n: null, hover: !!hover };
+    el.addEventListener("mouseenter", () => clearTimeout(hoverTimer));
+    el.addEventListener("mouseleave", () => lifePop && lifePop.hover && scheduleHoverClose());
+    renderLifePop();
+  }
+  function scheduleHoverClose() {
+    clearTimeout(hoverTimer);
+    hoverTimer = setTimeout(() => {
+      if (lifePop && lifePop.hover && !lifePop.el.matches(":hover") && !lifePop.anchor.matches(":hover")) closeLifePop();
+    }, 180);
+  }
+  els.participants.addEventListener("mouseover", (e) => {
+    const av = e.target.closest("li[data-id] .avatar");
+    const li = av && av.closest("li[data-id]");
+    if (!av || (e.relatedTarget && av.contains(e.relatedTarget))) return;
+    const room = currentRoom();
+    const p = room && findById(room, li.dataset.id);
+    if (!p || p.kind !== "agent" || p.status === "unstaffed") return;
+    clearTimeout(hoverTimer);
+    if (lifePop && lifePop.id === p.id) return;
+    hoverTimer = setTimeout(() => {
+      if (!lifePop || lifePop.hover) openLifePop(p, li, true);
+    }, 220);
+  });
+  els.participants.addEventListener("mouseout", (e) => {
+    const av = e.target.closest("li[data-id] .avatar");
+    const li = av && av.closest("li[data-id]");
+    if (!av || (e.relatedTarget && av.contains(e.relatedTarget))) return;
+    clearTimeout(hoverTimer);
+    if (lifePop && lifePop.hover && lifePop.id === li.dataset.id) scheduleHoverClose();
+  });
+  function closeLifePop() {
+    if (!lifePop) return;
+    lifePop.el.remove();
+    lifePop = null;
+  }
+  function renderLifePop() {
+    if (!lifePop) return;
+    const room = currentRoom();
+    const p = room && findById(room, lifePop.id);
+    if (!p || state.view !== "room" || !lifePop.anchor.isConnected) return closeLifePop();
+    const el = lifePop.el;
+    if (el.contains(document.activeElement)) return;
+    const { left, tone } = lifeOf(p);
+    const last = [...room.messages].reverse().find((m) => m.from === p.id && m.usage);
+    const n = lifePop.n ?? room.settings.replayAfterRestart ?? 10;
+    el.innerHTML = `<div class="lp-main">
+        <div class="lp-head">${avatar(p, 28, {})}<div><b>${esc(p.name)}</b><div class="lp-sub">${tone === "fresh" ? "fresh session: nothing used yet" : tone === "unknown" ? "context not reported by this agent" : `context ${fmtTokens(p.contextUsed)} of ${fmtTokens(p.contextSize)} used · <b>${left} % left</b>`}</div></div></div>
+        <div class="life-bar life-${tone}"><i style="width:${left ?? 0}%"></i></div>
+        ${p.contextEvent ? `<div class="lp-event${recentContextEvent(p) && p.contextEvent.kind !== "threshold" ? " fresh" : ""}">${ic("info")} ${esc(contextEventText(p, p.contextEvent))}</div>` : ""}
+        <div class="kv lp-kv">
+          <span>Turns</span><span>${p.turns}</span>
+          <span>Last reply</span><span>${last ? `<span title="tokens in">${ic("arrow-down")} ${fmtTokens(last.usage.inputTokens)}</span> <span title="tokens out">${ic("arrow-up")} ${fmtTokens(last.usage.outputTokens)}</span>` : "—"}</span>
+          <span>Cost (estimate)</span><span>${fmtCost(p.cost) || "—"}</span>
+          <span>Briefs sent</span><span>${p.briefsSent ?? 0}</span>
+          <span>Notes</span><span>${p.notes ? `taken at ${fmtTokens(p.notesAt || 0)} tokens` : "none yet"}${p.status === "offline" || p.status === "unstaffed" ? "" : ` · <button type="button" class="link-btn lp-take" title="A hidden turn: the vibemate writes 10 lines for a future restart; nothing is posted">${p.notes ? "refresh" : "take now"}</button>`}${p.notes ? ` · <button type="button" class="link-btn lp-edit">edit</button>` : ""}</span>
+        </div>
+        ${p.notes ? `<pre class="lp-notes">${esc(p.notes)}</pre><div class="lp-editor" hidden><textarea class="lp-notes-area" rows="6" maxlength="4000">${esc(p.notes)}</textarea><div class="row-btns"><button type="button" class="btn sm ghost lp-notes-clear">Clear</button><button type="button" class="btn sm primary lp-notes-save">Save</button></div></div>` : ""}
+        <div class="lp-respawn">
+          <button type="button" class="btn sm danger lp-empty" title="A new session that knows nothing of this conversation">${ic("bolt")}Respawn, empty head</button>
+          <label class="lp-with"><button type="button" class="btn sm lp-mem" title="A new session that re-reads only the last N messages${p.notes ? " and its own notes" : ""}">Respawn with the last</button><input type="number" class="lp-n" min="0" max="500" value="${n}"> messages</label>
+        </div>
+      </div>
+      <div class="lp-side"><button type="button" class="icon-btn sm lp-x" title="Close">${ic("close")}</button><button type="button" class="icon-btn sm lp-more" title="Open this vibemate's panel">${ic("settings")}</button></div>`;
+    el.querySelector(".lp-x").addEventListener("click", closeLifePop);
+    el.querySelector(".lp-more").addEventListener("click", () => {
+      closeLifePop();
+      openDetails({ kind: "participant", id: p.id });
+    });
+    el.querySelector(".lp-empty").addEventListener("click", () => respawnWith(p, 0));
+    el.querySelector(".lp-mem").addEventListener("click", () => respawnWith(p, Number(el.querySelector(".lp-n").value) || 0));
+    el.querySelector(".lp-n").addEventListener("input", (e) => (lifePop.n = Number(e.target.value) || 0));
+    const take = el.querySelector(".lp-take");
+    if (take)
+      take.addEventListener("click", async () => {
+        take.disabled = true;
+        take.textContent = "asking…";
+        try {
+          await post(roomApi(`/participants/${encodeURIComponent(p.id)}/take-notes`));
+        } catch (e) {
+          showError(e);
+          renderLifePop();
+        }
+      });
+    const edit = el.querySelector(".lp-edit");
+    if (edit)
+      edit.addEventListener("click", () => {
+        el.querySelector(".lp-notes").hidden = true;
+        el.querySelector(".lp-editor").hidden = false;
+        el.querySelector(".lp-notes-area").focus();
+      });
+    const saveNotes = async (text) => {
+      try {
+        await post(roomApi(`/participants/${encodeURIComponent(p.id)}/notes`), { notes: text });
+      } catch (e) {
+        showError(e);
+      }
+      el.querySelector(".lp-notes-area").blur();
+      renderLifePop();
+    };
+    const save = el.querySelector(".lp-notes-save");
+    if (save) save.addEventListener("click", () => saveNotes(el.querySelector(".lp-notes-area").value));
+    const clear = el.querySelector(".lp-notes-clear");
+    if (clear) clear.addEventListener("click", () => saveNotes(""));
+    const z = zoomFactor();
+    const r = lifePop.anchor.getBoundingClientRect();
+    el.style.left = `${Math.round((r.right + 12) / z)}px`;
+    el.style.top = `${Math.round(Math.max(8, Math.min(r.top / z - 10, window.innerHeight / z - el.offsetHeight - 8)))}px`;
+  }
+  async function respawnWith(p, n) {
+    const text =
+      n > 0
+        ? `${p.name} starts over with a new session that gets only ${p.notes ? "its own notes and " : ""}the last ${n} messages of this room. You keep the history; the rest of its memory is gone.`
+        : `${p.name} forgets this whole conversation and starts over. You keep the history; it does not.`;
+    const ok = await confirmDialog(text, { title: `Respawn ${p.name}?`, okLabel: "Respawn", danger: true });
+    if (!ok) return;
+    closeLifePop();
+    try {
+      await post(roomApi(`/participants/${encodeURIComponent(p.id)}/respawn`), { memory: n > 0, replay: n });
+    } catch (e) {
+      showError(e);
+    }
+  }
+  document.addEventListener("click", (e) => {
+    if (lifePop && !e.target.closest(".life-pop") && !e.target.closest("#participants .avatar")) closeLifePop();
+  });
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && lifePop) closeLifePop();
+  });
+
   const pinsBtn = $("#pins-btn");
   const pinsPanel = $("#pins-panel");
   function pinnedMessages(room) {

package/ui/theme.css

@@ -67,6 +67,9 @@
   --attention-shadow: 0 8px 18px -10px rgba(232, 100, 42, 0.7);
   --unread-grad: linear-gradient(135deg, #ff7a45, #f0452c);
   --note-hover: #ffeaa8;
+  --done: var(--st-ready);
+  --done-ink: var(--st-ready-ink);
+  --done-hover: #c4efdb;
   --tick-mine: #cdcdf9;
   --tick-mine-view: #a9a9f5;
   --tick-fallback: #9ca3af;