letagents 0.12.35 → 0.12.36

package/dist/mcp/server/runtime/workspace-capture.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import { Worker } from 'node:worker_threads';
 import { parseRoomAgentWorkSummary } from '../../../../shared/room-agent-work.mjs';
 import { REVIEW_LIMIT, REVIEW_PAGE_SIZE } from '../../../../shared/workspace-review.mjs';
-import { releaseWorkspaceTree } from '../../../../shared/workspace-turn-capture.mjs';
+import { captureRemoteTips, releaseWorkspaceTree } from '../../../../shared/workspace-turn-capture.mjs';
 import { getLocalStatePath, readLocalStateSnapshot, updateLocalState } from '../../local-state/storage.js';
 import { assertWorkerConnection } from '../../worker-call-context.js';
 import { encodeRoomIdPath } from '../../room-id.js';
@@ -18,6 +18,8 @@ import { requireValidWorkerBearerRuntime } from './worker-bearer.js';
 const execute = promisify(execFile);
 const activeCalls = new Set();
 let captureWorkerActive = false;
+// What the remotes held when each capture began. Memory only: after a restart the capture is compared plainly.
+const remoteTips = new Map();
 const validId = (id) => /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(id);
 const directory = (id) => join(`${getLocalStatePath()}.workspaces`, id);
 const preparationDirectory = (capture) => {
@@ -70,7 +72,7 @@ async function exclusive(key, operation) {
         activeCalls.delete(key);
     }
 }
-async function runCapture(operation, capture, text) {
+async function runCapture(operation, capture, text, tips = null) {
     if (captureWorkerActive)
         throw new Error('Another workspace is being captured. Retry shortly; the original baseline is preserved.');
     captureWorkerActive = true;
@@ -78,7 +80,7 @@ async function runCapture(operation, capture, text) {
     try {
         return await new Promise((resolve, reject) => {
             worker = new Worker(new URL('../../../../shared/mcp-workspace-capture-worker.mjs', import.meta.url), {
-                execArgv: [], workerData: { operation, capture, text, directory: operation === 'finish' ? preparationDirectory(capture) : null },
+                execArgv: [], workerData: { operation, capture, text, remoteTips: tips, directory: operation === 'finish' ? preparationDirectory(capture) : null },
             });
             const timeout = setTimeout(() => { reject(new Error('Capture exceeded its time limit. Retry using the same capture_id.')); void worker?.terminate(); }, 120_000);
             worker.once('message', result => { clearTimeout(timeout); result.error ? reject(new Error(result.error)) : resolve(result); });
@@ -111,6 +113,10 @@ export async function beginWorkspaceCapture(input) {
                 instruction: 'Continue this capture. Keep its capture_id and call publish_workspace_capture when finished.',
                 ...(prior.baseline ? {} : { warning: 'The starting snapshot is unavailable. Exact changes for this piece of work cannot be attributed.' }) };
         }
+        // Asked before the work starts, and not awaited: a slow remote must not delay it. The remotes
+        // are the ones this clone configures: nothing outside the clone records where it came from,
+        // and an independent worker reports its own work. (The supervisor daemon asks its own record.)
+        const tips = captureRemoteTips(workspace);
         const baseRevision = await git(['rev-parse', '--verify', 'HEAD']);
         const capture = { capture_id: randomUUID(), api_url: getApiUrl(), room_id: session.room_id,
             agent_key: session.agent_key, agent_instance_id: session.agent_instance_id, workspace, base_revision: baseRevision,
@@ -125,8 +131,11 @@ export async function beginWorkspaceCapture(input) {
                     delete records[id];
             records[capture.capture_id] = capture;
         });
-        for (const record of obsolete)
+        for (const record of obsolete) {
+            remoteTips.delete(record.capture_id);
             await rm(directory(record.capture_id), { recursive: true, force: true });
+        }
+        remoteTips.set(capture.capture_id, tips);
         try {
             const result = await runCapture('begin', capture);
             capture.baseline = result.baseline ?? null;
@@ -176,7 +185,7 @@ export async function publishWorkspaceCapture(input) {
                 throw new Error('Supply a short summary of at most 400 characters.');
             const candidate = { ...capture, preparation_id: randomUUID() };
             try {
-                await runCapture('finish', candidate, text);
+                await runCapture('finish', candidate, text, await remoteTips.get(capture.capture_id) ?? null);
                 await preparedCapture(candidate);
                 // Commit one immutable preparation under the same lock that fences
                 // reconnects. Stale processes only write their own disposable directory.
@@ -247,6 +256,7 @@ export async function publishWorkspaceCapture(input) {
             if (capture.next_page === total) {
                 capture = { ...capture, phase: 'published' };
                 persist();
+                remoteTips.delete(capture.capture_id);
                 await rm(directory(capture.capture_id), { recursive: true, force: true });
             }
             return { status: capture.phase === 'published' ? 'published' : 'uploading', capture_id: capture.capture_id,
@@ -259,6 +269,7 @@ export async function publishWorkspaceCapture(input) {
             if (error instanceof ApiError && error.status === 410) {
                 capture = { ...capture, phase: 'blocked' };
                 persist();
+                remoteTips.delete(capture.capture_id);
                 await rm(directory(capture.capture_id), { recursive: true, force: true });
             }
             throw error;

package/dist/mcp/server/tools/supervised-room-turn.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 const MAX_ROOM_REPLY_BYTES = 32 * 1024;
 /** Select routing only; the daemon remains the sole final-answer publisher. */
 export function registerReplyThreadTool(server) {
-    const tool = server.tool("set_reply_thread", "Place your final answer in the activating room message's thread. Takes no arguments, sends no message, and does not finish the turn. Continue working and use your normal final completion when ready. Unavailable for synthetic task continuations or corrections.", {}, async () => { throw new Error("set_reply_thread requires the active daemon-owned room turn."); });
+    const tool = server.tool("set_reply_thread", "Opt into a new thread for your final answer only when the user asks for one or a sustained side discussion would distract from the room. Answer ordinary top-level questions in the main room by default, without this tool; existing thread replies stay threaded automatically. Takes no arguments, sends no message, and does not finish the turn. Continue working and use your normal final completion when ready. Unavailable for synthetic task continuations or corrections.", {}, async () => { throw new Error("set_reply_thread requires the active daemon-owned room turn."); });
     // The legacy raw-shape overload strips unknown keys. Preserve a strict schema
     // so a caller cannot mistake ignored room/recipient/text arguments for authority.
     tool.inputSchema = z.object({}).strict();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.35",
+  "version": "0.12.36",
   "description": "Let Agents Chat \u2014 MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -50,7 +50,7 @@
   },
   "license": "BUSL-1.1",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.27.1",
+    "@modelcontextprotocol/sdk": "1.31.0",
     "drizzle-orm": "0.45.2",
     "express": "5.2.1",
     "pg": "8.20.0",
@@ -71,6 +71,8 @@
     },
     "fast-uri": "3.1.8",
     "hono": "4.13.8",
-    "ip-address": "10.7.2"
+    "ip-address": "10.7.2",
+    "@modelcontextprotocol/sdk": "1.31.0",
+    "proxy-addr": "2.0.8"
   }
 }

package/shared/activation-routing.d.mts

@@ -18,13 +18,33 @@ export declare function humanConversationFallback(input: {
  * channel for a managed local worker.
  */
 export declare function isUntrustedExternalActivationSource(source: unknown): boolean;
+export interface AgentMessageReplyTurn {
+    /** 1-based position in the reply order; only positions 2 and later are sent. */
+    position: number;
+    count: number;
+    /** Labels of the agents before this one that answered, in turn order. */
+    prior_speakers: string[];
+}
 export interface AgentMessageActivation {
     for_current_agent: {
         decision: AgentMessageActivationDecision;
         reason: AgentMessageActivationReason;
         addressed: boolean;
+        turn?: AgentMessageReplyTurn;
+        guidance?: string;
     };
 }
+/** A receipt as the activation authority sees it. Turn fields are optional. */
+export type AgentMessageActivationReceipt = {
+    activation_reason: string;
+    turn_position?: number | null;
+    turn_count?: number | null;
+    prior_speakers?: readonly string[] | null;
+    /** Why the held turn was released: "turn", "deadline", "activation" or "skipped". */
+    hold_release_reason?: string | null;
+};
+/** The turn note for an agent that answers a shared message after others. */
+export declare function replyTurnGuidance(position: number, count: number, priorSpeakers?: readonly string[], releaseReason?: string | null): string;
 type MessageLike = {
     id?: unknown;
     sender?: unknown;
@@ -85,9 +105,7 @@ export declare function attachAgentMessageActivation<T extends MessageLike>(mess
  * Only messages that predate routing snapshots keep the lazy per-reader
  * decision, so legacy backlog mentions still activate rotated sessions.
  */
-export declare function attachAgentMessageActivationsFromReceipts<T extends MessageLike>(messages: readonly T[], identity: ActivationIdentity | null, receiptsMap: ReadonlyMap<number | string, {
-    activation_reason: string;
-}>, snapshotNumbers: ReadonlySet<number>, context?: AgentMessageActivationContext): T[] | Array<T & {
+export declare function attachAgentMessageActivationsFromReceipts<T extends MessageLike>(messages: readonly T[], identity: ActivationIdentity | null, receiptsMap: ReadonlyMap<number | string, AgentMessageActivationReceipt>, snapshotNumbers: ReadonlySet<number>, context?: AgentMessageActivationContext): T[] | Array<T & {
     activation: AgentMessageActivation;
 }>;
 export declare function attachAgentMessageActivations<T extends MessageLike>(messages: readonly T[], identity: ActivationIdentity | null, context?: AgentMessageActivationContext): T[] | Array<T & {

package/shared/activation-routing.mjs

@@ -80,6 +80,7 @@ export function attachAgentMessageActivationsFromReceipts(messages, identity, re
                         decision: "activate",
                         reason: reason || "explicit_mention",
                         addressed: true,
+                        ...replyTurnActivationFields(receipt),
                     },
                 },
             };
@@ -103,6 +104,42 @@ export function attachAgentMessageActivationsFromReceipts(messages, identity, re
         return attachAgentMessageActivation(message, identity, context);
     });
 }
+/**
+ * The turn note for an agent that answers a shared message after others.
+ * Desktop adapters print `for_current_agent` into the prompt verbatim, so this
+ * text reaches the model without a client change.
+ */
+export function replyTurnGuidance(position, count, priorSpeakers = [], releaseReason = null) {
+    const opening = `Turn order: you answer this message in position ${position} of ${count}.`;
+    const speakers = priorSpeakers.filter((speaker) => typeof speaker === "string" && speaker.trim());
+    if (speakers.length === 0) {
+        // Say "did not answer in time" only when that is what happened. A
+        // turn opened by a direct activation, or after agents that ended with
+        // nothing to say, may still have earlier agents at work.
+        return releaseReason === "deadline"
+            ? `${opening} The agent before you did not answer in time. Answer now.`
+            : `${opening} The agents before you have not answered yet. Cover only what they are unlikely to say.`;
+    }
+    const names = speakers.length === 1
+        ? speakers[0]
+        : `${speakers.slice(0, -1).join(", ")} and ${speakers.at(-1)}`;
+    const replies = speakers.length === 1 ? "their reply is" : "their replies are";
+    return `${opening} ${names} answered before you; ${replies} in the recent room context.`
+        + " Do not repeat their points. Add only new points, agree in one short line, or disagree and give the reason.";
+}
+/** Position 1 and parallel receipts add nothing; later positions add turn and guidance. */
+function replyTurnActivationFields(receipt) {
+    const position = Number(receipt.turn_position);
+    const count = Number(receipt.turn_count);
+    if (!Number.isSafeInteger(position) || !Number.isSafeInteger(count) || position < 2 || count < position) {
+        return {};
+    }
+    const priorSpeakers = Array.isArray(receipt.prior_speakers) ? receipt.prior_speakers : [];
+    return {
+        turn: { position, count, prior_speakers: [...priorSpeakers] },
+        guidance: replyTurnGuidance(position, count, priorSpeakers, receipt.hold_release_reason ?? null),
+    };
+}
 export function attachAgentMessageActivations(messages, identity, context = {}) {
     if (!identity || identity.session_kind !== "worker") {
         return [...messages];

package/shared/codex-owner-isolation.mjs

@@ -9,8 +9,10 @@ import { join, parse } from "node:path";
 // The owner's config, auth and session history are not modified, and the
 // project's own skills and AGENTS.md still load. Codex has no launch switch
 // for its global AGENTS.md or its saved command rules, so those still reach
-// the agent. Shared by the desktop and the published MCP package, so it uses
-// nothing but Node.
+// the agent. A matching saved rule lets a command out of Codex's sandbox, so
+// the desktop gives an agent at a sandboxed access level a Codex home that has
+// none (codex-agent-home.ts). Shared by the desktop and the published MCP
+// package, so it uses nothing but Node.
 
 /** Plugins (with their MCP servers and skills), app connectors, computer and browser use, hooks, memories, notifier. */
 export const CODEX_OWNER_FEATURE_OVERRIDES = Object.freeze([

package/shared/codex-read-only-room-tools.d.mts

@@ -0,0 +1,2 @@
+/** The room tools a Read-only Codex agent may use; every other room tool is refused for it. */
+export const CODEX_READ_ONLY_ROOM_TOOLS: ReadonlySet<string>;

package/shared/codex-read-only-room-tools.mjs

@@ -0,0 +1,24 @@
+/**
+ * The room tools a Read-only Codex agent may use, and the only ones.
+ *
+ * These read what the room says, and say something in it: a message, a
+ * status, visible reasoning, a question for a person, and where the final
+ * answer goes. Each takes room identifiers and text, never a folder. None
+ * changes the task board, joins or creates a room, submits a review, saves
+ * room memory, sets a wake rule, or inspects or writes a repository on this
+ * Mac. A tool is allowed only by being named here, so one the room server
+ * gains later is refused until someone decides about it.
+ *
+ * Two places keep the list, and both read it from here. Codex is told to run
+ * these without asking and to refuse the others, since a Read-only agent has
+ * nobody to ask. The background service refuses the others itself, where
+ * every room tool call of such an agent passes, so the limit does not rest on
+ * what Codex does with an approval mode.
+ */
+export const CODEX_READ_ONLY_ROOM_TOOLS = new Set([
+  // What the room says.
+  "read_messages", "get_current_room", "get_room_guidelines", "get_room_memory", "get_human_requests",
+  "get_board", "get_board_settings", "list_board_intents", "list_wake_rules", "get_room_artifacts", "get_room_events",
+  // What the agent says in it.
+  "send_message", "send_thread_message", "post_status", "post_reasoning", "request_human_input", "set_reply_thread",
+]);

package/shared/mcp-workspace-capture-worker.mjs

@@ -12,7 +12,8 @@ try {
   if (workerData.operation === 'begin') {
     parentPort.postMessage({ baseline: await captureWorkspaceTree(capture.workspace, identity) });
   } else {
-    const pair = await captureWorkspacePair(capture.workspace, capture.base_revision, capture.baseline, `${identity}:${capture.preparation_id}`);
+    // The starting snapshot was taken on `base_revision`. With what the remotes held then, it tells a base update from the work.
+    const pair = await captureWorkspacePair(capture.workspace, capture.base_revision, capture.baseline, `${identity}:${capture.preparation_id}`, capture.base_revision, workerData.remoteTips ?? null);
     pair.contribution.summary = text;
     const { review, ...preview } = pair;
     const summary = { version: 3, recorded_state: 'completed', evidence_incomplete: true, elapsed_ms: null,

package/shared/message-link-previews.d.mts

@@ -5,6 +5,7 @@ export interface GitHubLinkReference extends LinkPreviewReference { repository:
 export interface MessageLinkPreview extends GitHubLinkReference { title: string; state: "merged" | "closed" | "draft" | "open" }
 export interface MessageLinkPreviewsResponse { room_id: string; previews: MessageLinkPreview[]; available?: boolean }
 export function parseGitHubLinkReference(value: unknown): GitHubLinkReference | null;
+export function excludeGitHubEventLink(urls: readonly string[], eventUrl: string | null | undefined): string[];
 export function normalizePreviewRepository(value: unknown): string | null;
 export function linkPreviewKey(reference: LinkPreviewReference): string;
 export function parseLinkPreviewReferences(value: unknown): LinkPreviewReference[] | null;

package/shared/message-link-previews.mjs

@@ -16,6 +16,12 @@ export function parseGitHubLinkReference(value) {
   } catch { return null; }
 }
 
+/** The event card already represents its main PR/issue; keep any other links. */
+export function excludeGitHubEventLink(urls, eventUrl) {
+  const represented = parseGitHubLinkReference(eventUrl);
+  return urls.filter(url => !represented || parseGitHubLinkReference(url)?.url !== represented.url);
+}
+
 export function normalizePreviewRepository(value) {
   if (typeof value !== "string") return null;
   const name = value.replace(/^https:\/\//i, "").replace(/^github\.com\//i, "").replace(/\/$/, "");

package/shared/room-settings.d.mts

@@ -46,3 +46,19 @@ export declare function estimateRoomAgentGuidelineTokens(value: unknown): number
 export declare function normalizeGitHubRoomChatEventKinds(value: unknown): GitHubRoomChatEventKind[] | null;
 /** The kind a repository event is filed under, or null when it has none. */
 export declare function githubRoomChatEventKind(event: { kind?: string } | null | undefined): GitHubRoomChatEventKind | null;
+
+export type RoomAgentReplyOrder = "sequential" | "parallel";
+export declare const ROOM_AGENT_REPLY_ORDERS: readonly RoomAgentReplyOrder[];
+export declare const DEFAULT_ROOM_AGENT_REPLY_ORDER: RoomAgentReplyOrder;
+
+export interface RoomAgentReplyOrderSetting {
+  room_id: string;
+  /** The order that applies; "parallel" when the room has not chosen. */
+  order: RoomAgentReplyOrder;
+  /** Whether a room admin chose it, rather than the default applying. */
+  chosen: boolean;
+  can_manage: boolean;
+}
+
+/** A known order, or null when the input is not one. */
+export declare function normalizeRoomAgentReplyOrder(value: unknown): RoomAgentReplyOrder | null;

package/shared/room-settings.mjs

@@ -106,3 +106,17 @@ export function githubRoomChatEventKind(event) {
       return null;
   }
 }
+
+/**
+ * How agents answer a message that activates several of them at once (a
+ * broadcast, or the small-room fallback). "parallel" — the default when a
+ * room has not chosen — wakes them all together; "sequential", which a room
+ * admin turns on, gives each agent a turn after the one before has answered.
+ */
+export const ROOM_AGENT_REPLY_ORDERS = Object.freeze(["sequential", "parallel"]);
+export const DEFAULT_ROOM_AGENT_REPLY_ORDER = "parallel";
+
+/** A known order, or null when the input is not one. */
+export function normalizeRoomAgentReplyOrder(value) {
+  return ROOM_AGENT_REPLY_ORDERS.includes(value) ? value : null;
+}

package/shared/room-typing.d.mts

@@ -9,8 +9,10 @@ export function createTypingSender(options: {
   schedule?: (callback: () => void, ms: number) => any; cancel?: (timer: any) => void;
 }): { input(nonempty: boolean): void; stop(): void };
 export function createTypingReceiver(now?: () => number): {
-  receive(raw: unknown, self: string | null): void; clear(): void; label(): string; nextExpiry(): number | null;
+  receive(raw: unknown, self: string | null): void; clear(): void; names(): string[]; label(): string; nextExpiry(): number | null;
 };
-export function createTypingDisplay(update: (label: string) => void, clock?: {
+export function typingLabel(names: readonly string[]): string;
+export function typingSentence(names: readonly string[]): Array<{ text: string; name: boolean }>;
+export function createTypingDisplay(update: (label: string, names: string[]) => void, clock?: {
   now?: () => number; schedule?: (callback: () => void, ms: number) => any; cancel?: (timer: any) => void;
 }): { receive(raw: unknown, self: string | null): void; clear(): void };

package/shared/room-typing.mjs

@@ -60,6 +60,22 @@ export function createTypingSender({ send, clientId, now = Date.now, schedule =
   };
 }
 
+/** Plain-text sentence for assistive technology and compact surfaces. */
+export function typingLabel(names) {
+  if (names.length > 2) return 'Several people are typing…';
+  return names.length ? `${names.join(' and ')} ${names.length === 1 ? 'is' : 'are'} typing…` : '';
+}
+
+/** The same sentence as parts, so a view can emphasise names without building HTML. */
+export function typingSentence(names) {
+  const name = text => ({ text, name: true }), plain = text => ({ text, name: false });
+  if (names.length === 1) return [name(names[0]), plain(' is typing')];
+  if (names.length === 2) return [name(names[0]), plain(' and '), name(names[1]), plain(' are typing')];
+  if (names.length < 3) return [];
+  const others = names.length - 2;
+  return [name(names[0]), plain(', '), name(names[1]), plain(` and ${others} ${others === 1 ? 'other' : 'others'} are typing`)];
+}
+
 /** Sequence guards survive stops briefly; no snapshot or replay. */
 export function createTypingReceiver(now = Date.now) {
   const sources = new Map();
@@ -81,16 +97,16 @@ export function createTypingReceiver(now = Date.now) {
       }
       return Number.isFinite(earliest) ? earliest : null;
     },
-    label() {
+    /** One name per account, in a stable order, so a row does not reshuffle between refreshes. */
+    names() {
       const people = new Map();
       for (const [key, value] of sources) {
         if (value.forget <= now()) sources.delete(key);
         else if (value.typing && value.until > now()) people.set(value.account_id, value.name);
       }
-      const names = [...people].sort(([a], [b]) => a.localeCompare(b)).map(([, name]) => name);
-      if (names.length > 2) return 'Several people are typing…';
-      return names.length ? `${names.join(' and ')} ${names.length === 1 ? 'is' : 'are'} typing…` : '';
+      return [...people].sort(([a], [b]) => a.localeCompare(b)).map(([, name]) => name);
     },
+    label() { return typingLabel(this.names()); },
   };
 }
 
@@ -101,7 +117,8 @@ export function createTypingDisplay(update, { now = Date.now, schedule = setTime
   function refresh() {
     if (timer !== null) cancel(timer);
     timer = null;
-    update(receiver.label());
+    const names = receiver.names();
+    update(typingLabel(names), names);
     const expiry = receiver.nextExpiry();
     if (expiry !== null) timer = schedule(refresh, Math.max(0, expiry - now()));
   }

package/shared/ui/GitHubEventCard.vue

@@ -0,0 +1,229 @@
+<template>
+  <article class="github-event-card" :class="{ 'is-preview': compact, 'is-room-event': room, 'is-activity': room && !['pull-request', 'issue'].includes(event.kind) }" :data-tone="event.tone" :data-kind="event.kind" :data-status="event.statusLabel">
+    <div class="github-event-header">
+      <svg class="github-event-icon" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+        <template v-if="event.kind === 'pull-request'">
+          <circle cx="4" cy="3" r="1.5" /><circle cx="4" cy="13" r="1.5" /><circle cx="12" cy="13" r="1.5" />
+          <path d="M4 4.5v7M12 11.5V6a3 3 0 0 0-3-3H8m2-2L8 3l2 2" />
+        </template>
+        <template v-else-if="event.kind === 'issue'">
+          <circle cx="8" cy="8" r="5.5" /><path d="M8 5v3M8 11h.01" />
+        </template>
+        <template v-else-if="event.kind === 'review' || event.kind === 'comment'">
+          <path d="M3 3h10v8H8l-3 2v-2H3z" />
+          <path v-if="event.kind === 'review'" d="m5.5 7 1.5 1.5 3.5-3" />
+          <path v-else d="M5.5 6h5M5.5 8h3" />
+        </template>
+        <template v-else-if="event.kind === 'check'">
+          <rect x="2.5" y="2.5" width="11" height="11" rx="3" />
+          <path v-if="/^(success|passed)$/i.test(event.statusLabel || '')" d="m5 8 2 2 4-4" />
+          <path v-else-if="event.tone === 'rose'" d="m5.5 5.5 5 5m0-5-5 5" />
+          <path v-else d="M8 5v3l2 1" />
+        </template>
+        <path v-else-if="event.kind === 'repository'" d="M2.5 4h4l1.5 2h5.5v6.5h-11z" />
+        <template v-else><circle cx="8" cy="8" r="5.5" /><path d="M8 5v3M8 11h.01" /></template>
+      </svg>
+      <p v-if="room" class="github-event-title">{{ title }}</p>
+      <span v-else class="github-event-kind">{{ event.kindLabel }}</span>
+      <span v-if="event.statusLabel" class="github-event-status">{{ statusLabel }}</span>
+    </div>
+
+    <div v-if="!room || description" class="github-event-content">
+      <p v-if="!room" class="github-event-title">{{ title }}</p>
+      <p v-if="description" class="github-event-description">{{ description }}</p>
+    </div>
+
+    <div v-if="event.repository || event.taskId" class="github-event-context">
+      <span v-if="event.repository" class="github-event-repository">{{ event.repository }}</span>
+      <span v-if="event.repository && event.taskId" class="github-event-separator" aria-hidden="true">·</span>
+      <button
+        v-if="event.taskId && taskLinkEnabled"
+        type="button"
+        class="github-event-task"
+        :title="`Open ${event.taskId} on the Board`"
+        :data-task-reference-id="event.taskId"
+        @click="emit('openTask', event.taskId)"
+      >{{ event.taskId }}</button>
+      <span v-else-if="event.taskId" class="github-event-task">{{ event.taskId }}</span>
+    </div>
+
+    <div v-if="event.url" class="github-event-actions">
+      <slot name="actions" />
+      <a class="github-event-action" :href="event.url" target="_blank" rel="noopener noreferrer">
+        {{ event.urlLabel }}
+        <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 11 11 5M5 5h6v6" /></svg>
+      </a>
+      <button v-if="showEventLink && !compact" type="button" class="github-event-action is-secondary" @click="emit('openEvent', event.url)">
+        View in Events
+        <svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m6 4 4 4-4 4" /></svg>
+      </button>
+    </div>
+  </article>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+
+const props = defineProps<{
+  event: {
+    kind: string;
+    tone: string;
+    kindLabel: string;
+    statusLabel: string | null;
+    headline: string;
+    detail: string | null;
+    repository: string | null;
+    taskId: string | null;
+    url: string | null;
+    urlLabel: string;
+  };
+  compact?: boolean;
+  room?: boolean;
+  taskLinkEnabled?: boolean;
+  showEventLink?: boolean;
+}>();
+
+const emit = defineEmits<{
+  openTask: [taskId: string];
+  openEvent: [url: string];
+}>();
+
+// PR/issue details carry the artifact title; other events carry supporting text.
+const titleFirst = computed(() => Boolean(props.event.detail) && ['pull-request', 'issue'].includes(props.event.kind));
+const title = computed(() => titleFirst.value ? props.event.detail : props.event.headline);
+const description = computed(() => titleFirst.value ? props.event.headline : props.event.detail);
+const statusLabel = computed(() => {
+  const label = props.event.statusLabel || '';
+  return label.charAt(0).toUpperCase() + label.slice(1);
+});
+</script>
+
+<style scoped>
+.github-event-card {
+  --event-accent: var(--text-secondary);
+  display: grid;
+  gap: 10px;
+  width: 100%;
+  max-width: 560px;
+  min-width: 0;
+  box-sizing: border-box;
+  padding: 14px 16px 10px;
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-lg, 12px);
+  background: var(--bg-card);
+  color: var(--text);
+  font-family: var(--font-sans);
+}
+.github-event-card:not(.is-preview) { container-type: inline-size; }
+.github-event-card[data-tone="violet"] { --event-accent: var(--task-assigned); }
+.github-event-card[data-tone="emerald"] { --event-accent: var(--green-text); }
+.github-event-card[data-tone="rose"] { --event-accent: var(--red-text); }
+.github-event-card[data-tone="amber"] { --event-accent: var(--amber-text); }
+.github-event-card[data-tone="sky"] { --event-accent: var(--blue-text); }
+.github-event-header { display: flex; align-items: center; gap: 8px; min-width: 0; }
+.github-event-icon { width: 16px; height: 16px; flex: none; color: var(--event-accent); }
+.github-event-kind { color: var(--text-secondary); font-size: 12px; font-weight: 500; line-height: 1.5; }
+.github-event-status {
+  margin-left: auto;
+  padding: 2px 7px;
+  border-radius: 5px;
+  background: color-mix(in srgb, var(--event-accent) 10%, transparent);
+  color: var(--text);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+.github-event-content { display: grid; gap: 4px; min-width: 0; }
+.github-event-title { margin: 0; color: var(--text); font-size: 14px; font-weight: 600; line-height: 1.5; overflow-wrap: anywhere; }
+.github-event-description { margin: 0; color: var(--text-secondary); font-size: 12px; line-height: 1.5; white-space: pre-line; overflow-wrap: anywhere; }
+.github-event-context { display: flex; align-items: center; flex-wrap: wrap; gap: 6px; min-width: 0; color: var(--text-secondary); font-size: 11px; line-height: 1.5; }
+.github-event-repository { overflow-wrap: anywhere; }
+.github-event-task { display: inline-flex; align-items: center; min-height: 24px; padding: 0 4px; border: 0; border-radius: 4px; background: transparent; color: var(--text-secondary); font: inherit; font-family: var(--font-mono); }
+button.github-event-task { cursor: pointer; }
+.github-event-actions { display: flex; align-items: center; flex-wrap: wrap; gap: 4px; padding-top: 8px; border-top: 1px solid var(--border); }
+.github-event-action,
+.github-event-actions :deep(.pull-request-changes-button) {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 5px;
+  min-height: 32px;
+  max-width: 100%;
+  box-sizing: border-box;
+  padding: 5px 9px;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--text-secondary);
+  font: 500 12px/1.5 var(--font-sans);
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+  transition: background-color 120ms ease, color 120ms ease;
+}
+.github-event-action:first-child,
+.github-event-actions :deep(.pull-request-changes-button) { border-color: var(--border); background: var(--accent-dim); color: var(--text); }
+@container (min-width: 420px) {
+  .github-event-action.is-secondary { margin-left: auto; }
+}
+.github-event-action svg { width: 14px; height: 14px; flex: none; }
+@media (hover: hover) and (pointer: fine) {
+  .github-event-action:hover,
+  .github-event-actions :deep(.pull-request-changes-button:hover),
+  button.github-event-task:hover { background: var(--accent-hover); color: var(--text); text-decoration: none; }
+}
+.github-event-action:active,
+.github-event-actions :deep(.pull-request-changes-button:active),
+button.github-event-task:active { background: var(--accent-active); color: var(--text); transition: none; }
+.github-event-action:focus-visible,
+.github-event-actions :deep(.pull-request-changes-button:focus-visible),
+button.github-event-task:focus-visible { outline: 2px solid var(--blue-text); outline-offset: 2px; }
+.github-event-card.is-preview { margin-top: 6px; gap: 8px; padding: 12px 14px 8px; }
+@media (pointer: coarse) {
+  .github-event-action,
+  .github-event-actions :deep(.pull-request-changes-button),
+  button.github-event-task { min-height: 44px; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .github-event-action,
+  .github-event-actions :deep(.pull-request-changes-button) { transition: none; }
+}
+@media (prefers-contrast: more) {
+  .github-event-card { border-color: var(--text-secondary); }
+  .github-event-status { outline: 1px solid var(--event-accent); }
+}
+/* Room events share the conversation column, with flat, semantic borders. */
+.github-event-card.is-room-event {
+  max-width: 100%;
+  gap: 6px;
+  padding: 11px 14px 8px;
+  border-color: color-mix(in srgb, var(--event-accent) 45%, var(--border-strong));
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--bg-card) 65%, var(--bg));
+  box-shadow: none;
+}
+.is-room-event .github-event-title { font-size: 13px; font-weight: 550; }
+.is-room-event .github-event-description { font-size: 11px; }
+.is-room-event .github-event-actions { border: 0; padding-top: 0; gap: 8px; }
+.is-room-event .github-event-action,
+.is-room-event .github-event-actions :deep(.pull-request-changes-button) {
+  min-height: 26px; padding: 3px 0; border: 0; background: transparent; font-size: 11px;
+}
+.is-activity { display: flex; flex-wrap: wrap; align-items: center; column-gap: 12px; }
+.is-activity .github-event-header { flex: 1 1 220px; }
+.is-activity .github-event-kind { display: none; }
+.is-activity .github-event-status { margin-left: 0; }
+.is-activity .github-event-content { display: none; }
+.is-activity .github-event-title { font-size: 12px; font-weight: 500; color: var(--text-secondary); }
+.is-activity .github-event-description, .is-activity .github-event-repository, .is-activity .github-event-separator { display: none; }
+.is-activity .github-event-context,
+.is-activity .github-event-actions { grid-column: 1 / -1; }
+@media (pointer: coarse) {
+  .is-room-event .github-event-action,
+  .is-room-event .github-event-actions :deep(.pull-request-changes-button) { min-height: 44px; }
+}
+@media (prefers-contrast: more) {
+  .github-event-card.is-room-event { border-color: var(--event-accent); }
+}
+</style>