@co0ontty/wand 4.100.0 → 4.101.0

package/dist/ai-team-runner.d.ts

@@ -189,7 +189,7 @@ export declare class AiTeamRunner {
     chatInput(sessionId: string, text: string): Promise<void>;
     /** Explicit task target; ordinary group talk never implicitly approves/stops/starts a run. */
     inputForRun(runId: string, text: string): Promise<AiTeamRunDetail>;
-    detail(runId: string): AiTeamRunDetail;
+    detail(runId: string, relayTurns?: ConversationTurn[]): AiTeamRunDetail;
     listForTask(taskId: string): AiTeamRun[];
     /**
      * 此刻正在干活的步骤的实时文本（§4.9）。只覆盖 running 且有会话的步骤，按 seq 升序；

package/dist/ai-team-runner.js

@@ -531,7 +531,7 @@ export class AiTeamRunner {
             this.saveRun(current);
         });
     }
-    detail(runId) {
+    detail(runId, relayTurns) {
         const run = this.storage.getAiTeamRun(runId);
         if (!run)
             throw new Error("团队运行不存在。");
@@ -547,8 +547,8 @@ export class AiTeamRunner {
         // 群聊回合只给最近这一段（§4.4）；没有群聊会话的旧运行给空数组，前端不用判 null。
         // 有对话归属时 ConversationService 已投影用户署名；旧运行只回放 relay 快照，在这里补同一口径。
         const self = this.selfAuthorOf;
-        const messages = (run.conversationId && this.chatHistoryTurns ? this.chatHistoryTurns(run.conversationId)
-            : run.chatSessionId ? this.ops.snapshot(run.chatSessionId)?.messages ?? [] : [])
+        const messages = (relayTurns ?? (run.conversationId && this.chatHistoryTurns ? this.chatHistoryTurns(run.conversationId)
+            : run.chatSessionId ? this.ops.snapshot(run.chatSessionId)?.messages ?? [] : []))
             .map((turn) => (turn.role === "user" && !turn.author && self ? { ...turn, author: self() } : turn));
         const currentTeam = this.storage.getAiTeam(run.teamId);
         // A relay belongs to a conversation, not its newest task. Always use the run's task.

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "b7d273f3dbcfed836b48f5321b9b1645910731f5",
-  "builtAt": "2026-10-21T06:25:16.318Z",
-  "version": "4.100.0",
+  "commit": "47bb7f819edbd778640501e0c80eeec6b6f3a8cd",
+  "builtAt": "2026-10-21T13:30:56.402Z",
+  "version": "4.101.0",
   "channel": "stable"
 }

package/dist/conversation-service.d.ts

@@ -1,3 +1,4 @@
+import { type ConversationSyncQuery } from "./conversation-sync.js";
 import { type AiTeamRun } from "./ai-team-types.js";
 import { type AiTeamRunner } from "./ai-team-runner.js";
 import { type ConversationDetail, type ConversationInstance, type ConversationReceipt, type ConversationSummary, type ConversationTarget, type ConversationSessionUpdate } from "./conversation-types.js";
@@ -37,11 +38,19 @@ export declare class ConversationService {
         config: WandConfig;
         deleteSession?(id: string): void;
         notifySession?(update: ConversationSessionUpdate): void;
+        notifyChanged?(): void;
     });
     private readonly removals;
     private readonly pendingOperations;
     private readonly previewTimers;
     private readonly legacyChannels;
+    private liveRevision;
+    private noticePending;
+    private changed;
+    private readSnapshots;
+    private readonly projections;
+    private readonly synchronizer;
+    sync(id: string, query: ConversationSyncQuery): import("./conversation-sync-contract.js").ConversationSync;
     /** Reuse session events; send only a bounded IM projection, never a second execution protocol. */
     ingestSessionEvent(event: ProcessEvent): void;
     dispose(): void;
@@ -73,7 +82,8 @@ export declare class ConversationService {
     remove(id: string): Promise<void>;
     private removeOwnedResources;
     history(id: string): ConversationTurn[];
-    detail(id: string): ConversationDetail;
+    detail(id: string, select?: (turns: ConversationTurn[]) => ConversationTurn[]): ConversationDetail;
+    private readDetail;
     /** Read-only, bounded projection of the exact accepted run. Never follow a group's newest task. */
     private taskPreview;
     private groupTeam;

package/dist/conversation-service.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { ConversationSynchronizer } from "./conversation-sync.js";
 import { statSync, rmSync, existsSync, realpathSync } from "node:fs";
 import { isAbsolute, resolve, sep } from "node:path";
 import { AI_TEAM_ACTIVE_RUN_STATUSES, AI_TEAM_DEFAULT_MAX_STEPS, AI_TEAM_MAX_MEMBERS, memberAgents } from "./ai-team-types.js";
@@ -56,8 +57,21 @@ export class ConversationService {
     pendingOperations = new Map();
     previewTimers = new Map();
     legacyChannels = new Set();
+    liveRevision = 0;
+    noticePending = false;
+    changed() {
+        if (this.noticePending)
+            return;
+        this.noticePending = true;
+        queueMicrotask(() => { this.noticePending = false; this.deps.notifyChanged?.(); });
+    }
+    readSnapshots = null;
+    projections = new Map();
+    synchronizer = new ConversationSynchronizer((id, select) => this.detail(id, select));
+    sync(id, query) { return this.synchronizer.sync(id, query); }
     /** Reuse session events; send only a bounded IM projection, never a second execution protocol. */
     ingestSessionEvent(event) {
+        this.liveRevision++;
         const session = this.deps.structured.get(event.sessionId);
         if (session)
             this.importEmployeeSession(session);
@@ -85,10 +99,17 @@ export class ConversationService {
         for (const timer of this.previewTimers.values())
             clearTimeout(timer);
         this.previewTimers.clear();
+        this.projections.clear();
     }
     get storage() { return this.deps.storage; }
     snapshot(id) {
-        return id ? this.deps.structured.get(id) ?? this.storage.getSession(id) : null;
+        if (!id)
+            return null;
+        if (this.readSnapshots?.has(id))
+            return this.readSnapshots.get(id);
+        const snapshot = this.deps.structured.get(id) ?? this.storage.getSession(id);
+        this.readSnapshots?.set(id, snapshot);
+        return snapshot;
     }
     /** Explicit startup/event migration, never a GET repair and never an invented group. */
     importRun(run) {
@@ -308,6 +329,7 @@ export class ConversationService {
         if (patch.dissolved !== undefined && instance.kind !== "group")
             throw new Error("只有群聊可以解散或恢复。");
         this.storage.updateConversationListState(id, { ...patch, dissolvedBy: this.selfName() });
+        this.changed();
         return this.summary(instance);
     }
     /** Delete only this conversation's owned channels and, for groups, its linked task resources. */
@@ -318,7 +340,7 @@ export class ConversationService {
         const removal = this.removeOwnedResources(id);
         this.removals.set(id, removal);
         void removal.finally(() => { if (this.removals.get(id) === removal)
-            this.removals.delete(id); }).catch(() => { });
+            this.removals.delete(id); this.changed(); }).catch(() => { });
         return removal;
     }
     async removeOwnedResources(id) {
@@ -383,17 +405,39 @@ export class ConversationService {
         this.storage.deleteConversation(id);
     }
     history(id) { return this.turns(this.requireInstance(id)); }
-    detail(id) {
-        const instance = this.requireInstance(id);
-        const turns = this.turns(instance);
-        const summary = this.summary(instance, turns);
-        return { ...summary, messages: turns.map(turn => turn.sessionLink
+    detail(id, select = turns => turns) {
+        const previous = this.readSnapshots;
+        this.readSnapshots = previous ?? new Map();
+        try {
+            return this.readDetail(id, select);
+        }
+        finally {
+            this.readSnapshots = previous;
+        }
+    }
+    readDetail(id, select) {
+        const revision = `${this.storage.projectionRevision()}:${this.liveRevision}:${JSON.stringify(this.deps.config.userProfile ?? {})}`;
+        let projection = this.projections.get(id);
+        if (projection?.revision !== revision) {
+            const instance = this.requireInstance(id);
+            const turns = this.turns(instance);
+            const summary = this.summary(instance, turns);
+            projection = { revision, instance, turns, summary, bytes: Buffer.byteLength(JSON.stringify(turns)) };
+            this.projections.delete(id);
+            if (projection.bytes <= 8 * 1024 * 1024)
+                this.projections.set(id, projection);
+            while (this.projections.size > 12 || [...this.projections.values()].reduce((n, p) => n + p.bytes, 0) > 16 * 1024 * 1024) {
+                this.projections.delete(this.projections.keys().next().value);
+            }
+        }
+        const { summary, turns } = projection;
+        return { ...summary, messages: select(turns).map(turn => turn.sessionLink
                 ? { ...turn, sessionPreview: conversationSessionPreview(this.snapshot(turn.sessionLink.sessionId), turn.requestId ? this.receipt(turn.requestId) ?? undefined : undefined),
                     // Older clients can still open the exact source session without understanding sessionLink.
                     author: turn.author ? { ...turn.author, sessionId: turn.sessionLink.sessionId } : turn.author,
                     content: turn.content.length ? turn.content : [{ type: "text", text: "消息已接收，打开对应会话查看实时回复。" }] }
                 : this.taskPreview(turn)),
-            runDetails: summary.tasks.flatMap((task) => task.runs.map((run) => this.deps.runner.detail(run.id))) };
+            runDetails: projection.runDetails ??= summary.tasks.flatMap((task) => task.runs.map((run) => this.deps.runner.detail(run.id, turns))) };
     }
     /** Read-only, bounded projection of the exact accepted run. Never follow a group's newest task. */
     taskPreview(turn) {
@@ -497,7 +541,10 @@ export class ConversationService {
             return existing.receipt; // Pending survives restart: never implicitly execute twice.
         }
         const receipt = { requestId, state: "pending", conversationId: id };
-        const commit = () => this.storage.saveConversationRequest({ id: requestId, fingerprint, receipt, updatedAt: now() });
+        const commit = () => {
+            this.storage.saveConversationRequest({ id: requestId, fingerprint, receipt, updatedAt: now() });
+            this.changed();
+        };
         commit();
         try {
             await operation(receipt, commit);

package/dist/conversation-sync-contract.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationDetail } from "./conversation-types.js";
+import type { ConversationTurn } from "./types.js";
+export interface ConversationHistory {
+    revision: string;
+    from: string | null;
+    hasEarlier: boolean;
+    total: number;
+}
+export interface ConversationSync {
+    id: string;
+    history: ConversationHistory;
+    unchanged?: boolean;
+    reset?: boolean;
+    detail?: Omit<ConversationDetail, "messages">;
+    messages?: ConversationTurn[];
+    messageOrder?: string[];
+}
+export interface ConversationSyncQuery {
+    since?: string;
+    from?: string;
+    older?: boolean;
+    limit?: number;
+}
+/** Shared client reducer. The server's order also removes deleted or moved rows. */
+export declare function mergeConversationSync(previous: ConversationDetail | null, update: ConversationSync): ConversationDetail & {
+    history: ConversationHistory;
+};

package/dist/conversation-sync-contract.js

@@ -0,0 +1,23 @@
+/** Shared client reducer. The server's order also removes deleted or moved rows. */
+export function mergeConversationSync(previous, update) {
+    if (previous && previous.id !== update.id)
+        previous = null;
+    if (update.unchanged) {
+        if (!previous)
+            throw new Error("缺少对话同步基线，请重新读取。");
+        return { ...previous, history: update.history };
+    }
+    const messages = new Map((update.reset ? [] : previous?.messages ?? []).map(turn => [turn.messageId, turn]));
+    for (const turn of update.messages ?? [])
+        messages.set(turn.messageId, turn);
+    const ordered = (update.messageOrder ?? []).map(id => {
+        const turn = messages.get(id);
+        if (!turn)
+            throw new Error("对话同步缺少消息，请重新读取。");
+        return turn;
+    });
+    const detail = update.detail ?? previous;
+    if (!detail || detail.id !== update.id)
+        throw new Error("对话同步身份不一致。");
+    return { ...detail, messages: ordered, history: update.history };
+}

package/dist/conversation-sync.d.ts

@@ -0,0 +1,11 @@
+import type { ConversationDetail } from "./conversation-types.js";
+import type { ConversationTurn } from "./types.js";
+import type { ConversationSync, ConversationSyncQuery } from "./conversation-sync-contract.js";
+export type { ConversationSyncQuery } from "./conversation-sync-contract.js";
+/** Owner-scoped, bounded diff fingerprints only: no transcript copy or persistent client state. */
+export declare class ConversationSynchronizer {
+    private readonly read;
+    private readonly revisions;
+    constructor(read: (id: string, select: (turns: ConversationTurn[]) => ConversationTurn[]) => ConversationDetail);
+    sync(id: string, query?: ConversationSyncQuery): ConversationSync;
+}

package/dist/conversation-sync.js

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+// Anchors survive deletion of the first loaded row. Never use an array offset as a durable cursor.
+function key(turn) { return [turn.createdAt ?? "", turn.role === "user" ? "0" : "1", turn.messageId]; }
+function compare(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        const d = a[i].localeCompare(b[i]);
+        if (d)
+            return d;
+    }
+    return 0;
+}
+function anchor(turn) { return Buffer.from(JSON.stringify(key(turn))).toString("base64url"); }
+function decode(value) {
+    if (!value || value.length > 2048)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString());
+        return Array.isArray(parsed) && parsed.length === 3 && parsed.every(v => typeof v === "string") ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Owner-scoped, bounded diff fingerprints only: no transcript copy or persistent client state. */
+export class ConversationSynchronizer {
+    read;
+    revisions = new Map();
+    constructor(read) {
+        this.read = read;
+    }
+    sync(id, query = {}) {
+        let from = null, hasEarlier = false, total = 0;
+        const limit = Math.min(80, Math.max(1, query.limit ?? 40));
+        const requestedAnchor = decode(query.from);
+        const detail = this.read(id, raw => {
+            const all = raw.map((turn, i) => turn.messageId ? turn : { ...turn, messageId: `${id}:legacy:${i}` })
+                .sort((a, b) => compare(key(a), key(b)));
+            total = all.length;
+            let start = requestedAnchor ? all.findIndex(turn => compare(key(turn), requestedAnchor) >= 0) : Math.max(0, total - limit);
+            if (start < 0)
+                start = total;
+            if (query.older && requestedAnchor)
+                start = Math.max(0, start - limit);
+            // Bound the first page by bytes too. One indivisible turn may exceed this soft budget.
+            if (!requestedAnchor) {
+                let bytes = 0;
+                for (let i = total - 1; i >= start; i--) {
+                    const size = Buffer.byteLength(JSON.stringify(all[i]));
+                    if (bytes + size > 96 * 1024 && i < total - 1) {
+                        start = i + 1;
+                        break;
+                    }
+                    bytes += size;
+                }
+            }
+            hasEarlier = start > 0;
+            from = all[start] ? anchor(all[start]) : query.from ?? null;
+            return all.slice(start);
+        });
+        const { messages, ...metadata } = detail;
+        const metadataHash = hash(metadata);
+        const fingerprints = new Map(messages.map(turn => [turn.messageId, hash(turn)]));
+        const order = [...fingerprints.keys()];
+        if (order.length !== messages.length)
+            throw new Error("对话消息身份重复，无法安全同步。");
+        const revision = hash([id, metadataHash, from, hasEarlier, total, [...fingerprints]]);
+        const history = { revision, from, hasEarlier, total };
+        const previous = query.since ? this.revisions.get(query.since) : undefined;
+        this.revisions.delete(revision);
+        // Avoid a large reader retaining unbounded fingerprint maps; cache miss resets the
+        // SAME anchored window, never silently drops already loaded history.
+        if (order.length <= 10_000)
+            this.revisions.set(revision, { id, metadata: metadataHash, messages: fingerprints });
+        while (this.revisions.size > 64)
+            this.revisions.delete(this.revisions.keys().next().value);
+        if (query.since === revision)
+            return { id, history, unchanged: true };
+        const valid = previous?.id === id ? previous : undefined;
+        return { id, history, reset: !valid,
+            ...(valid?.metadata === metadataHash ? {} : { detail: metadata }),
+            messages: valid ? messages.filter(turn => valid.messages.get(turn.messageId) !== fingerprints.get(turn.messageId)) : messages,
+            messageOrder: order };
+    }
+}

package/dist/conversation-types.d.ts

@@ -53,6 +53,7 @@ export interface ConversationSummary extends ConversationInstance {
 export interface ConversationDetail extends ConversationSummary {
     messages: ConversationTurn[];
     runDetails: AiTeamRunDetail[];
+    history?: import("./conversation-sync-contract.js").ConversationHistory;
 }
 export interface ConversationReceipt {
     requestId: string;

package/dist/server-conversation-routes.js

@@ -48,6 +48,23 @@ export function registerConversationRoutes(app, service) {
         else
             res.json(receipt);
     });
+    app.get("/api/conversations/:id/sync", (req, res) => {
+        try {
+            for (const key of ["since", "from"])
+                if (typeof req.query[key] === "string" && String(req.query[key]).length > 2048) {
+                    throw badRequest("对话同步游标无效。");
+                }
+            res.setHeader("Cache-Control", "private, no-store");
+            res.json(service.sync(req.params.id, {
+                since: typeof req.query.since === "string" ? req.query.since : undefined,
+                from: typeof req.query.from === "string" ? req.query.from : undefined,
+                older: req.query.older === "1",
+            }));
+        }
+        catch (error) {
+            sendRouteError(res, error, "对话同步失败。", 404);
+        }
+    });
     app.get("/api/conversations/:id", (req, res) => {
         try {
             res.json(service.detail(req.params.id));

package/dist/server-session-context.js

@@ -11,7 +11,7 @@ export function createSessionRouteContext(deps) {
     const { structured, storage, sessions, config, decisions } = deps;
     const wantsCompactTools = (req) => req.get("X-Wand-Tool-Projection") === "compact" || req.query.compactTools === "1";
     const sessionResponseDTO = (snapshot, req) => {
-        const enriched = enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
+        const enriched = sessions.transportMessages?.(snapshot.id, snapshot.messages ?? []) ?? enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
         const windowed = windowMessagesForTransport(wantsCompactTools(req) ? compactToolMessagesForTransport(enriched) : enriched, config.cardDefaults ?? {});
         return toSessionDetailDTO(snapshot, {
             messages: windowed.messages,

package/dist/server-session-list-routes.js

@@ -219,7 +219,7 @@ export function registerSessionListRoutes(app, ctx) {
         const transcriptOutput = (snapshot.sessionKind ?? "pty") === "pty"
             ? processes.getPtyTranscript(snapshot.id) ?? snapshot.output
             : req.query.format === "chat" && req.query.output === "omit" ? "" : snapshot.output;
-        const enriched = enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
+        const enriched = sessions.transportMessages?.(snapshot.id, snapshot.messages ?? []) ?? enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
         const messages = wantsCompactTools(req) ? compactToolMessagesForTransport(enriched) : enriched;
         if (req.query.format === "chat") {
             // 客户端带 blockBudget（Web/iOS）走块级窗口：只回最近 N 个块（必要时切掉最旧 turn 的头部），
@@ -260,7 +260,7 @@ export function registerSessionListRoutes(app, ctx) {
             res.status(404).json({ error: "未找到该会话，可能已被删除。" });
             return;
         }
-        const enriched = enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
+        const enriched = sessions.transportMessages?.(snapshot.id, snapshot.messages ?? []) ?? enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
         const all = wantsCompactTools(req) ? compactToolMessagesForTransport(enriched) : enriched;
         const total = all.length;
         // Web history: fetch at most one block window *before* the currently

package/dist/server.js

@@ -463,7 +463,7 @@ export async function startServer(config, configPath, options = {}) {
         defaultModelOf: (provider) => getDefaultModelForProvider(config, provider),
     });
     const conversationService = new ConversationService({ storage, config, structured: structuredSessions, runner: aiTeams,
-        notifySession: notifier.conversationSession, deleteSession: id => { sessionRegistry.deleteWithProviderHistory(id); } });
+        notifySession: notifier.conversationSession, notifyChanged: () => notifier.system({ kind: "conversations-changed" }), deleteSession: id => { sessionRegistry.deleteWithProviderHistory(id); } });
     conversations = conversationService;
     conversationService.migrateExistingChats();
     const scheduledTasks = new ScheduledTaskService({ storage, conversations: conversationService,
@@ -802,6 +802,7 @@ export async function startServer(config, configPath, options = {}) {
     const wsManager = new WsBroadcastManager(wss, () => config.cardDefaults ?? {}, useHttps, authService, (req) => authenticateBearerAppToken(req, storage, config) !== null);
     wsManager.setup({
         getSession: (id) => sessionRegistry.get(id),
+        projectMessages: (id, messages) => sessionRegistry.transportMessages(id, messages),
         getTerminalState: (id) => processes.getTerminalState(id),
         sendPtyInput: (id, input, shortcutKey, userInput) => processes.sendInputConfirmed(id, input, "terminal", shortcutKey, userInput).then(() => { }),
         resizePty: (id, cols, rows) => {
@@ -817,6 +818,7 @@ export async function startServer(config, configPath, options = {}) {
     });
     // Wire process events to WebSocket broadcast
     processes.on("process", (event) => {
+        sessionRegistry.invalidateMessageProjection(event.sessionId);
         taskTitles.ingest(event);
         sessionCompletions.ingest(event);
         missions.ingest(event);
@@ -825,6 +827,7 @@ export async function startServer(config, configPath, options = {}) {
         wsManager.emitEvent(event);
     });
     structuredSessions.setEventEmitter((event) => {
+        sessionRegistry.invalidateMessageProjection(event.sessionId);
         taskTitles.ingest(event);
         storage.recordTaskCommentSessionEvent(event);
         conversationService.ingestSessionEvent(event);

package/dist/session-registry.d.ts

@@ -1,7 +1,7 @@
 import type { ProcessManager } from "./process-manager.js";
 import type { WandStorage } from "./storage.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
-import type { ExecutionMode, SessionSnapshot } from "./types.js";
+import type { ExecutionMode, SessionSnapshot, ConversationTurn } from "./types.js";
 export type SessionOwner = "structured" | "pty" | "storage";
 export type ProviderHistoryDeleter = Pick<ProcessManager, "deleteClaudeHistoryFiles" | "deleteCodexHistoryFiles" | "deleteOpenCodeHistorySessions" | "deleteQoderHistoryFiles" | "deletePiHistoryFiles" | "deleteGrokHistoryFiles">;
 export declare function deleteProviderNativeHistory(deleter: ProviderHistoryDeleter, provider: string, providerSessionId: string, cwd: string): void;
@@ -28,6 +28,11 @@ export declare class SessionRegistry {
     private readonly processes;
     private readonly structured;
     private readonly storage;
+    private readonly messageProjections;
+    private readonly messageEpochs;
+    invalidateMessageProjection(id: string): void;
+    /** One semantic pass per source/revision, shared by HTTP and all WS readers. */
+    transportMessages(id: string, messages: ConversationTurn[]): ConversationTurn[];
     /** Deleted owners can still be exiting; listSlim alone no longer sees them. */
     private readonly nativeDeletionBarriers;
     constructor(processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage);

package/dist/session-registry.js

@@ -1,9 +1,11 @@
+import { createHash } from "node:crypto";
 import { isArchiveBlocked } from "./archive-policy.js";
 import { logInfo } from "./runtime-log.js";
 import { isSystemAiCall } from "./system-ai-call.js";
 import { systemAiSessions } from "./system-ai-session-recorder.js";
 import { cleanupWorktreeSync } from "./git-worktree.js";
 import { inferProviderFromCommand } from "./session-provider.js";
+import { enrichStructuredMessages } from "./structured-client-protocol.js";
 export function deleteProviderNativeHistory(deleter, provider, providerSessionId, cwd) {
     const id = providerSessionId.trim();
     if (!id)
@@ -117,6 +119,33 @@ export class SessionRegistry {
     processes;
     structured;
     storage;
+    messageProjections = new Map();
+    messageEpochs = new Map();
+    invalidateMessageProjection(id) {
+        this.messageProjections.delete(id);
+        this.messageEpochs.set(id, (this.messageEpochs.get(id) ?? 0) + 1);
+        if (this.messageEpochs.size > 2048)
+            this.messageEpochs.delete(this.messageEpochs.keys().next().value);
+    }
+    /** One semantic pass per source/revision, shared by HTTP and all WS readers. */
+    transportMessages(id, messages) {
+        // Some live adapters append in place before the debounced event boundary. A
+        // content digest prevents cached semantics from crossing that mutation window.
+        const raw = JSON.stringify(messages);
+        const digest = createHash("sha256").update(raw).digest("hex");
+        const revision = `${this.storage.projectionRevision()}:${this.messageEpochs.get(id) ?? 0}:${digest}`;
+        const cached = this.messageProjections.get(id);
+        if (cached?.revision === revision)
+            return cached.projected;
+        const projected = enrichStructuredMessages(messages, id);
+        this.messageProjections.delete(id);
+        if (raw.length <= 1024 * 1024 && messages.length <= 2000 && messages.reduce((n, turn) => n + turn.content.length, 0) <= 10000) {
+            this.messageProjections.set(id, { revision, source: messages, projected });
+            while (this.messageProjections.size > 16)
+                this.messageProjections.delete(this.messageProjections.keys().next().value);
+        }
+        return projected;
+    }
     /** Deleted owners can still be exiting; listSlim alone no longer sees them. */
     nativeDeletionBarriers = new Map();
     constructor(processes, structured, storage) {