@tea-agent/loop-agent 0.41.1-beta.0 → 0.41.1

package/dist/worker/console/chat/turn-process.js

@@ -2,7 +2,7 @@
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
-import { semanticActivityForTool, } from "./semantic-activity.js";
+import { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
 function emptyGroup(key) {
     return {
         key,
@@ -72,14 +72,22 @@ export function hydrateSessionThread(raw) {
                 turnId = item.turnId;
             if (!turnId)
                 turnId = `restored-tool-${item.id}`;
+            // Prefer event-ring timestamps (tool_call at → tool_result at) so
+            // refreshed sessions keep real elapsed durations instead of 0ms.
+            const startedAtMs = item.startedAt ? Date.parse(item.startedAt) : NaN;
+            const finishedAtMs = item.finishedAt ? Date.parse(item.finishedAt) : NaN;
             const entry = {
                 id: item.toolCallId || item.id,
                 toolName: item.toolName || "tool",
                 status: item.isError === true ? "error" : "ok",
                 resultText: item.text,
                 result: item.text,
-                createdAt,
-                finishedAt: createdAt,
+                createdAt: Number.isFinite(startedAtMs)
+                    ? startedAtMs
+                    : createdAt,
+                finishedAt: Number.isFinite(finishedAtMs)
+                    ? finishedAtMs
+                    : createdAt,
                 turnId: item.turnId ?? turnId,
                 ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
                 ...(item.finishedSeq === undefined
@@ -88,7 +96,10 @@ export function hydrateSessionThread(raw) {
                 ...(item.operationId ? { operationId: item.operationId } : {}),
             };
             toolCalls.push(entry);
-            pendingTools.push(entry);
+            // Durable rows with an event sequence are already self-ordering. Only
+            // legacy rows need the historical "next assistant" attribution fallback.
+            if (item.eventSeq === undefined)
+                pendingTools.push(entry);
         }
     }
     return { messages, toolCalls };
@@ -118,6 +129,11 @@ function flushToolBuffer(processItems, buffer) {
         return;
     const sorted = sortToolsStable(buffer);
     for (const tool of sorted) {
+        const dagProgress = dagProgressActivityForTool(tool);
+        if (dagProgress) {
+            processItems.push({ kind: "dag-progress", progress: dagProgress });
+            continue;
+        }
         const activity = semanticActivityForTool(tool);
         if (activity) {
             processItems.push({ kind: "activity", activity });
@@ -127,48 +143,92 @@ function flushToolBuffer(processItems, buffer) {
         }
     }
 }
-function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
-    let buffer = [];
-    for (const block of blocks) {
-        if (block.type === "thinking") {
-            flushToolBuffer(processItems, buffer);
-            buffer = [];
-            processItems.push({ kind: "thinking", thinking: block.thinking });
-            continue;
-        }
-        if (block.type === "text") {
-            flushToolBuffer(processItems, buffer);
-            buffer = [];
-            if (block.text.trim()) {
-                processItems.push({ kind: "text", text: block.text });
+function collapseDagProgressItems(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (item.kind !== "dag-progress")
+            return true;
+        if (seen.has(item.progress.activityRef))
+            return false;
+        seen.add(item.progress.activityRef);
+        return true;
+    });
+}
+function fillProcessDetails(group) {
+    const usedToolIds = new Set();
+    const nodes = [];
+    let insertionOrder = 0;
+    const addNode = (input) => {
+        if (input.items.length === 0)
+            return;
+        nodes.push({
+            ...(input.eventSeq === undefined ? {} : { eventSeq: input.eventSeq }),
+            createdAt: input.createdAt,
+            insertionOrder: insertionOrder++,
+            items: input.items,
+        });
+    };
+    const addAssistantNode = (assistant, blocks, includeProviderError = false) => {
+        let items = [];
+        let anchorSeq = assistant.eventSeq;
+        let anchorAt = assistant.createdAt;
+        const flushItems = () => {
+            addNode({
+                items,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: anchorAt,
+            });
+            items = [];
+        };
+        for (const block of blocks) {
+            if (block.type === "thinking") {
+                items.push({ kind: "thinking", thinking: block.thinking });
+                continue;
             }
-            continue;
+            if (block.type === "text") {
+                if (block.text.trim())
+                    items.push({ kind: "text", text: block.text });
+                continue;
+            }
+            const tool = group.tools.find((entry) => entry.id === block.toolCallId);
+            if (!tool || usedToolIds.has(tool.id))
+                continue;
+            flushItems();
+            usedToolIds.add(tool.id);
+            const toolItems = [];
+            flushToolBuffer(toolItems, [tool]);
+            addNode({
+                items: toolItems,
+                ...(tool.eventSeq === undefined
+                    ? anchorSeq === undefined
+                        ? {}
+                        : { eventSeq: anchorSeq }
+                    : { eventSeq: tool.eventSeq }),
+                createdAt: tool.createdAt,
+            });
+            anchorSeq = tool.eventSeq ?? anchorSeq;
+            anchorAt = tool.createdAt;
         }
-        const tool = group.tools.find((entry) => entry.id === block.toolCallId);
-        if (tool && !usedToolIds.has(tool.id)) {
-            buffer.push(tool);
+        if (includeProviderError && assistant.providerError) {
+            items.push({ kind: "provider-error", error: assistant.providerError });
+        }
+        flushItems();
+        // Preserve the old-data fallback after this stage. Sequenced unmatched
+        // tools stay independent and are merged by their own eventSeq below.
+        const legacyUnmatched = group.tools.filter((tool) => !usedToolIds.has(tool.id) &&
+            tool.eventSeq === undefined &&
+            tool.assistantMessageId === assistant.id);
+        for (const tool of sortToolsStable(legacyUnmatched)) {
             usedToolIds.add(tool.id);
+            const toolItems = [];
+            flushToolBuffer(toolItems, [tool]);
+            addNode({
+                items: toolItems,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: Math.max(anchorAt, tool.createdAt),
+            });
         }
-    }
-    flushToolBuffer(processItems, buffer);
-}
-/**
- * Insert tools attributed to this assistant stage but without a matching
- * content toolCall block (live SSE tool_call frames often arrive before the
- * assistant content does). They follow the stage's thinking/text instead of
- * sinking to the end of the whole turn.
- */
-function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds) {
-    const unmatched = group.tools.filter((tool) => !usedToolIds.has(tool.id) && tool.assistantMessageId === assistant.id);
-    if (unmatched.length === 0)
-        return;
-    for (const tool of unmatched)
-        usedToolIds.add(tool.id);
-    flushToolBuffer(processItems, unmatched);
-}
-function fillProcessDetails(group) {
-    const usedToolIds = new Set();
-    const processItems = [];
+    };
     const lastAssistant = group.assistants.at(-1);
     const finalAssistant = lastAssistant?.kind === "provider-error" ? undefined : lastAssistant;
     const finalIndex = finalAssistant
@@ -178,30 +238,47 @@ function fillProcessDetails(group) {
         if (index === finalIndex)
             continue;
         if (assistant.kind === "provider-error" && assistant.providerError) {
-            emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
-            appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
-            processItems.push({
-                kind: "provider-error",
-                error: assistant.providerError,
-            });
+            addAssistantNode(assistant, getDisplayableAssistantBlocks(assistant.content ?? []), true);
             continue;
         }
-        emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
-        appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+        addAssistantNode(assistant, getDisplayableAssistantBlocks(assistant.content ?? []));
     }
     const blocks = finalAssistant?.content ?? [];
     const split = splitFinalAssistantBlocks(blocks, { isStreaming: group.live });
-    emitProcessBlocks(split.processBlocks, group, processItems, usedToolIds);
     if (finalAssistant) {
-        appendAssistantUnmatchedTools(group, finalAssistant, processItems, usedToolIds);
+        addAssistantNode(finalAssistant, split.processBlocks);
+    }
+    // DSH-style peer nodes: a sequenced tool keeps its own anchor instead of
+    // being appended to whichever assistant id happens to own it at render time.
+    for (const tool of group.tools) {
+        if (usedToolIds.has(tool.id) || tool.eventSeq === undefined)
+            continue;
+        usedToolIds.add(tool.id);
+        const items = [];
+        flushToolBuffer(items, [tool]);
+        nodes.push({
+            eventSeq: tool.eventSeq,
+            createdAt: tool.createdAt,
+            insertionOrder: insertionOrder++,
+            items,
+        });
     }
-    // Bounded fallback for legacy restored rows with no assistant attribution:
-    // keep them at this turn's end in stable server order instead of randomly
-    // interleaving them into earlier stages.
-    const orphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
-    if (orphans.length > 0)
-        flushToolBuffer(processItems, orphans);
-    group.processItems = processItems;
+    const fullySequenced = nodes.every((node) => node.eventSeq !== undefined);
+    nodes.sort((a, b) => {
+        if (fullySequenced && a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        return a.insertionOrder - b.insertionOrder;
+    });
+    const processItems = nodes.flatMap((node) => node.items);
+    // Bounded fallback for legacy restored rows with neither event sequence nor
+    // assistant attribution: keep them at the turn end in stable local order.
+    const legacyOrphans = group.tools.filter((tool) => !usedToolIds.has(tool.id));
+    if (legacyOrphans.length > 0)
+        flushToolBuffer(processItems, legacyOrphans);
+    group.processItems = collapseDagProgressItems(processItems);
     if (!finalAssistant)
         return;
     if (blocks.length === 0) {
@@ -282,7 +359,9 @@ export function buildTurnProcessGroups(input) {
         if (assigned.has(tool.id))
             continue;
         if (tool.turnId) {
-            const byTurn = groups.find((group) => group.tools.some((t) => t.turnId === tool.turnId) ||
+            const byTurn = groups.find((group) => group.user?.turnId === tool.turnId ||
+                group.assistants.some((assistant) => assistant.turnId === tool.turnId) ||
+                group.tools.some((t) => t.turnId === tool.turnId) ||
                 group.key === `turn-${tool.turnId}` ||
                 (group.user && `restored-${group.user.id}` === tool.turnId));
             if (byTurn) {

package/dist/worker/console/index.js

@@ -11,9 +11,6 @@ export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateT
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";
 export { OperationStore } from "./operation-store.js";
-export { createFrontendSplitOperationAdapter } from "./frontend-split-operation-adapter.js";
-export { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
-export { FrontendSplitTaskMaterializer } from "../materialize/frontend-split-task-materializer.js";
 export { createOperationEventStore } from "./operation-sse.js";
 export { DagConfirmationStore } from "./dag-confirmation.js";
 export { DraftStore } from "./draft-store.js";

package/dist/worker/console/operation-store.js

@@ -1,9 +1,5 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
-import { assertFrontendSplitProjectionSuccessor, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
-import { buildFrontendHumanDecisionProjection, consumeFrontendHumanDecision, materializeFrontendHumanDecision, parseFrontendHumanDecisionProjection, parseFrontendHumanDecisionReceipt, } from "../../workflows/dag/frontend-human-decision.js";
-import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finalizeFrontendSplitAggregate, frontendCommittedFactRefSchema, frontendSplitChildCloseoutFactsSchema, initializeFrontendSplitParent, } from "../../workflows/dag/frontend-split-orchestrator.js";
-import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
 export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
 function operationFile(appData, operationId) {
@@ -19,21 +15,16 @@ export function computeActionPayloadHash(action, actionParams) {
 export function newOperationId() {
     return `op_${randomBytes(12).toString("hex")}`;
 }
-const sharedWriteChains = new Map();
 export class OperationStore {
     appData;
-    /** Shared per-store-root, per-key write lock. Multiple OperationStore instances
-     * in one worker process must observe the same CAS critical section. */
-    writeChains;
+    /**
+     * Per-key write lock. Concurrent update/save/create on the same operation
+     * or clientRequestId must not race rename() into the same JSON path
+     * (Windows EPERM) or last-write-wins lost patches.
+     */
+    writeChains = new Map();
     constructor(appData) {
         this.appData = appData;
-        const root = path.resolve(appData.operations);
-        let chains = sharedWriteChains.get(root);
-        if (!chains) {
-            chains = new Map();
-            sharedWriteChains.set(root, chains);
-        }
-        this.writeChains = chains;
     }
     serialize(key, op) {
         const prev = this.writeChains.get(key) ?? Promise.resolve();
@@ -75,7 +66,6 @@ export class OperationStore {
                 payloadHash,
                 state: "queued",
                 createdAt: now,
-                revision: 1,
                 taskId: input.taskId,
                 cliArgs: input.cliArgs,
                 ...(input.externalCommand
@@ -87,61 +77,11 @@ export class OperationStore {
             return { kind: "created", operation };
         });
     }
-    /**
-     * Idempotently materialize a split child/integration operation with a
-     * caller-specified deterministic operationId (from the split manifest).
-     * Unlike create() (random op_<hex> id) and save/update (no create), this is
-     * the durable cross-restart idempotency boundary for the production
-     * FrontendSplitTaskMaterializer backend: an existing operation file with the
-     * same taskId + payloadHash is returned as {created:false}; any drift fails
-     * closed instead of overwriting or silently diverging.
-     */
-    async ensureSplitMaterializedOperation(input) {
-        return this.serialize(input.operationId, async () => {
-            const existing = await this.get(input.operationId);
-            if (existing) {
-                if (existing.taskId !== input.taskId ||
-                    existing.payloadHash !== input.payloadHash) {
-                    throw new Error("frontend split operation materialization payload drift");
-                }
-                return { operation: existing, created: false };
-            }
-            const now = new Date().toISOString();
-            const operation = {
-                schemaVersion: 1,
-                operationId: input.operationId,
-                clientRequestId: `split:${input.operationId}`,
-                action: input.action,
-                actionParams: input.actionParams,
-                payloadHash: input.payloadHash,
-                state: "queued",
-                createdAt: now,
-                revision: 1,
-                taskId: input.taskId,
-                ...(input.cliArgs ? { cliArgs: input.cliArgs } : {}),
-            };
-            await writeSecureJson(operationFile(this.appData, input.operationId), operation);
-            return { operation, created: true };
-        });
-    }
     async get(operationId) {
         return readJsonIfExists(operationFile(this.appData, operationId));
     }
     async save(operation) {
         return this.serialize(operation.operationId, async () => {
-            const current = await this.get(operation.operationId);
-            if (current?.revision !== undefined && operation.revision !== current.revision)
-                throw new Error("operation revision may not be changed by save");
-            if (operation.frontendHumanDecision !== undefined || current?.frontendHumanDecision !== undefined) {
-                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
-                    throw new Error("human-decision projection may only be mutated by canonical CAS");
-                return current;
-            }
-            if (operation.frontendSplit !== undefined || current?.frontendSplit !== undefined) {
-                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
-                    throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
-                return current;
-            }
             await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
             return operation;
         });
@@ -152,10 +92,6 @@ export class OperationStore {
             if (!current) {
                 throw new Error(`operation not found: ${operationId}`);
             }
-            if ("frontendHumanDecision" in patch || (current.frontendHumanDecision !== undefined && ("state" in patch || "frontendExecution" in patch)))
-                throw new Error("human-decision projection may only be mutated by canonical CAS");
-            if ("frontendSplit" in patch || "revision" in patch || (current.frontendSplit !== undefined && ("state" in patch || "frontendExecution" in patch)))
-                throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
             const next = {
                 ...current,
                 ...patch,
@@ -170,162 +106,6 @@ export class OperationStore {
             return next;
         });
     }
-    async materializeFrontendHumanDecision(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision) {
-                const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.envelope.runId, revision: Math.max(1, input.expectedRecordRevision) });
-                return { outcome: "rejected", reason: "record revision conflict or legacy record", projection: fallback };
-            }
-            const projection = current.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: current.operationId, runId: input.envelope.runId, revision: current.revision });
-            const result = materializeFrontendHumanDecision({ projection, envelope: input.envelope, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest });
-            if (result.outcome !== "applied")
-                return result;
-            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection, state: "running" };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return result;
-        });
-    }
-    async consumeFrontendHumanDecision(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || !current.frontendHumanDecision) {
-                const fallback = buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
-                return { outcome: "rejected", reason: "record has no mutable human-decision projection", projection: fallback };
-            }
-            const projection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
-            if (current.revision !== input.expectedRecordRevision)
-                return { outcome: "rejected", reason: "record revision conflict", projection };
-            const result = consumeFrontendHumanDecision({ projection, receipt: input.receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
-            if (result.outcome !== "applied")
-                return result;
-            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return result;
-        });
-    }
-    async initializeFrontendHumanApprovedSplit(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
-            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision || !current.frontendHumanDecision || !current.frontendExecution || current.frontendSplit)
-                return { outcome: "rejected", reason: "record is not an authoritative pending single-task split", projection: fallback };
-            const humanProjection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
-            if (humanProjection.status !== "blocked-human" || humanProjection.envelope.kind !== "split-materialization-approval" || humanProjection.digest !== input.expectedProjectionDigest)
-                return { outcome: "rejected", reason: "pending split envelope conflict", projection: humanProjection };
-            const receipt = parseFrontendHumanDecisionReceipt(input.receipt);
-            if (receipt.kind !== "split-materialization-approval")
-                return { outcome: "rejected", reason: "receipt is not a split approval", projection: humanProjection };
-            if (JSON.stringify(current.frontendExecution) !== JSON.stringify(input.execution) || input.execution.kind !== "single-task")
-                return { outcome: "rejected", reason: "single-task execution conflict", projection: humanProjection };
-            const consumed = consumeFrontendHumanDecision({ projection: humanProjection, receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
-            if (consumed.outcome !== "applied")
-                return consumed;
-            const initialized = initializeFrontendSplitParent({
-                execution: input.execution,
-                manifest: input.manifest,
-                expectedOperationRevision: input.execution.operationRevision,
-                successorOperationRevision: consumed.projection.revision,
-                envelopeTargetDigest: humanProjection.envelope.targetDigest,
-                activeWriterOperationId: input.activeWriterOperationId,
-                activeProviderOperationId: input.activeProviderOperationId,
-                authorization: { mode: "human", envelope: humanProjection.envelope, receipt },
-            });
-            if (initialized.outcome !== "applied")
-                return { outcome: "rejected", reason: initialized.reason, projection: humanProjection };
-            const splitProjection = frontendSplitProjectionSchema.parse({ revision: consumed.projection.revision, execution: initialized.execution, manifest: input.manifest, parent: initialized.parent });
-            const { frontendExecution: _singleTask, ...withoutSingleTask } = current;
-            const record = { ...withoutSingleTask, revision: consumed.projection.revision, frontendHumanDecision: consumed.projection, frontendSplit: splitProjection, state: "running" };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return { outcome: "applied", projection: splitProjection, humanDecision: consumed.projection };
-        });
-    }
-    async compareAndSwapFrontendSplit(input) {
-        return this.serialize(input.operationId, async () => {
-            const current = await this.get(input.operationId);
-            if (!current || current.revision === undefined || current.revision !== input.expectedRevision)
-                return { outcome: "conflict" };
-            const currentProjection = current.frontendSplit;
-            if (currentProjection) {
-                if (currentProjection.execution.digest !== input.expectedExecutionDigest || currentProjection.parent.digest !== input.expectedParentDigest)
-                    return { outcome: "conflict" };
-            }
-            else if (input.expectedExecutionDigest || input.expectedParentDigest)
-                return { outcome: "conflict" };
-            const next = currentProjection
-                ? assertFrontendSplitProjectionSuccessor(currentProjection, input.next)
-                : frontendSplitProjectionSchema.parse(input.next);
-            if (next.revision !== current.revision + 1 || next.parent.operationId !== input.operationId)
-                throw new Error("split CAS next revision or operation binding mismatch");
-            const state = next.parent.operationState === "success" ? "succeeded" : next.parent.operationTerminal !== undefined ? "failed" : current.state;
-            const record = { ...current, revision: next.revision, frontendSplit: next, state };
-            await writeSecureJson(operationFile(this.appData, input.operationId), record);
-            return { outcome: "applied", projection: next };
-        });
-    }
-    async loadChildCloseoutFacts(input) {
-        const factsDir = input.closeoutRef.ref;
-        const facts = await readJsonIfExists(path.join(factsDir, "frontend-closeout-facts.json"));
-        if (facts === undefined)
-            return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: [], frontendTestHandoffRef: undefined });
-        const parsedFacts = frontendCloseoutFactsSchema.parse(facts);
-        if (computeFrontendSplitDigest(parsedFacts) !== input.closeoutRef.digest)
-            throw new Error(`child closeout facts digest mismatch: ${input.childId}`);
-        const handoff = await readJsonIfExists(path.join(factsDir, "frontend-test-handoff.json"));
-        const frontendTestHandoffRef = handoff === undefined ? undefined : computeFrontendSplitDigest(frontendTestHandoffSchema.parse(handoff));
-        return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: parsedFacts.residualRisks ?? [], frontendTestHandoffRef });
-    }
-    async settleFrontendSplitAggregate(input) {
-        return this.serialize(input.operationId, async () => {
-            const record = await this.get(input.operationId);
-            if (!record || record.revision === undefined || record.revision !== input.expectedRevision || !record.frontendSplit)
-                return { outcome: "conflict" };
-            const authoritative = frontendSplitProjectionSchema.parse(record.frontendSplit);
-            if (authoritative.parent.operationId !== input.operationId
-                || authoritative.revision !== input.expectedRevision
-                || authoritative.execution.digest !== input.expectedExecutionDigest
-                || authoritative.parent.digest !== input.expectedParentDigest
-                || authoritative.manifest.digest !== input.expectedManifestDigest
-                || authoritative.candidateBinding?.digest !== input.expectedCandidateBindingDigest
-                || authoritative.integrationBinding?.digest !== input.expectedIntegrationBindingDigest)
-                return { outcome: "conflict" };
-            if (!authoritative.candidateBinding)
-                return { outcome: "conflict" };
-            const expectedAggregate = buildFrontendSplitAggregateCloseout(authoritative.parent, authoritative.manifest, authoritative.candidateBinding, authoritative.integrationBinding, input.childCloseoutFacts);
-            if (JSON.stringify(expectedAggregate) !== JSON.stringify(input.aggregate))
-                return { outcome: "conflict" };
-            const transaction = await input.prepareAggregate({
-                operationId: authoritative.parent.operationId,
-                aggregate: expectedAggregate,
-            });
-            try {
-                const committedRef = frontendCommittedFactRefSchema.parse(transaction.committedRef);
-                const finalized = finalizeFrontendSplitAggregate(authoritative.parent, expectedAggregate, committedRef);
-                const next = assertFrontendSplitProjectionSuccessor(authoritative, { ...authoritative, revision: authoritative.revision + 1, parent: finalized.parent, execution: finalized.execution, aggregateCloseout: { value: expectedAggregate, committedRef } });
-                const nextRecord = { ...record, revision: next.revision, frontendSplit: next, state: "succeeded" };
-                await transaction.commit({
-                    parentRecordPath: operationFile(this.appData, record.operationId),
-                    parentRecord: nextRecord,
-                });
-                return { outcome: "applied", projection: next };
-            }
-            catch (error) {
-                await transaction.rollback();
-                throw error;
-            }
-        });
-    }
-    async initializeFrontendSplit(expectedRevision, projectionValue) {
-        const projection = frontendSplitProjectionSchema.parse(projectionValue);
-        return this.serialize(projection.parent.operationId, async () => {
-            const current = await this.get(projection.parent.operationId);
-            if (!current || current.revision === undefined || current.revision !== expectedRevision || current.frontendSplit !== undefined || projection.revision !== expectedRevision + 1)
-                return { outcome: "conflict" };
-            const record = { ...current, revision: projection.revision, frontendSplit: projection };
-            await writeSecureJson(operationFile(this.appData, current.operationId), record);
-            return { outcome: "applied", projection };
-        });
-    }
     async list() {
         const files = await listJsonFiles(this.appData.operations);
         const ops = [];