@tea-agent/loop-agent 0.35.4-beta.0 → 0.36.0

package/dist/commands/task-advance.js

@@ -1,5 +1,6 @@
 import { advanceTaskLifecycle, } from "../application/task-lifecycle/index.js";
 import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+import { createRunDagProgressObserver, validateRunDagProgressIntervalMs, } from "./run-dag-progress.js";
 const COMMAND = "task advance";
 const USAGE = `usage:
   task advance <task-id> [title]
@@ -24,6 +25,8 @@ const USAGE = `usage:
     [--dag-output <path>]
     [--skip-finalize]
     [--no-strict-models]
+    [--quiet]
+    [--progress-interval-ms <ms>]
     [--dry-run]
     [--json]`;
 function pushList(target, value) {
@@ -170,6 +173,19 @@ export function parseTaskAdvanceArgs(args) {
             options.strictModels = false;
             continue;
         }
+        if (token === "--quiet") {
+            options.quiet = true;
+            continue;
+        }
+        if (token === "--progress-interval-ms") {
+            const raw = next();
+            const parsed = Number(raw);
+            if (!Number.isFinite(parsed)) {
+                throw new Error(`progress-interval-ms must be an integer >= 1000\n${USAGE}`);
+            }
+            options.progressIntervalMs = validateRunDagProgressIntervalMs(parsed);
+            continue;
+        }
         if (token === "--help" || token === "-h") {
             throw new Error(USAGE);
         }
@@ -208,7 +224,7 @@ function mapOutcome(result) {
         return "blocked";
     return "succeeded";
 }
-function toUseCaseInput(repoRoot, taskId, options) {
+export function toUseCaseInput(repoRoot, taskId, options, observer) {
     const timeouts = new Map((options.verifyTimeout ?? []).map((entry) => {
         const parsed = parseVerifyTimeout(entry);
         return [parsed.label, parsed.timeoutMs];
@@ -271,7 +287,8 @@ function toUseCaseInput(repoRoot, taskId, options) {
         dagOutputPath: options.dagOutputPath,
         skipFinalize: options.skipFinalize,
         strictModels: options.strictModels,
-        onProgress: options.json
+        ...(observer ? { observer } : {}),
+        onProgress: options.quiet
             ? undefined
             : (message) => {
                 process.stderr.write(`[task advance] ${message}\n`);
@@ -296,8 +313,18 @@ export async function runTaskAdvance(repoRoot, args) {
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
         return;
     }
+    let progress;
     try {
-        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options));
+        // AC-006/AC-007: periodic DAG progress goes to stderr only (stdout stays
+        // the single final OperatorCommandResultV1 JSON). The observer is created
+        // ONLY for the approve-gate execution path and disposed on every exit;
+        // its timer starts only after onRunStart (double guard, no stray timer).
+        if (options.approveGate && !options.dryRun && !options.quiet) {
+            progress = createRunDagProgressObserver({
+                intervalMs: options.progressIntervalMs,
+            });
+        }
+        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options, progress?.observer));
         const outcome = mapOutcome(result);
         const gateStop = result.lifecycleState === "awaiting-write-set-approval" &&
             result.blockers.length === 0;
@@ -333,4 +360,7 @@ export async function runTaskAdvance(repoRoot, args) {
         writeOperatorJson(envelope);
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
     }
+    finally {
+        progress?.dispose();
+    }
 }

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

@@ -194,7 +194,7 @@ export function buildDagPiUserMessage(task, persona, step) {
     if (isDagPiWriteTask(task)) {
         const outcomeInstruction = task.writerOutcomePolicy
             ? [
-                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. Use changed only after producing a non-empty bounded diff; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed.",
+                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. The runner measures your diff mechanically from git status snapshots taken before and after this node: code pasted into the response text is NOT an implementation and yields an empty diff. Use changed only after actually calling write/edit tools that persist files to disk; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed. Claiming changed without a persisted diff fails this node as invalid-output.",
                 task.writerOutcomePolicy.requireChangedFiles
                     ? "This generation node requires a non-empty bounded diff; already-satisfied cannot complete it successfully."
                     : undefined,
@@ -206,6 +206,8 @@ export function buildDagPiUserMessage(task, persona, step) {
             `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
             "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
             "Use write tools only for the bounded implementation requested by this node.",
+            "The upstream plan node's output is a BLUEPRINT, not a deliverable: reading it never satisfies this node. You MUST materialize the plan into actual working-tree changes by calling write/edit tools before claiming changed. A detailed plan that names every file, test, or snippet still requires you to write those files yourself.",
+            "Forbidden paths bound the writeSet, not the task: when the task only requires writing inside the writeSet (e.g. adding tests that call existing public APIs), a forbidden src/** does not make the task impossible — do NOT claim blocked merely because some path you never need to write is forbidden. blocked is only for when you genuinely cannot produce the required writeSet changes.",
             outcomeInstruction,
             `Allowed paths: ${(task.allowedPaths ?? []).join(", ") || "(none declared)"}.`,
             `Write set: ${(task.writeSet ?? []).join(", ") || "(none declared)"}.`,

package/dist/shared/operator/capabilities.js

@@ -13,6 +13,13 @@ const CONTROLLER_PROTOCOL_CAPABILITIES = [
     "worker-attempt-revision-v1",
     "recovery-decision-v2",
 ];
+function officialModelCallable(coverage, kind) {
+    if (coverage === "human-gated-required")
+        return "prepare-only";
+    if (coverage === "advanced" && kind !== "read")
+        return "never";
+    return "always";
+}
 const officialAction = (action, cli, kind, coverage) => ({
     action,
     cli,
@@ -51,11 +58,7 @@ const officialAction = (action, cli, kind, coverage) => ({
             ]
             : []),
     ],
-    modelCallable: coverage === "human-gated-required"
-        ? "prepare-only"
-        : coverage === "advanced" && kind !== "read"
-            ? "never"
-            : "always",
+    modelCallable: officialModelCallable(coverage, kind),
     humanConfirmation: coverage === "human-gated-required" ? "required" : "none",
 });
 const OFFICIAL_ACTIONS = [
@@ -142,13 +145,13 @@ const OFFICIAL_ACTIONS = [
         ["stats", "loop-agent stats", "read", "model-callable"],
         [
             "promoteRun",
-            "loop-agent task advance <id> --json",
+            "loop-agent task advance",
             "mutation",
             "model-callable",
         ],
         [
             "closeoutTask",
-            "loop-agent task advance <id> --json",
+            "loop-agent task advance",
             "mutation",
             "model-callable",
         ],
@@ -445,6 +448,49 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "operationWait",
+            cli: "console canonical operation wait (read-only event-driven long poll)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            resultPolicy: { readOnly: true, bounded: true, redacted: true },
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "NOT_FOUND",
+                "INVALID_INPUT",
+                "EVENT_CURSOR_EXPIRED",
+            ],
+            description: "Read-only event-driven wait on the canonical operation event ring. Default wakeOn=meaningful: heartbeats never settle the wait and are never returned as event payload (nextSeq still covers them); state/result/stdout/stderr/reconcile/error settle immediately; terminal or needs-reconcile flushes immediately. Every subsequent wait MUST pass afterSeq equal to the previous response nextSeq; omitting or reusing an older cursor replays already-consumed startup events. The response includes recommendedNextCall with the safe cursor. wakeOn=all (diagnostic compatibility) resolves on the first new event including heartbeats. maxWaitMs elapsing returns timedOut:true (a success summary, not a command failure).",
+            inputParams: [
+                {
+                    name: "operationId",
+                    type: "string",
+                    required: true,
+                    description: "canonical operation id",
+                },
+                {
+                    name: "afterSeq",
+                    type: "number",
+                    required: false,
+                    description: "event cursor; first wait may use 0, every later wait MUST use the previous response nextSeq (>= 0)",
+                },
+                {
+                    name: "maxWaitMs",
+                    type: "number",
+                    required: false,
+                    description: "bounded wait budget; clamped server-side (default 180000, floor 60000)",
+                },
+                {
+                    name: "wakeOn",
+                    type: "string",
+                    required: false,
+                    description: "wake policy: meaningful (default; heartbeats are cursor-only liveness) | all (first event settles, diagnostics)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
         {
             action: "contractShow",
             cli: "loop-agent task status <taskId> --json",
@@ -896,6 +942,74 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "taskAdvance",
+            cli: "loop-agent task advance <taskId> [title] --task-kind <kind> --allowed-path <glob> --forbidden-path <glob> --verify <label:command> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+            ],
+            description: "Canonical typed task advance mutation. Use after task creation/PRD import to apply explicit taskKind and engineering boundaries, generate + strict-validate the DAG, and stop at the writeSet gate. Never pass placeholder ids such as <id>. A successful child process may still return a blocked business outcome; inspect lifecycleState, blockers, gate, and next.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "canonical YYYY-MM-DD-<slug> task id; placeholders are rejected",
+                },
+                {
+                    name: "title",
+                    type: "string",
+                    required: false,
+                    description: "optional task title for create/first advance",
+                },
+                {
+                    name: "taskKind",
+                    type: "string",
+                    required: false,
+                    description: "business DAG template; ordinary fixes/docs use standard",
+                },
+                {
+                    name: "featureId",
+                    type: "string",
+                    required: false,
+                    description: "required only by feature-scoped task kinds such as knowledge-sync",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "governance profile auto|minimal|standard|reviewed|supervised",
+                },
+                {
+                    name: "allowedPaths",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "explicit writer boundary globs",
+                },
+                {
+                    name: "forbiddenPaths",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "explicit forbidden path globs",
+                },
+                {
+                    name: "verifyCommands",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "verification entries as label:command strings",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
         {
             action: "dagRunTask",
             cli: "loop-agent task advance <taskId> --profile auto --dag-output <path> --json",
@@ -965,7 +1079,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor.",
+            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor/operationWait.",
             inputParams: [
                 {
                     name: "executionId",
@@ -988,7 +1102,7 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Read-only R1 subgraph plan (no mutation). Call before dagRerun. Prefer primaryFailure.nodeId from dagReport. If eligible=false (writer/decision/fingerprint), do not force execute — fall back to standaloneTaskRerun or same-task advance. Returns planHash required by execute.",
+            description: "Read-only R1 subgraph plan (no mutation). Call before dagRerun. Prefer primaryFailure.nodeId from dagReport. If eligible=false (writer/decision/fingerprint, or subgraph contains unsafe shell nodes), do not force execute — fall back to standaloneTaskRerun or same-task advance after fixing the root cause (contract changes must be adopted first). Returns planHash required by execute.",
             inputParams: [
                 {
                     name: "runId",
@@ -1317,7 +1431,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Full standalone task regenerate → validate → execute with parent lineage. Only when node rerun plan is ineligible or primaryRecovery recommends rerun-task; the server checks read-only run facts before accepting.",
+            description: "Full standalone task regenerate → validate → execute with parent lineage. Only when node rerun plan is ineligible or primaryRecovery recommends rerun-task; the server checks read-only run facts before accepting. Regeneration reuses the CURRENT contract snapshot: if the failure requires contract changes (e.g. allowing a catalog index path), first update the contract (re-import PRD, or adopt externally-edited sources via `task contract adopt`) BEFORE calling this action, otherwise the regenerated DAG repeats the same failure.",
             inputParams: [
                 {
                     name: "runId",
@@ -1438,7 +1552,7 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     {
         command: "loop-agent task advance",
         coverage: "model-callable",
-        action: "newTask",
+        action: "taskAdvance",
         source: "loop-agent",
     },
     {

package/dist/task/source-prepare/completeness.js

@@ -2,6 +2,13 @@ const FRESH_SOURCE_MISSING_CODES = new Set([
     "MISSING_REQUIREMENT",
     "MISSING_CONSTRAINTS",
 ]);
+function hasKnowledgeSyncFeatureSurface(featureId, allowedPaths) {
+    const featureRoot = `features/${featureId}/`;
+    return allowedPaths.some((pathGlob) => {
+        const normalized = pathGlob.replaceAll("\\", "/").replace(/^\.\//, "");
+        return normalized === `features/${featureId}` || normalized.startsWith(featureRoot);
+    });
+}
 export function isFreshLegacyUnversioned(state, sourceFilesPresent) {
     if (state.effectiveStatus !== "legacy-unversioned")
         return false;
@@ -105,6 +112,16 @@ export function listPrepareGaps(input) {
             message: "featureId is required when taskKind is knowledge-sync",
         });
     }
+    if (draft.taskKind === "knowledge-sync" &&
+        draft.featureId &&
+        !hasKnowledgeSyncFeatureSurface(draft.featureId, draft.constraints.allowedPaths)) {
+        gaps.push({
+            code: "KNOWLEDGE_SYNC_PATH_MISMATCH",
+            level: "blocking",
+            field: "allowedPaths",
+            message: `knowledge-sync for ${draft.featureId} requires an allowed path under features/${draft.featureId}/; ordinary docs-only work should use taskKind standard`,
+        });
+    }
     if (draft.requirement.scope.length === 0) {
         gaps.push({
             code: "EMPTY_SCOPE",

package/dist/task/source-prepare/parse-intent.js

@@ -15,7 +15,21 @@ const HEADING_ALIASES = {
         "已确认需求",
     ]),
     nonGoals: new Set(["非目标", "out of scope", "non-goals", "non goals"]),
-    acceptance: new Set(["验收标准", "acceptance criteria", "acceptance"]),
+    acceptance: new Set([
+        "验收标准",
+        "acceptance criteria",
+        "acceptance",
+        // Common zh-CN product-writing variants seen in real PRDs; without
+        // these a PRD re-import flips to deterministic parse and loses all AC
+        // (EMPTY_ACCEPTANCE deadlock on the pendingPrdRefresh path).
+        "完成定义",
+        "完成标准",
+        "验收",
+        "验收条件",
+        "验收准则",
+        "dod",
+        "definition of done",
+    ]),
     constraints: new Set(["约束", "constraints", "不变式", "invariants"]),
     openQuestions: new Set(["待决问题", "open questions", "open-questions"]),
     assumptions: new Set(["假设", "assumptions"]),

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

@@ -19,5 +19,12 @@ 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);
+    return current.map((item, candidate) => candidate === index
+        ? {
+            ...item,
+            ...incoming,
+            eventSeq: item.eventSeq ?? incoming.eventSeq,
+            activityRef: item.activityRef ?? incoming.activityRef,
+        }
+        : item);
 }

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

@@ -50,6 +50,62 @@ function controllerSummary(operation) {
         .join("@");
     return safeIdentity(label);
 }
+/** Re-project an already-safe stored run summary through a bounded re-check. */
+function safeRunSummaryProjection(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const runId = safeIdentity(record.runId);
+    const status = safeIdentity(record.status);
+    if (!runId || !status)
+        return undefined;
+    const nodes = Array.isArray(record.nodes)
+        ? record.nodes
+            .filter((node) => Boolean(node && typeof node === "object"))
+            .map((node) => ({
+            id: safeIdentity(node.id) ?? "",
+            status: safeIdentity(node.status) ?? "",
+        }))
+            .filter((node) => node.id && node.status)
+            .slice(0, 20)
+        : [];
+    const verdict = typeof record.verdict === "string"
+        ? boundedRedactedText(record.verdict)
+        : undefined;
+    const failureCategory = typeof record.failureCategory === "string"
+        ? boundedRedactedText(record.failureCategory)
+        : undefined;
+    const outOfBounds = Array.isArray(record.outOfBounds)
+        ? record.outOfBounds
+            .filter((entry) => Boolean(entry && typeof entry === "object"))
+            .map((entry) => ({
+            nodeId: safeIdentity(entry.nodeId) ?? "",
+            failureCategory: safeIdentity(entry.failureCategory) ?? "",
+        }))
+            .filter((entry) => entry.nodeId && entry.failureCategory)
+            .slice(0, 20)
+        : undefined;
+    const nextRec = record.next && typeof record.next === "object"
+        ? record.next
+        : undefined;
+    const next = nextRec
+        ? {
+            kind: safeIdentity(nextRec.kind) ?? "",
+            description: typeof nextRec.description === "string"
+                ? boundedRedactedText(nextRec.description)
+                : undefined,
+        }
+        : undefined;
+    return {
+        runId,
+        status,
+        nodes,
+        ...(verdict ? { verdict } : {}),
+        ...(failureCategory ? { failureCategory } : {}),
+        ...(outOfBounds && outOfBounds.length > 0 ? { outOfBounds } : {}),
+        ...(next && next.kind ? { next } : {}),
+    };
+}
 /** Chat/browser-safe projection. Never includes actionParams, CLI args, paths or raw results. */
 export function projectOperationForChat(operation) {
     const params = operation.actionParams ?? {};
@@ -61,12 +117,16 @@ export function projectOperationForChat(operation) {
     const featureId = safeIdentity(params.featureId);
     const workerRunId = safeIdentity(params.workerRunId);
     const controller = controllerSummary(operation);
+    const runSummary = safeRunSummaryProjection(operation.runSummary);
     const previewHash = createHash("sha256")
         .update(JSON.stringify({
         stdoutPreview,
         stderrPreview,
         summaryPreview,
         state: operation.state,
+        // runSummary participates in the dedupe hash: terminal summary updates
+        // must not be swallowed by state+previewHash dedup (2026-08-14).
+        runSummary: runSummary ?? null,
     }))
         .digest("hex");
     return {
@@ -88,6 +148,7 @@ export function projectOperationForChat(operation) {
         ...(operation.errorCode
             ? { errorCode: safeIdentity(operation.errorCode) }
             : {}),
+        ...(runSummary ? { runSummary } : {}),
         previewHash,
     };
 }

package/dist/worker/console/chat/human-gate-card.js

@@ -32,6 +32,14 @@ export function mergeHumanGateCardState(cards, next) {
     if (index < 0)
         return [...cards, next];
     const copy = [...cards];
-    copy[index] = next;
+    const current = copy[index];
+    if (!current)
+        return [...cards, next];
+    copy[index] = {
+        ...current,
+        ...next,
+        eventSeq: current.eventSeq ?? next.eventSeq,
+        activityRef: current.activityRef ?? next.activityRef,
+    };
     return copy;
 }

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

@@ -2,7 +2,24 @@ export function mergeOperationCardState(current, incoming) {
     const index = current.findIndex((operation) => operation.operationId === incoming.operationId);
     if (index < 0)
         return [...current, incoming];
-    return current.map((operation, candidateIndex) => candidateIndex === index ? { ...operation, ...incoming } : operation);
+    return current.map((operation, candidateIndex) => {
+        if (candidateIndex !== index)
+            return operation;
+        let eventSeq = operation.eventSeq;
+        if (eventSeq === undefined)
+            eventSeq = incoming.eventSeq;
+        else if (incoming.eventSeq !== undefined) {
+            eventSeq = Math.min(eventSeq, incoming.eventSeq);
+        }
+        return {
+            ...operation,
+            ...incoming,
+            ...(eventSeq === undefined ? {} : { eventSeq }),
+            updatedSeq: Math.max(operation.updatedSeq ?? operation.eventSeq ?? 0, incoming.updatedSeq ?? incoming.eventSeq ?? 0),
+            toolCallId: operation.toolCallId ?? incoming.toolCallId,
+            activityRef: operation.activityRef ?? incoming.activityRef,
+        };
+    });
 }
 export function operationFromEventPayload(payload) {
     const operation = payload.operation;
@@ -19,5 +36,57 @@ export function operationFromEventPayload(payload) {
         typeof candidate.previewHash !== "string") {
         return undefined;
     }
-    return candidate;
+    // Optional runSummary stays backward-compatible: validate shape field by
+    // field and drop it entirely when malformed (legacy events simply lack it).
+    const safe = safeRunSummary(candidate.runSummary);
+    const { runSummary: _unsafeRunSummary, ...base } = candidate;
+    return {
+        ...base,
+        ...(safe ? { runSummary: safe } : {}),
+    };
+}
+/** Field-by-field validation for the optional browser-side runSummary. */
+function safeRunSummary(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const rec = value;
+    if (typeof rec.runId !== "string" || !rec.runId)
+        return undefined;
+    if (typeof rec.status !== "string" || !rec.status)
+        return undefined;
+    let nodes = [];
+    if (Array.isArray(rec.nodes)) {
+        nodes = rec.nodes
+            .flatMap((node) => {
+            if (!node || typeof node !== "object")
+                return [];
+            const id = String(node.id ?? "");
+            const status = String(node.status ?? "");
+            if (!id || !status)
+                return [];
+            return [{ id, status }];
+        })
+            .slice(0, 20);
+    }
+    let next;
+    if (rec.next && typeof rec.next === "object") {
+        const nextRecord = rec.next;
+        next = {
+            kind: String(nextRecord.kind ?? ""),
+            ...(typeof nextRecord.description === "string"
+                ? { description: nextRecord.description }
+                : {}),
+        };
+    }
+    const out = {
+        runId: rec.runId,
+        status: rec.status,
+        nodes,
+        ...(typeof rec.verdict === "string" ? { verdict: rec.verdict } : {}),
+        ...(typeof rec.failureCategory === "string"
+            ? { failureCategory: rec.failureCategory }
+            : {}),
+        ...(next && next.kind ? { next } : {}),
+    };
+    return out;
 }