letagents 0.12.34 → 0.12.36

package/README.md

@@ -212,8 +212,6 @@ The API runs at `http://localhost:3001`. Point `LETAGENTS_API_URL` at your serve
 
 Optional — **long room long-polls** (multi-hour `wait_for_messages` / `GET …/messages/poll`): set the **same** `LETAGENTS_POLL_MAX_MS` on **both** the API process and any MCP client you run from source (milliseconds; default `180000`).
 
-Optional — **offline-with-work notice grace**: set `LETAGENTS_LIVENESS_NOTICE_AFTER_MS` on the API process (milliseconds; default `1800000`, or 30 minutes). The room is told about an unreachable worker only while it holds an active work lease, and only after this grace; ordinary connects and disconnects are never posted (the roster shows presence). Internal transport staleness remains 2 minutes for routing and diagnostics.
-
 The API now uses PostgreSQL with Drizzle ORM. `DB_URL` must be set before starting the server or running migrations.
 
 Useful database commands:

package/dist/mcp/server/runtime/messages.js

@@ -122,11 +122,28 @@ function withThreadMetadata(record, recordsById, summaries) {
         },
     };
 }
+/**
+ * Who reacted is worth an agent's attention; an empty list on every message,
+ * or an avatar address per reactor, is not.
+ */
+function withAgentReadableReactions(record) {
+    const { reactions, ...rest } = record;
+    if (!Array.isArray(reactions))
+        return record;
+    const readable = reactions.filter(isRecord).map((reaction) => ({
+        emoji: reaction.emoji,
+        count: reaction.count,
+        by: (Array.isArray(reaction.reactors) ? reaction.reactors : [])
+            .filter(isRecord)
+            .map((reactor) => reactor.name ?? reactor.login),
+    }));
+    return readable.length ? { ...rest, reactions: readable } : rest;
+}
 function toAgentReadableMessage(message, recordsById, summaries) {
     if (!message || typeof message !== "object") {
         return message;
     }
-    const record = withThreadMetadata(message, recordsById, summaries);
+    const record = withThreadMetadata(withAgentReadableReactions(message), recordsById, summaries);
     const kind = normalizeAgentPromptKind(record.agent_prompt_kind);
     const text = typeof record.text === "string" ? record.text : null;
     if (!kind || text === null) {

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.34",
+  "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/code-block.css

@@ -0,0 +1,193 @@
+/* ─── Shared Fenced Code Block & Syntax Highlighting Styles ─── */
+
+.fenced-code-block {
+  position: relative;
+  max-width: 100%;
+  margin: 0.75em 0;
+  padding: 0;
+  overflow: hidden;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md, 8px);
+  background: var(--code-bg, color-mix(in srgb, var(--bg) 88%, transparent));
+  color: var(--code-text, var(--text));
+  font-family: var(--font-mono);
+  font-size: 0.82rem;
+  line-height: 1.55;
+}
+
+.fenced-code-block-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 6px 12px;
+  background: var(--code-header-bg, color-mix(in srgb, var(--text) 4%, transparent));
+  border-bottom: 1px solid var(--border);
+  user-select: none;
+  font-family: var(--font-sans);
+  font-size: 0.75rem;
+  line-height: 1.2;
+}
+
+.fenced-code-block-lang {
+  color: var(--code-lang, var(--text-secondary));
+  font-weight: 500;
+  text-transform: lowercase;
+}
+
+.fenced-code-block-lang[data-lang]::before {
+  content: attr(data-lang);
+}
+
+.fenced-code-block-copy {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin-left: auto;
+  padding: 3px 8px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm, 4px);
+  background: var(--code-copy-bg, transparent);
+  color: var(--code-copy-text, var(--text-secondary));
+  font-family: var(--font-sans);
+  font-size: 0.72rem;
+  font-weight: 500;
+  line-height: 1.2;
+  cursor: pointer;
+  transition: color var(--duration-fast, 150ms) var(--ease-out, ease),
+              background var(--duration-fast, 150ms) var(--ease-out, ease),
+              border-color var(--duration-fast, 150ms) var(--ease-out, ease);
+}
+
+@media (hover: hover) and (pointer: fine) {
+  .fenced-code-block-copy:hover {
+    background: var(--accent-hover, rgba(255, 255, 255, 0.08));
+    color: var(--text);
+    border-color: var(--border-strong);
+  }
+}
+
+.fenced-code-block-copy:focus-visible {
+  outline: 2px solid var(--blue, #3b82f6);
+  outline-offset: 1px;
+}
+
+.fenced-code-block-copy::before {
+  content: "Copy";
+}
+
+.fenced-code-block-copy[data-copied="true"] {
+  color: var(--green-text, #4ade80);
+  border-color: color-mix(in srgb, var(--green-text, #4ade80) 40%, transparent);
+}
+
+.fenced-code-block-copy[data-copied="true"]::before {
+  content: "Copied";
+}
+
+.fenced-code-block-copy[data-copied="error"] {
+  color: var(--red-text, #f87171);
+  border-color: color-mix(in srgb, var(--red-text, #f87171) 40%, transparent);
+}
+
+.fenced-code-block-copy[data-copied="error"]::before {
+  content: "Failed";
+}
+
+/*
+ * Eleven different surfaces across desktop and web (e.g. chat messages, long message reader,
+ * board task inspector, thread panel, events view, markdown editor preview, agent inspector)
+ * define conflicting styles for `pre` with varying selector specificity.
+ * The `!important` declarations below ensure the fenced code block pre maintains a clean,
+ * borderless, transparent container with standard monospace sizing across all surfaces.
+ */
+.fenced-code-block pre {
+  margin: 0 !important;
+  padding: 10px 14px !important;
+  overflow-x: auto !important;
+  border: none !important;
+  border-radius: 0 !important;
+  background: transparent !important;
+  line-height: 1.55;
+  font-family: var(--font-mono);
+  font-size: 0.82rem;
+  white-space: pre;
+}
+
+.fenced-code-block code.fenced-code-block-content {
+  display: block;
+  padding: 0;
+  overflow-x: visible;
+  background: transparent;
+  color: inherit;
+  font-family: inherit;
+  font-size: inherit;
+  line-height: inherit;
+  white-space: pre;
+}
+
+/* ─── Syntax Highlighting Token Mappings ─── */
+.hljs-comment,
+.hljs-quote {
+  color: var(--code-comment, var(--text-secondary));
+  font-style: italic;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-subst {
+  color: var(--code-keyword, var(--task-assigned));
+}
+
+.hljs-string,
+.hljs-doctag,
+.hljs-regexp {
+  color: var(--code-string, var(--green-text));
+}
+
+.hljs-number,
+.hljs-literal {
+  color: var(--code-number, var(--amber-text));
+}
+
+.hljs-title,
+.hljs-title.function_,
+.hljs-title.class_,
+.hljs-section {
+  color: var(--code-function, var(--blue-text));
+}
+
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attr,
+.hljs-attribute {
+  color: var(--code-variable, var(--task-in-review));
+}
+
+.hljs-type,
+.hljs-built_in,
+.hljs-name {
+  color: var(--code-type, var(--red-text));
+}
+
+.hljs-meta,
+.hljs-tag {
+  color: var(--code-comment, var(--text-secondary));
+}
+
+.hljs-addition {
+  color: var(--code-string, var(--green-text));
+  background-color: var(--green-dim, rgba(34, 197, 94, 0.12));
+}
+
+.hljs-deletion {
+  color: var(--code-type, var(--red-text));
+  background-color: var(--red-dim, rgba(239, 68, 68, 0.12));
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-strong {
+  font-weight: bold;
+}

package/shared/code-highlighting.d.mts

@@ -0,0 +1,109 @@
+export type CanonicalLanguage =
+  | 'javascript'
+  | 'typescript'
+  | 'python'
+  | 'bash'
+  | 'json'
+  | 'yaml'
+  | 'xml'
+  | 'css'
+  | 'sql'
+  | 'diff'
+  | 'rust'
+  | 'go'
+  | 'c'
+  | 'cpp'
+  | 'java'
+  | 'csharp'
+  | 'dockerfile'
+  | 'ruby'
+  | 'php'
+  | 'swift'
+  | 'kotlin'
+  | 'ini';
+
+export type LanguageAlias =
+  | 'js'
+  | 'jsx'
+  | 'mjs'
+  | 'cjs'
+  | 'ts'
+  | 'tsx'
+  | 'mts'
+  | 'cts'
+  | 'py'
+  | 'sh'
+  | 'zsh'
+  | 'shell'
+  | 'yml'
+  | 'html'
+  | 'xhtml'
+  | 'svg'
+  | 'rs'
+  | 'golang'
+  | 'c++'
+  | 'cc'
+  | 'hpp'
+  | 'h'
+  | 'cs'
+  | 'docker'
+  | 'rb'
+  | 'kt'
+  | 'kts'
+  | 'toml';
+
+export type CodeHighlightLanguage = CanonicalLanguage;
+
+export interface ResolvedLanguage {
+  canonical: CanonicalLanguage;
+  label: string;
+}
+
+export interface CodeHighlighterOptions {
+  highlight: (code: string, canonicalLanguage: CanonicalLanguage) => string;
+  now?: () => number;
+  maxBudgetMs?: number;
+  windowMs?: number;
+}
+
+export interface CodeHighlighter {
+  renderCodeBlock(code: string, rawTag?: string): string;
+  cache: CodeHighlightCache;
+  resolveLanguage(rawTag?: string): ResolvedLanguage | null;
+}
+
+export const CANONICAL_LANGUAGES: readonly CanonicalLanguage[];
+export const LANGUAGE_ALIASES: ReadonlyMap<string, CanonicalLanguage>;
+
+export const MAX_HIGHLIGHT_CHARS: number;
+export const MAX_HIGHLIGHT_LINES: number;
+export const MAX_HIGHLIGHT_LINE_LENGTH: number;
+export const MAX_CACHE_ENTRIES: number;
+export const MAX_CACHE_CHARS: number;
+
+export const DEFAULT_TIME_BUDGET_MS: number;
+export const DEFAULT_TIME_WINDOW_MS: number;
+
+export function escapeHtml(value: unknown): string;
+export function escapeAttribute(value: unknown): string;
+export function resolveLanguage(rawTag?: string): ResolvedLanguage | null;
+
+export class CodeHighlightCache {
+  constructor(maxEntries?: number, maxChars?: number);
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  clear(): void;
+  readonly size: number;
+  readonly totalChars: number;
+}
+
+export function createCodeHighlighter(options: CodeHighlighterOptions): CodeHighlighter;
+export function executeCodeBlockCopy(
+  button: HTMLButtonElement,
+  textToCopy: string | null,
+  copyFn: (text: string) => Promise<boolean> | boolean,
+  copyTimers?: WeakMap<HTMLButtonElement, number>
+): Promise<{ success: boolean; timerId: number | null }>;
+export function setupCodeBlockCopyListener(
+  copyFn: (text: string) => Promise<boolean> | boolean
+): () => void;