@tea-agent/loop-agent 0.33.4 → 0.33.5

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [0.33.5] - 2026-08-11
+
+### 重点更新
+
+- 全面加固 Operator Chat 流式响应的执行可靠性，对齐 pi-web 四层保障机制，彻底解决重连后界面无限加载、空占位气泡卡死等问题
+- 优化前端测试的目标 URL 解析机制，改为从运行时上下文精准解析，并丰富执行报告的细节展示
+- 修复测试生成与执行环境中的多处转义错误，提升复杂脚本生成的稳定性
+
+### 新增
+
+- 新增轻量级会话状态轮询接口（GET /sessions/:id/state），用于快速获取真实的活跃任务状态
+- 前端测试执行报告新增更丰富的细节展示，并支持从运行时上下文中精准解析目标 URL
+
+### 改进
+
+- Operator Chat 客户端现支持每 15 秒及页面可见性变化时定期对账服务端真实状态，当服务端已空闲而客户端仍在加载时自动强制结束
+- 优化重连时的回放保护机制：仅当回放事件的任务 ID 与服务端真实活跃 ID 匹配时才继续流式响应，防止已结束的任务被错误唤醒
+- 前端测试默认短链失败用例现仅重跑 1 次，而阻断性审查节点分支默认重跑 2 次，显式配置仍可覆盖默认值
+
+### 修复
+
+- 修复 Operator Chat 在中断或失败时未写入持久结束事件，导致重连回放卡在开始阶段、界面无限加载的问题
+- 修复对话中断或结束时残留空白占位气泡和卡死省略号的问题，现自动清理未产生内容的消息
+- 修复前端测试重跑选择器生成的 Shell JavaScript 丢失正则反斜杠和换行转义，导致报语法错误的问题
+- 修复前端测试环境预检脚本将 URL 尾部反引号匹配规则展开为裸 Shell 反引号，导致命令替换未闭合的问题
+- 修复后端测试偶尔按优先级生成单一模块文件的问题，现对非法模块命名执行严格阻断
+- 修复后端测试分片完整性校验误判合法测试字符串中未配对分隔符为脚本截断的问题
+
 ## [0.33.4] - 2026-08-10
 
 ### 重点更新

package/dist/executors/dag-pi-executor.js

@@ -324,25 +324,47 @@ export async function writePiExecutorArtifacts(artifactsDir, input) {
     await writeTextArtifactFile(summaryPath, buildPiResultSummaryMarkdown(input));
     return { promptPath, summaryPath };
 }
-async function resolveControllerOwnedFrontendBaseUrl(runDir) {
-    const capabilityPath = path.join(runDir, "preflight-frontend-browser-tool-shell", "frontend-browser-capability.json");
-    let capability;
+async function resolveValidatedFrontendBaseUrlFromContext(workspaceRoot, runDir) {
     try {
-        capability = JSON.parse(await readFile(capabilityPath, "utf8"));
+        const capability = JSON.parse(await readFile(path.join(runDir, "preflight-frontend-browser-tool-shell", "frontend-browser-capability.json"), "utf8"));
+        if (capability.status !== "ready" ||
+            capability.structuredToolName !== "playwright_cli") {
+            throw new Error("invalid capability artifact");
+        }
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: missing or invalid frontend browser capability artifact");
+    }
+    const contextPath = path.join(workspaceRoot, "testcase", "frontend", "rag", "context.md");
+    let markdown;
+    try {
+        markdown = await readFile(contextPath, "utf8");
     }
     catch {
-        throw new Error("browser-command-capability-unavailable: missing controller-owned frontend browser capability artifact");
+        throw new Error("browser-command-capability-unavailable: missing frontend context.md after environment preflight");
+    }
+    const patterns = [
+        /baseUrl\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /base[-_ ]url\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /playwright-cli open --browser=chrome\s+((?:https?):\/\/[^\s"'`<>]+)/i,
+    ];
+    let rawBaseUrl;
+    for (const pattern of patterns) {
+        const match = markdown.match(pattern);
+        if (match?.[1]) {
+            rawBaseUrl = match[1].replace(/[)\]},.;]+$/, "");
+            break;
+        }
     }
-    if (capability.status !== "ready" ||
-        typeof capability.baseUrl !== "string") {
-        throw new Error("browser-command-capability-unavailable: invalid controller-owned frontend browser capability artifact");
+    if (!rawBaseUrl || !/environmentProbe\s*[:=]\s*reachable/i.test(markdown)) {
+        throw new Error("browser-command-capability-unavailable: frontend context URL is missing or not environment-validated");
     }
     let parsed;
     try {
-        parsed = new URL(capability.baseUrl);
+        parsed = new URL(rawBaseUrl);
     }
     catch {
-        throw new Error("browser-command-capability-unavailable: invalid controller-owned frontend browser origin");
+        throw new Error("browser-command-capability-unavailable: invalid frontend context origin");
     }
     if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
         parsed.username ||
@@ -350,7 +372,7 @@ async function resolveControllerOwnedFrontendBaseUrl(runDir) {
         parsed.search ||
         parsed.hash ||
         /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(parsed.hostname)) {
-        throw new Error("browser-command-capability-unavailable: unsafe controller-owned frontend browser origin");
+        throw new Error("browser-command-capability-unavailable: unsafe frontend context origin");
     }
     return parsed.toString();
 }
@@ -466,7 +488,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                             nodeId: input.task.id,
                             caseId,
                             evidenceDir,
-                            baseUrl: await resolveControllerOwnedFrontendBaseUrl(meta.runDir),
+                            baseUrl: await resolveValidatedFrontendBaseUrlFromContext(input.cwd, meta.runDir),
                             inputRoot: "testcase/frontend/fixtures",
                         };
                         // Cleanup must be confirmed before a new case; otherwise default-session

package/dist/executors/shell-executor.js

@@ -1,5 +1,4 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -30,9 +29,9 @@ import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBa
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
-import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -40,7 +39,6 @@ import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcela
 import { parseAndValidateFinalWriteSetApproval, } from "../workflows/dag/node-execution.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 import { readRunState } from "../workflows/dag/run-store.js";
-import { resolveDagTaskSourcePath } from "../task/dag-source-paths.js";
 import { readProjectGovernanceContext } from "../workflows/dag/project-governance-context.js";
 import { assertMavenPlanFresh, MavenPlanStaleError, } from "../verification/maven/index.js";
 async function runBackendScenarioParamPreflight(input) {
@@ -197,56 +195,6 @@ export function resolveShellCwd(root, requestedCwd) {
     }
     return resolved;
 }
-async function resolveControllerFrontendBaseUrlForPreflight(input) {
-    const binding = input.spec.sourceBinding;
-    const candidates = (binding?.sources ?? []).filter((source) => /(?:^|\/)config\.md$/i.test(source.path));
-    let rawBaseUrl = "http://localhost:5173";
-    let baseUrlSource = "default-localhost-5173";
-    let baseUrlSourceSha256;
-    for (const source of candidates) {
-        const absolutePath = resolveDagTaskSourcePath({
-            workspaceRoot: input.workspaceRoot,
-            taskId: binding.taskId,
-            sourcePath: source.path,
-        });
-        const markdown = await readFile(absolutePath, "utf8");
-        const actualSha256 = createHash("sha256").update(markdown).digest("hex");
-        if (actualSha256 !== source.sha256) {
-            throw new Error(`browser-command-capability-unavailable: stale frontend source ${source.path}`);
-        }
-        const match = markdown.match(/(?:frontend[_-]?base[_-]?url|base[_-]?url|base[- ]url)\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i);
-        if (!match?.[1]) {
-            if (/(?:frontend[_-]?base[_-]?url|base[_-]?url|base[- ]url)\s*[:=]/i.test(markdown)) {
-                throw new Error(`browser-command-capability-unavailable: invalid controller baseUrl from ${source.path}`);
-            }
-            continue;
-        }
-        rawBaseUrl = match[1].replace(/[)\]},.;]+$/, "");
-        baseUrlSource = source.path;
-        baseUrlSourceSha256 = source.sha256;
-        break;
-    }
-    let parsed;
-    try {
-        parsed = new URL(rawBaseUrl);
-    }
-    catch {
-        throw new Error(`browser-command-capability-unavailable: invalid controller baseUrl from ${baseUrlSource}`);
-    }
-    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
-        parsed.username ||
-        parsed.password ||
-        parsed.search ||
-        parsed.hash ||
-        /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(parsed.hostname)) {
-        throw new Error(`browser-command-capability-unavailable: unsafe controller baseUrl from ${baseUrlSource}`);
-    }
-    return {
-        baseUrl: parsed.toString(),
-        baseUrlSource,
-        ...(baseUrlSourceSha256 ? { baseUrlSourceSha256 } : {}),
-    };
-}
 async function resolveJsonArtifactSourceNodeId(input) {
     const candidates = [
         input.fromNodeId,
@@ -598,6 +546,15 @@ async function executeBackendTestPipeline(input, meta) {
                     durationMs: Date.now() - started,
                 };
             }
+            if (hasBlockingBackendMarkdownModuleStemFindings(report)) {
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n"),
+                    stderr: "backend Markdown module stem gate blocked: priority-only-module-stem",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
             const sourceBinding = meta.spec.sourceBinding;
             if (!sourceBinding) {
                 const coverage = "# Backend Test Case Coverage Analysis\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Coverage analysis requires spec.sourceBinding; node 4 and node 7 fail closed on the same task/source binding contract.\n";
@@ -651,7 +608,16 @@ async function executeBackendTestPipeline(input, meta) {
         else if (pipeline === "markdown-collection-assess") {
             const resolution = await resolveBackendTestMappedPytestScripts(input.cwd);
             let facts;
-            if (resolution.missingScripts.length > 0) {
+            const preflightInventory = await buildBackendPytestAssetInventory(input.cwd, resolution.existingScripts, { requireMappedScripts: false });
+            const priorityOnlyFacts = assessPriorityOnlyBackendPytestModules({
+                phase: "initial",
+                mappedScripts: resolution.expectedScripts,
+                inventory: preflightInventory,
+            });
+            if (priorityOnlyFacts) {
+                facts = priorityOnlyFacts;
+            }
+            else if (resolution.missingScripts.length > 0) {
                 const inventory = await buildBackendPytestAssetInventory(input.cwd, resolution.existingScripts, { requireMappedScripts: false });
                 facts = assessMissingBackendPytestScripts({
                     mappedScripts: resolution.expectedScripts,
@@ -2138,17 +2104,15 @@ export async function executeDagShellNode(input, meta) {
             if (!sdkCapability.ok) {
                 throw new Error(`browser-command-capability-unavailable: ${sdkCapability.detail}`);
             }
-            const controllerOrigin = await resolveControllerFrontendBaseUrlForPreflight({
-                workspaceRoot: input.cwd,
-                spec: meta.spec,
-            });
             const toolProbe = await createPlaywrightCliTool({
                 repoRoot: input.cwd,
                 runDir: meta.runDir,
                 nodeId: input.task.id,
                 caseId: "frontend-browser-preflight",
                 evidenceDir: "testcase/frontend/evidence/frontend-browser-preflight",
-                baseUrl: controllerOrigin.baseUrl,
+                // Capability-only registration probe. The tested URL is selected later by
+                // retrieve-frontend-test-context-pi and validated by the environment shell.
+                baseUrl: "http://localhost:5173/",
                 inputRoot: "testcase/frontend/fixtures",
             });
             if (toolProbe.name !== "playwright_cli") {
@@ -2165,7 +2129,7 @@ export async function executeDagShellNode(input, meta) {
             const help = `${result.stdout}\n${result.stderr}`;
             if (result.exitCode !== 0 ||
                 result.timedOut ||
-                !["open", "close", "snapshot", "click"].every((command) => new RegExp(`\\b${command}\\b`, "i").test(help))) {
+                !["open", "close", "find", "snapshot", "click"].every((command) => new RegExp(`\\b${command}\\b`, "i").test(help))) {
                 throw new Error("playwright-cli-contract-incompatible");
             }
             const capability = {
@@ -2175,11 +2139,7 @@ export async function executeDagShellNode(input, meta) {
                 launcher: "verified-js-entry",
                 sdkCustomToolCapability: true,
                 structuredToolName: toolProbe.name,
-                baseUrl: controllerOrigin.baseUrl,
-                baseUrlSource: controllerOrigin.baseUrlSource,
-                ...(controllerOrigin.baseUrlSourceSha256
-                    ? { baseUrlSourceSha256: controllerOrigin.baseUrlSourceSha256 }
-                    : {}),
+                targetUrlAuthority: "retrieve-context-and-environment-probe",
             };
             await writeDagNodeJsonArtifact(meta.runDir, input.task.id, "frontend-browser-capability.json", capability);
             return {

package/dist/task/config-types.js

@@ -85,8 +85,8 @@ export const frontendTestConfigSchema = z.object({
     strictOutcomeGate: z.boolean().optional(),
     /**
      * Maximum rerun attempts for blocked or missing-result frontend cases.
-     * Defaults to 2; the static graph always carries a single rerun select+map
-     * pair and bounds candidates within that pair via this value.
+     * Defaults to 1 for the lean off/advisory topology and 2 for the full
+     * reviewMode=blocking topology. An explicit value overrides either default.
      */
     maxRerunAttempts: z.number().int().min(0).max(4).optional(),
     /**

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

@@ -41,7 +41,8 @@ function controllerSummary(operation) {
     const record = identity;
     const fingerprint = typeof record.fingerprint === "string"
         ? record.fingerprint
-        : typeof record.packageFingerprint?.value === "string"
+        : typeof record.packageFingerprint
+            ?.value === "string"
             ? String(record.packageFingerprint.value)
             : undefined;
     const label = [record.packageName, record.packageVersion, fingerprint]
@@ -61,7 +62,12 @@ export function projectOperationForChat(operation) {
     const workerRunId = safeIdentity(params.workerRunId);
     const controller = controllerSummary(operation);
     const previewHash = createHash("sha256")
-        .update(JSON.stringify({ stdoutPreview, stderrPreview, summaryPreview, state: operation.state }))
+        .update(JSON.stringify({
+        stdoutPreview,
+        stderrPreview,
+        summaryPreview,
+        state: operation.state,
+    }))
         .digest("hex");
     return {
         schemaVersion: 1,
@@ -79,25 +85,34 @@ export function projectOperationForChat(operation) {
         ...(stdoutPreview ? { stdoutPreview } : {}),
         ...(stderrPreview ? { stderrPreview } : {}),
         ...(summaryPreview ? { summaryPreview } : {}),
-        ...(operation.errorCode ? { errorCode: safeIdentity(operation.errorCode) } : {}),
+        ...(operation.errorCode
+            ? { errorCode: safeIdentity(operation.errorCode) }
+            : {}),
         previewHash,
     };
 }
 export function projectCompactSnapshot(value) {
-    const record = value && typeof value === "object" ? 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)
+    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;
+    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"),
+        previewHash: createHash("sha256")
+            .update(JSON.stringify({ summary, firstKeptEntryId, tokensBefore, details }))
+            .digest("hex"),
     };
 }
 function boundedRedactedJson(value) {
@@ -145,7 +160,12 @@ export function projectOperationEventSummary(event) {
         ...(messagePreview ? { messagePreview } : {}),
         ...(dataPreview ? { dataPreview } : {}),
         previewHash: createHash("sha256")
-            .update(JSON.stringify({ messagePreview, dataPreview, state: event.state, kind: event.kind }))
+            .update(JSON.stringify({
+            messagePreview,
+            dataPreview,
+            state: event.state,
+            kind: event.kind,
+        }))
             .digest("hex"),
     };
 }
@@ -166,16 +186,17 @@ export function createChatOperationLinker(options) {
             if (event.kind !== "operation-ref")
                 return false;
             const data = event.data;
-            return event.turnId === input.turnId &&
+            return (event.turnId === input.turnId &&
                 data.operationId === input.operationId &&
-                data.toolCallId === input.toolCallId;
+                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";
+        const focused = isTerminalOperationState(operation.state) ||
+            operation.state === "needs-reconcile";
         if (!focused)
             return;
         const projection = projectOperationForChat(operation);
@@ -184,14 +205,16 @@ export function createChatOperationLinker(options) {
             : operation.state === "failed" || operation.state === "timed-out"
                 ? "failed"
                 : "terminal";
-        const duplicate = options.chatEvents.snapshot(input.sessionId).some((event) => {
+        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 &&
+            return (data.operationId === input.operationId &&
                 data.closureKind === closureKind &&
                 data.operation?.state === projection.state &&
-                data.operation?.previewHash === projection.previewHash;
+                data.operation?.previewHash === projection.previewHash);
         });
         if (!duplicate) {
             options.chatEvents.append(input.sessionId, input.turnId, {
@@ -237,7 +260,9 @@ export function createChatOperationLinker(options) {
     return {
         link,
         async recoverSession(sessionId) {
-            const refs = options.chatEvents.snapshot(sessionId).filter((event) => event.kind === "operation-ref");
+            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)
@@ -339,8 +364,14 @@ export function createChatEventStore(options) {
     return {
         forkContextRefs(input) {
             const allowed = new Set([
-                "operation-ref", "operation-status", "draft", "assessment",
-                "taskKind-confirmed", "human-gate-card", "compact", "artifact-ref",
+                "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)) {
@@ -351,7 +382,10 @@ export function createChatEventStore(options) {
                     delete data.humanGateToken;
                     delete data.dagBytesPath;
                 }
-                this.append(input.targetSessionId, input.targetTurnId, { kind: event.kind, data: data });
+                this.append(input.targetSessionId, input.targetTurnId, {
+                    kind: event.kind,
+                    data: data,
+                });
                 copiedCount += 1;
             }
             return { copiedCount };
@@ -402,6 +436,11 @@ export function createChatEventStore(options) {
             const turn = ring.turns.find((candidate) => candidate.state === "queued" || candidate.state === "running");
             return turn ? { ...turn } : undefined;
         },
+        latestTurn(sessionId) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.at(-1);
+            return turn ? { ...turn } : undefined;
+        },
         append(sessionId, turnId, partial) {
             const ring = ringFor(sessionId);
             const seq = ring.nextSeq++;