@tea-agent/loop-agent 0.23.1 → 0.24.0

package/dist/worker/console/app-data.js

@@ -41,6 +41,7 @@ export function openConsoleAppData(options) {
         interviews: path.join(repoNamespace, "interviews"),
         chats: path.join(repoNamespace, "chats"),
         chatSessions: path.join(repoNamespace, "chat-sessions"),
+        chatEvents: path.join(repoNamespace, "chat-events"),
     };
     for (const dir of [
         paths.drafts,
@@ -51,6 +52,7 @@ export function openConsoleAppData(options) {
         paths.interviews,
         paths.chats,
         paths.chatSessions,
+        paths.chatEvents,
     ]) {
         ensureSecureDir(dir);
     }

package/dist/worker/console/chat/artifact-card.js

@@ -0,0 +1,23 @@
+export const ARTIFACT_KINDS = ["operation", "contract", "dag", "report", "html"];
+export function artifactFromEventPayload(payload) {
+    const raw = payload.artifact;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const candidate = raw;
+    if (candidate.schemaVersion !== 1 ||
+        typeof candidate.artifactId !== "string" || !candidate.artifactId ||
+        typeof candidate.kind !== "string" || !ARTIFACT_KINDS.includes(candidate.kind) ||
+        typeof candidate.previewHash !== "string")
+        return undefined;
+    for (const field of ["title", "summary", "htmlPreview", "reportText", "inspectHref"]) {
+        if (candidate[field] !== undefined && typeof candidate[field] !== "string")
+            return undefined;
+    }
+    return candidate;
+}
+export function mergeArtifactCardState(current, incoming) {
+    const index = current.findIndex((item) => item.artifactId === incoming.artifactId);
+    if (index < 0)
+        return [...current, incoming];
+    return current.map((item, candidate) => candidate === index ? { ...item, ...incoming } : item);
+}

package/dist/worker/console/chat/chat-event-store.js

@@ -0,0 +1,495 @@
+/**
+ * Operator Chat — persisted event ring + reconnect support (roadmap M1-T03/T04/T07).
+ *
+ * Each Chat session owns a bounded event ring persisted to app-data. Every
+ * event gets a monotonic `seq` and an `eventId = "<sessionId>:<seq>"`, so a
+ * browser that refreshes mid-stream (or reconnects after a network blip) can
+ * resume via the SSE `Last-Event-ID` header.
+ *
+ * Live turn streaming: while a turn is in flight, in-memory subscriber
+ * callbacks are notified so an open `GET /events` connection (re)plays the
+ * retained tail and then follows the live stream. When no turn is active the
+ * endpoint simply replays the ring and closes (idempotent snapshot).
+ *
+ * Stale-turn fence (T07): each persisted event records its `turnId`. A
+ * reconnecting client that lost its `turnId` mid-stream compares the ring's
+ * latest `turnId` against the one it last saw; a mismatch is surfaced as a
+ * `reconcile` signal so the UI does not render stale events under a new turn.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import { ensureSecureDir, writeSecureJsonSync, } from "../app-data.js";
+import { isTerminalOperationState, } from "../operation-store.js";
+import { scrubSecrets } from "./explore-tools.js";
+const OPERATION_PREVIEW_MAX_CHARS = 1200;
+function boundedRedactedText(value, maxChars = OPERATION_PREVIEW_MAX_CHARS) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const { scrubbed } = scrubSecrets(value);
+    return scrubbed.length <= maxChars
+        ? scrubbed
+        : `${scrubbed.slice(0, maxChars)}…[truncated]`;
+}
+function safeIdentity(value) {
+    return boundedRedactedText(value, 240);
+}
+function controllerSummary(operation) {
+    const identity = operation.controllerIdentity;
+    if (!identity || typeof identity !== "object")
+        return undefined;
+    const record = identity;
+    const fingerprint = typeof record.fingerprint === "string"
+        ? record.fingerprint
+        : typeof record.packageFingerprint?.value === "string"
+            ? String(record.packageFingerprint.value)
+            : undefined;
+    const label = [record.packageName, record.packageVersion, fingerprint]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join("@");
+    return safeIdentity(label);
+}
+/** Chat/browser-safe projection. Never includes actionParams, CLI args, paths or raw results. */
+export function projectOperationForChat(operation) {
+    const params = operation.actionParams ?? {};
+    const stdoutPreview = boundedRedactedText(operation.stdoutPreview);
+    const stderrPreview = boundedRedactedText(operation.stderrPreview);
+    const summaryPreview = boundedRedactedText(operation.errorMessage);
+    const taskId = safeIdentity(operation.taskId ?? params.taskId);
+    const dagRunId = safeIdentity(operation.dagRunId ?? params.dagRunId ?? params.runId);
+    const featureId = safeIdentity(params.featureId);
+    const workerRunId = safeIdentity(params.workerRunId);
+    const controller = controllerSummary(operation);
+    const previewHash = createHash("sha256")
+        .update(JSON.stringify({ stdoutPreview, stderrPreview, summaryPreview, state: operation.state }))
+        .digest("hex");
+    return {
+        schemaVersion: 1,
+        operationId: operation.operationId,
+        action: operation.action,
+        state: operation.state,
+        createdAt: operation.createdAt,
+        updatedAt: operation.finishedAt ?? operation.startedAt ?? operation.createdAt,
+        inspectHref: `/inspect/?operationId=${encodeURIComponent(operation.operationId)}#/`,
+        ...(taskId ? { taskId } : {}),
+        ...(dagRunId ? { dagRunId } : {}),
+        ...(featureId ? { featureId } : {}),
+        ...(workerRunId ? { workerRunId } : {}),
+        ...(controller ? { controller } : {}),
+        ...(stdoutPreview ? { stdoutPreview } : {}),
+        ...(stderrPreview ? { stderrPreview } : {}),
+        ...(summaryPreview ? { summaryPreview } : {}),
+        ...(operation.errorCode ? { errorCode: safeIdentity(operation.errorCode) } : {}),
+        previewHash,
+    };
+}
+export function projectCompactSnapshot(value) {
+    const record = value && typeof value === "object" ? value : {};
+    const summary = boundedRedactedText(record.summary, 12_000) ?? "Context compacted.";
+    const firstKeptEntryId = safeIdentity(record.firstKeptEntryId);
+    const tokensBefore = typeof record.tokensBefore === "number" && Number.isFinite(record.tokensBefore)
+        ? Math.max(0, Math.floor(record.tokensBefore))
+        : undefined;
+    const details = record.details === undefined ? undefined : boundedRedactedJson(record.details).preview;
+    return {
+        schemaVersion: 1,
+        summary,
+        ...(firstKeptEntryId ? { firstKeptEntryId } : {}),
+        ...(tokensBefore !== undefined ? { tokensBefore } : {}),
+        ...(details ? { details } : {}),
+        previewHash: createHash("sha256").update(JSON.stringify({ summary, firstKeptEntryId, tokensBefore, details })).digest("hex"),
+    };
+}
+function boundedRedactedJson(value) {
+    let raw;
+    try {
+        raw = JSON.stringify(value ?? {});
+    }
+    catch {
+        raw = String(value);
+    }
+    const preview = boundedRedactedText(raw) ?? "{}";
+    return {
+        preview,
+        previewHash: createHash("sha256").update(preview).digest("hex"),
+    };
+}
+export function projectChatToolEventPayload(input) {
+    const { preview, previewHash } = boundedRedactedJson(input.value);
+    if (input.kind === "tool_call") {
+        return {
+            toolCallId: input.toolCallId,
+            toolName: input.toolName,
+            argsPreview: preview,
+            previewHash,
+        };
+    }
+    return {
+        toolCallId: input.toolCallId,
+        toolName: input.toolName,
+        resultPreview: preview,
+        previewHash,
+        isError: Boolean(input.isError),
+    };
+}
+export function projectOperationEventSummary(event) {
+    const messagePreview = boundedRedactedText(event.message, 600);
+    const dataPreview = event.data === undefined
+        ? undefined
+        : boundedRedactedText(JSON.stringify(event.data), 600);
+    return {
+        seq: event.seq,
+        at: event.at,
+        kind: event.kind,
+        ...(event.state ? { state: event.state } : {}),
+        ...(messagePreview ? { messagePreview } : {}),
+        ...(dataPreview ? { dataPreview } : {}),
+        previewHash: createHash("sha256")
+            .update(JSON.stringify({ messagePreview, dataPreview, state: event.state, kind: event.kind }))
+            .digest("hex"),
+    };
+}
+const DEFAULT_MAX_EVENTS = 2000;
+/** Make a sessionId safe to use as a filename component. */
+function safeSessionId(sessionId) {
+    return sessionId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
+}
+/**
+ * Link durable Chat refs to the existing canonical operation store/event ring.
+ * This owns no operation state and schedules no work; it only projects facts.
+ */
+export function createChatOperationLinker(options) {
+    const followers = new Map();
+    const keyFor = (sessionId, operationId) => `${sessionId}\u0000${operationId}`;
+    function hasRef(input) {
+        return options.chatEvents.snapshot(input.sessionId).some((event) => {
+            if (event.kind !== "operation-ref")
+                return false;
+            const data = event.data;
+            return event.turnId === input.turnId &&
+                data.operationId === input.operationId &&
+                data.toolCallId === input.toolCallId;
+        });
+    }
+    async function syncFact(input) {
+        const operation = await options.operations.get(input.operationId);
+        if (!operation)
+            return;
+        const focused = isTerminalOperationState(operation.state) || operation.state === "needs-reconcile";
+        if (!focused)
+            return;
+        const projection = projectOperationForChat(operation);
+        const closureKind = operation.state === "needs-reconcile"
+            ? "needs-reconcile"
+            : operation.state === "failed" || operation.state === "timed-out"
+                ? "failed"
+                : "terminal";
+        const duplicate = options.chatEvents.snapshot(input.sessionId).some((event) => {
+            if (event.kind !== "operation-status")
+                return false;
+            const data = event.data;
+            return data.operationId === input.operationId &&
+                data.closureKind === closureKind &&
+                data.operation?.state === projection.state &&
+                data.operation?.previewHash === projection.previewHash;
+        });
+        if (!duplicate) {
+            options.chatEvents.append(input.sessionId, input.turnId, {
+                kind: "operation-status",
+                data: {
+                    operationId: input.operationId,
+                    closureKind,
+                    operation: projection,
+                },
+            });
+        }
+        if (isTerminalOperationState(operation.state)) {
+            const key = keyFor(input.sessionId, input.operationId);
+            followers.get(key)?.();
+            followers.delete(key);
+        }
+    }
+    async function link(input) {
+        const operation = await options.operations.get(input.operationId);
+        if (!operation)
+            throw new Error(`operation not found: ${input.operationId}`);
+        if (!hasRef(input)) {
+            options.chatEvents.append(input.sessionId, input.turnId, {
+                kind: "operation-ref",
+                data: {
+                    operationId: input.operationId,
+                    toolCallId: input.toolCallId,
+                    operation: projectOperationForChat(operation),
+                },
+            });
+        }
+        const key = keyFor(input.sessionId, input.operationId);
+        if (!followers.has(key) && !isTerminalOperationState(operation.state)) {
+            const unsubscribe = options.operationEvents.subscribe(input.operationId, () => {
+                void syncFact(input).catch(() => {
+                    // Recovery reads will retry from durable refs; never break operation append.
+                });
+            });
+            followers.set(key, unsubscribe);
+        }
+        await syncFact(input);
+    }
+    return {
+        link,
+        async recoverSession(sessionId) {
+            const refs = options.chatEvents.snapshot(sessionId).filter((event) => event.kind === "operation-ref");
+            for (const event of refs) {
+                const data = event.data;
+                if (!data.operationId || !data.toolCallId)
+                    continue;
+                await link({
+                    sessionId,
+                    turnId: event.turnId,
+                    toolCallId: data.toolCallId,
+                    operationId: data.operationId,
+                }).catch(() => undefined);
+            }
+        },
+        clearSession(sessionId) {
+            for (const [key, unsubscribe] of followers) {
+                if (!key.startsWith(`${sessionId}\u0000`))
+                    continue;
+                unsubscribe();
+                followers.delete(key);
+            }
+        },
+        dispose() {
+            for (const unsubscribe of followers.values())
+                unsubscribe();
+            followers.clear();
+        },
+    };
+}
+export function createChatEventStore(options) {
+    const maxEvents = options?.maxEventsPerSession ?? DEFAULT_MAX_EVENTS;
+    const persistenceDir = options?.appData?.chatEvents
+        ? path.resolve(options.appData.chatEvents)
+        : undefined;
+    if (persistenceDir)
+        ensureSecureDir(persistenceDir);
+    const rings = new Map();
+    /** Monotonic turn ordinal per session (persisted alongside the ring). */
+    const turnCounts = new Map();
+    /** Live subscribers per session. */
+    const subscribers = new Map();
+    function persistedPath(sessionId) {
+        return persistenceDir
+            ? path.join(persistenceDir, `${safeSessionId(sessionId)}.json`)
+            : undefined;
+    }
+    function loadRing(sessionId) {
+        const file = persistedPath(sessionId);
+        if (!file || !existsSync(file))
+            return undefined;
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf8"));
+            if (parsed.schemaVersion !== 1 ||
+                parsed.sessionId !== sessionId ||
+                !Array.isArray(parsed.events)) {
+                throw new Error("invalid persisted chat event ring");
+            }
+            const events = parsed.events.slice(-maxEvents);
+            const turns = Array.isArray(parsed.turns) ? parsed.turns : [];
+            turnCounts.set(sessionId, parsed.turnCount ?? 0);
+            return {
+                events,
+                turns,
+                nextSeq: Math.max(parsed.nextSeq, (events[events.length - 1]?.seq ?? 0) + 1),
+                minSeq: events[0]?.seq ?? parsed.minSeq ?? 1,
+                maxEvents,
+            };
+        }
+        catch (error) {
+            throw new Error(`invalid persisted chat events ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    function persist(sessionId, ring) {
+        const file = persistedPath(sessionId);
+        if (!file)
+            return;
+        writeSecureJsonSync(file, {
+            schemaVersion: 1,
+            sessionId,
+            turnCount: turnCounts.get(sessionId) ?? 0,
+            turns: ring.turns,
+            events: ring.events,
+            nextSeq: ring.nextSeq,
+            minSeq: ring.minSeq,
+        });
+    }
+    function ringFor(sessionId) {
+        let ring = rings.get(sessionId);
+        if (!ring) {
+            ring = loadRing(sessionId) ?? {
+                events: [],
+                turns: [],
+                nextSeq: 1,
+                minSeq: 1,
+                maxEvents,
+            };
+            rings.set(sessionId, ring);
+        }
+        return ring;
+    }
+    return {
+        forkContextRefs(input) {
+            const allowed = new Set([
+                "operation-ref", "operation-status", "draft", "assessment",
+                "taskKind-confirmed", "human-gate-card", "compact", "artifact-ref",
+            ]);
+            let copiedCount = 0;
+            for (const event of this.snapshot(input.sourceSessionId)) {
+                if (!allowed.has(event.kind))
+                    continue;
+                const data = structuredClone(event.data);
+                if (event.kind === "human-gate-card") {
+                    delete data.humanGateToken;
+                    delete data.dagBytesPath;
+                }
+                this.append(input.targetSessionId, input.targetTurnId, { kind: event.kind, data: data });
+                copiedCount += 1;
+            }
+            return { copiedCount };
+        },
+        createTurn(sessionId) {
+            const ring = ringFor(sessionId);
+            const active = ring.turns.find((turn) => turn.state === "queued" || turn.state === "running");
+            if (active)
+                return { ok: false, code: "TURN_ACTIVE", activeTurn: active };
+            const ordinal = (turnCounts.get(sessionId) ?? 0) + 1;
+            turnCounts.set(sessionId, ordinal);
+            const now = new Date().toISOString();
+            const turn = {
+                schemaVersion: 1,
+                turnId: `${sessionId}:turn-${ordinal}`,
+                sessionId,
+                ordinal,
+                state: "queued",
+                createdAt: now,
+            };
+            ring.turns.push(turn);
+            persist(sessionId, ring);
+            return { ok: true, turn };
+        },
+        setTurnState(sessionId, turnId, state, error) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.turnId === turnId);
+            if (!turn)
+                return undefined;
+            turn.state = state;
+            if (state === "running" && !turn.startedAt)
+                turn.startedAt = new Date().toISOString();
+            if (state === "settled" || state === "aborted" || state === "failed") {
+                turn.finishedAt = new Date().toISOString();
+            }
+            if (error)
+                turn.error = error;
+            persist(sessionId, ring);
+            return { ...turn };
+        },
+        getTurn(sessionId, turnId) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.turnId === turnId);
+            return turn ? { ...turn } : undefined;
+        },
+        getActiveTurn(sessionId) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.state === "queued" || candidate.state === "running");
+            return turn ? { ...turn } : undefined;
+        },
+        append(sessionId, turnId, partial) {
+            const ring = ringFor(sessionId);
+            const seq = ring.nextSeq++;
+            const event = {
+                schemaVersion: 1,
+                eventId: `${sessionId}:${seq}`,
+                sessionId,
+                seq,
+                turnId,
+                at: partial.at ?? new Date().toISOString(),
+                kind: partial.kind,
+                data: partial.data,
+            };
+            ring.events.push(event);
+            while (ring.events.length > ring.maxEvents) {
+                const dropped = ring.events.shift();
+                if (dropped)
+                    ring.minSeq = dropped.seq + 1;
+            }
+            if (ring.events.length > 0) {
+                ring.minSeq = ring.events[0].seq;
+            }
+            persist(sessionId, ring);
+            const subs = subscribers.get(sessionId);
+            if (subs) {
+                for (const fn of subs) {
+                    try {
+                        fn(event);
+                    }
+                    catch {
+                        // a subscriber throwing must never break the append path
+                    }
+                }
+            }
+            return event;
+        },
+        listFrom(sessionId, afterSeq) {
+            const ring = rings.get(sessionId) ?? loadRing(sessionId);
+            if (!ring)
+                return { events: [] };
+            rings.set(sessionId, ring);
+            if (ring.events.length > 0 && afterSeq + 1 < ring.minSeq) {
+                return { error: "CURSOR_EXPIRED", minSeq: ring.minSeq };
+            }
+            return { events: ring.events.filter((e) => e.seq > afterSeq) };
+        },
+        snapshot(sessionId) {
+            const ring = rings.get(sessionId) ?? loadRing(sessionId);
+            if (ring)
+                rings.set(sessionId, ring);
+            return ring?.events.slice() ?? [];
+        },
+        nextTurnOrdinal(sessionId) {
+            // Load the ring FIRST so a fresh store instance hydrates turnCounts from
+            // the persisted file before we read it (otherwise a restart resets the
+            // ordinal to 1 and collides with prior turns).
+            const ring = ringFor(sessionId);
+            const next = (turnCounts.get(sessionId) ?? 0) + 1;
+            turnCounts.set(sessionId, next);
+            persist(sessionId, ring);
+            return next;
+        },
+        latestTurnId(sessionId) {
+            const ring = rings.get(sessionId) ?? loadRing(sessionId);
+            if (ring)
+                rings.set(sessionId, ring);
+            return ring?.events.at(-1)?.turnId;
+        },
+        subscribe(sessionId, listener) {
+            let subs = subscribers.get(sessionId);
+            if (!subs) {
+                subs = new Set();
+                subscribers.set(sessionId, subs);
+            }
+            subs.add(listener);
+            return () => {
+                subs?.delete(listener);
+                if (subs && subs.size === 0)
+                    subscribers.delete(sessionId);
+            };
+        },
+        clear(sessionId) {
+            rings.delete(sessionId);
+            turnCounts.delete(sessionId);
+            subscribers.delete(sessionId);
+            const file = persistedPath(sessionId);
+            if (file)
+                rmSync(file, { force: true });
+        },
+    };
+}

package/dist/worker/console/chat/chat-ui-policy.js

@@ -0,0 +1,25 @@
+export function advanceIndicator(state, event) {
+    if (event.eventId && event.eventId === state.lastEventId)
+        return state;
+    if (event.kind === "visible")
+        return { ...state, unread: 0 };
+    const running = event.kind === "agent_start"
+        ? true
+        : event.kind === "agent_settled" || event.kind === "error"
+            ? false
+            : state.running;
+    const unread = event.hidden && (event.kind === "message_end" || event.kind === "agent_settled")
+        ? state.unread + 1
+        : state.unread;
+    return { running, unread, ...(event.eventId ? { lastEventId: event.eventId } : { lastEventId: state.lastEventId }) };
+}
+export function shouldPlayCompletionSound(input) {
+    return input.enabled && input.kind === "agent_settled" && !input.replayed;
+}
+export function copyTextForMessage(input) {
+    return input.code ?? input.text;
+}
+/** Empty sandbox means scripts, same-origin access, navigation and popups are denied. */
+export function previewSandbox() {
+    return { sandbox: "" };
+}

package/dist/worker/console/chat/composer-draft-store.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+const MAX_DRAFT_BYTES = 64 * 1024;
+function safeSessionId(sessionId) {
+    if (!/^[A-Za-z0-9_-]+$/.test(sessionId))
+        throw new Error("invalid chat session id");
+    return sessionId;
+}
+export class ComposerDraftStore {
+    chains = new Map();
+    dir;
+    constructor(appData) {
+        this.dir = path.join(appData.chats, ".composer-drafts");
+    }
+    file(sessionId) {
+        return path.join(this.dir, `${safeSessionId(sessionId)}.txt`);
+    }
+    serialize(sessionId, op) {
+        const previous = this.chains.get(sessionId) ?? Promise.resolve();
+        const next = previous.then(op, op);
+        this.chains.set(sessionId, next.then(() => undefined, () => undefined));
+        return next;
+    }
+    async get(sessionId) {
+        try {
+            return await readFile(this.file(sessionId), "utf8");
+        }
+        catch {
+            return "";
+        }
+    }
+    async save(sessionId, text) {
+        if (Buffer.byteLength(text, "utf8") > MAX_DRAFT_BYTES)
+            throw new Error(`composer draft exceeds ${MAX_DRAFT_BYTES} bytes`);
+        await this.serialize(sessionId, async () => {
+            if (!text) {
+                await rm(this.file(sessionId), { force: true });
+                return;
+            }
+            await mkdir(this.dir, { recursive: true, mode: 0o700 });
+            await writeFile(this.file(sessionId), text, { encoding: "utf8", mode: 0o600 });
+        });
+    }
+    async remove(sessionId) { await this.save(sessionId, ""); }
+}

package/dist/worker/console/chat/context-panel.js

@@ -0,0 +1,54 @@
+import { humanGateCardFromEventPayload } from "./human-gate-card.js";
+import { mergeOperationCardState, operationFromEventPayload } from "./operation-card.js";
+function taskIdOf(event) {
+    if (!["interview-turn", "draft", "assessment", "taskKind-confirmed", "human-gate-card"].includes(event.kind))
+        return undefined;
+    const value = event.data.taskId;
+    return typeof value === "string" && value ? value : undefined;
+}
+function safeGate(card) {
+    const { humanGateToken: _token, ...safe } = card;
+    return safe;
+}
+export function projectTaskContext(input) {
+    const events = [...input].sort((a, b) => a.seq - b.seq);
+    const latest = events.at(-1);
+    let activeTaskId;
+    for (const event of events)
+        activeTaskId = taskIdOf(event) ?? activeTaskId;
+    const view = { schemaVersion: 1, operations: [], ...(latest ? { sessionId: latest.sessionId, lastEventId: latest.eventId, updatedAt: latest.at } : {}), ...(activeTaskId ? { taskId: activeTaskId } : {}) };
+    const gates = new Map();
+    for (const event of events) {
+        const eventTaskId = taskIdOf(event);
+        if (eventTaskId && activeTaskId && eventTaskId !== activeTaskId)
+            continue;
+        const data = event.data;
+        if (event.kind === "interview-turn")
+            view.interview = { interviewSessionId: typeof data.interviewSessionId === "string" ? data.interviewSessionId : undefined, state: typeof data.state === "string" ? data.state : undefined, question: data.question && typeof data.question === "object" ? data.question : undefined };
+        else if (event.kind === "draft" && typeof data.draftSha256 === "string" && data.draft && typeof data.draft === "object")
+            view.draft = { value: data.draft, draftSha256: data.draftSha256, ...(typeof data.taskKindRecommendation === "string" ? { taskKindRecommendation: data.taskKindRecommendation } : {}) };
+        else if (event.kind === "assessment" && typeof data.outcome === "string")
+            view.assessment = { outcome: data.outcome, fresh: data.fresh === true, missingFields: Array.isArray(data.missingFields) ? data.missingFields.map(String) : [], ...(typeof data.reason === "string" ? { reason: data.reason } : {}), ...(typeof data.assessmentId === "string" ? { assessmentId: data.assessmentId } : {}) };
+        else if (event.kind === "taskKind-confirmed" && typeof data.taskKind === "string" && typeof data.confirmedAt === "string")
+            view.taskKind = { value: data.taskKind, confirmedAt: data.confirmedAt, confirmedBy: "human" };
+        else if (event.kind === "human-gate-card") {
+            const card = humanGateCardFromEventPayload(data);
+            if (!card)
+                continue;
+            const previous = gates.get(card.cardId);
+            gates.set(card.cardId, safeGate({ ...card, ...(previous?.dagSpine && !card.dagSpine ? { dagSpine: previous.dagSpine } : {}) }));
+        }
+        else if (event.kind === "operation-ref" || event.kind === "operation-status") {
+            const operation = operationFromEventPayload(data);
+            if (operation && (!activeTaskId || !operation.taskId || operation.taskId === activeTaskId))
+                view.operations = mergeOperationCardState(view.operations, operation);
+        }
+    }
+    for (const gate of gates.values()) {
+        if (gate.gateType === "contract-apply")
+            view.contract = { diffSummary: gate.contractDiffSummary, revision: gate.contractRevision, confirmationState: gate.state, gate };
+        else
+            view.dag = { spine: gate.dagSpine, confirmationState: gate.state, gate };
+    }
+    return view;
+}