@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/worker/console/static-src/pages/tasks/run-panel-progress.js

@@ -35,8 +35,25 @@ function toProgressNode(node) {
         startedAt: typeof node.startedAt === "string" ? node.startedAt : undefined,
         durationMs: typeof node.durationMs === "number" ? node.durationMs : undefined,
         errorPreview: typeof node.errorPreview === "string" ? node.errorPreview : undefined,
+        lastMeaningfulProgressAt: typeof node.lastMeaningfulProgressAt === "string"
+            ? node.lastMeaningfulProgressAt
+            : undefined,
+        livenessStatus: typeof node.livenessStatus === "string" ? node.livenessStatus : undefined,
     };
 }
+function latestIso(values) {
+    let latest = null;
+    for (const iso of values) {
+        if (!iso)
+            continue;
+        const time = Date.parse(iso);
+        if (!Number.isFinite(time))
+            continue;
+        if (!latest || time > latest.time)
+            latest = { iso, time };
+    }
+    return latest?.iso ?? null;
+}
 function elapsedSince(iso, now) {
     if (!iso)
         return null;
@@ -58,6 +75,8 @@ export function summarizeRunProgress(dag, now = Date.now()) {
             stalled: false,
             currentNodeElapsedMs: null,
             runElapsedMs: null,
+            lastMeaningfulProgressAt: null,
+            observedAtMs: now,
         };
     }
     const rawNodes = Array.isArray(dag.nodes) ? dag.nodes : [];
@@ -86,6 +105,8 @@ export function summarizeRunProgress(dag, now = Date.now()) {
         runElapsedMs: terminal
             ? (runDurationMs ?? elapsedSince(runStartedAt, now))
             : elapsedSince(runStartedAt, now),
+        lastMeaningfulProgressAt: latestIso(nodes.map((node) => node.lastMeaningfulProgressAt)),
+        observedAtMs: now,
     };
 }
 const TERMINAL_RUN_PROGRESS_STATUSES = new Set([
@@ -108,3 +129,88 @@ export function formatDurationMs(ms) {
         return `${minutes} 分 ${seconds} 秒`;
     return `${seconds} 秒`;
 }
+function friendlyRunPhase(node) {
+    if (!node)
+        return "正在等待下一阶段";
+    const searchable = `${node.nodeId} ${node.label}`.toLowerCase();
+    if (/contract|boundary|intake/.test(searchable))
+        return "正在确认执行边界";
+    if (/scout|explore|research/.test(searchable))
+        return "正在梳理影响范围";
+    if (/plan|design/.test(searchable))
+        return "正在规划实施步骤";
+    if (/implement|repair|fix|write/.test(searchable))
+        return "正在实现本次修改";
+    if (/verify|test|lint|review|check/.test(searchable))
+        return "正在验证本次修改";
+    if (/closeout|handoff|report/.test(searchable))
+        return "正在整理执行结果";
+    if (node.label && node.label !== node.nodeId)
+        return `正在进行${node.label}`;
+    return "正在推进当前阶段";
+}
+function formatMeaningfulAge(iso, now) {
+    if (!iso)
+        return "等待首个执行进展";
+    const time = Date.parse(iso);
+    if (!Number.isFinite(time))
+        return "等待首个执行进展";
+    const seconds = Math.max(0, Math.floor((now - time) / 1000));
+    if (seconds < 60)
+        return `最近进展 ${seconds} 秒前`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `最近进展 ${minutes} 分钟前`;
+    return `最近进展 ${Math.floor(minutes / 60)} 小时前`;
+}
+/** Human-facing copy shared by the task panel and Operator Chat progress row. */
+export function presentRunProgress(summary, now = Date.now()) {
+    if (!summary || !summary.effectiveStatus) {
+        return {
+            kind: "pending",
+            title: "DAG 正在启动",
+            detail: "正在等待首个执行进展",
+        };
+    }
+    const status = summary.effectiveStatus;
+    const liveElapsed = summary.runElapsedMs == null
+        ? null
+        : summary.runElapsedMs +
+            (summary.terminal ? 0 : Math.max(0, now - summary.observedAtMs));
+    const elapsed = formatDurationMs(liveElapsed);
+    const progressDetail = `${friendlyRunPhase(summary.running)} · 已完成 ${summary.finished}/${summary.total} 步 · ${formatMeaningfulAge(summary.lastMeaningfulProgressAt, now)}`;
+    if (status === "running") {
+        return { kind: "progress", title: `DAG 执行中 · 已运行 ${elapsed}`, detail: progressDetail };
+    }
+    if (status === "running-quiet") {
+        return { kind: "quiet", title: `DAG 仍在执行 · 已运行 ${elapsed}`, detail: progressDetail };
+    }
+    if (status === "running-suspected-stall") {
+        return { kind: "warning", title: `执行可能停滞 · 已运行 ${elapsed}`, detail: progressDetail };
+    }
+    if (["needs-attention", "paused", "interrupted"].includes(status)) {
+        return { kind: "warning", title: "DAG 需要处理", detail: progressDetail };
+    }
+    if (status === "finished") {
+        return {
+            kind: "success",
+            title: `DAG 已完成 · 总用时 ${elapsed}`,
+            detail: `已完成 ${summary.finished}/${summary.total} 步 · ${formatMeaningfulAge(summary.lastMeaningfulProgressAt, now)}`,
+        };
+    }
+    if (status === "partial_failed" || status === "failed") {
+        return {
+            kind: "error",
+            title: `DAG 未完成 · 总用时 ${elapsed}`,
+            detail: `已完成 ${summary.finished}/${summary.total} 步 · ${formatMeaningfulAge(summary.lastMeaningfulProgressAt, now)}`,
+        };
+    }
+    if (status === "pending") {
+        return { kind: "pending", title: "DAG 正在启动", detail: progressDetail };
+    }
+    return {
+        kind: "warning",
+        title: `DAG 已结束 · 总用时 ${elapsed}`,
+        detail: `已完成 ${summary.finished}/${summary.total} 步`,
+    };
+}

package/dist/worker/console/static-src/shell/console-update-reload.js

@@ -0,0 +1,25 @@
+/**
+ * Poll /api/health until a (possibly brand-new) Console instance answers,
+ * then reload. A handoff restart kills the old process before the new one
+ * starts listening, so reloading immediately after "restarting" hits a dead
+ * port and reads as "the page is gone".
+ */
+export async function reloadWhenConsoleReady(timeoutMs = 30_000) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        try {
+            const res = await fetch(`/api/health?ts=${Date.now()}`, {
+                cache: "no-store",
+            });
+            if (res.ok) {
+                window.location.reload();
+                return;
+            }
+        }
+        catch {
+            // old process gone, new one not listening yet — keep polling
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    window.location.reload();
+}

package/dist/worker/console/workspace-context.js

@@ -19,10 +19,9 @@
  */
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { rm } from "node:fs/promises";
 import path from "node:path";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
-import { openConsoleAppData, sha256Json, writeSecureJson, } from "./app-data.js";
+import { openConsoleAppData, } from "../../infrastructure/console/app-data.js";
 import { DagConfirmationStore } from "./dag-confirmation.js";
 import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
 import { DraftStore } from "./draft-store.js";
@@ -38,10 +37,10 @@ import { GoalRegistry } from "./chat/goals.js";
 import { GoalRoundDriver } from "./chat/goal-round-driver.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
-import { OperationStore } from "./operation-store.js";
-import { createFrontendSplitOperationAdapter, } from "./frontend-split-operation-adapter.js";
-import { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
-import { FrontendSplitTaskMaterializer, } from "../materialize/frontend-split-task-materializer.js";
+import { OperationStore } from "../../infrastructure/console/operation-store.js";
+import { reconcileContextExports } from "../../infrastructure/console/context-export-store.js";
+import { reconcileArtifactRevisions } from "../../infrastructure/console/artifact-revision-store.js";
+import { recordContextTransferEvent } from "./context-transfer-diagnostics.js";
 import { probePiReadiness, } from "./pi-readiness.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
@@ -77,106 +76,6 @@ export async function createWorkspaceContext(record, deps) {
     const events = createOperationEventStore({
         persistenceDir: path.join(appData.operations, "events"),
     });
-    // Frontend split runtime is repo-scoped: materialization, durable schedule
-    // intents, and aggregate closeout must use this workspace's app-data and
-    // OperationStore rather than the process startup workspace.
-    const splitScheduleDir = path.join(appData.root, "frontend-split-schedule");
-    const splitAuditDir = path.join(appData.root, "frontend-split-audit");
-    const splitAggregateDir = path.join(appData.root, "frontend-split-aggregate");
-    const splitMaterializationBackend = {
-        async ensureTask({ taskId }) {
-            return { taskId, complete: true };
-        },
-        async ensureOperation({ taskId, operationId, payloadDigest, request }) {
-            const action = request.kind === "child"
-                ? "frontendSplitChild"
-                : "frontendSplitIntegration";
-            const { operation } = await operations.ensureSplitMaterializedOperation({
-                operationId,
-                taskId,
-                action,
-                actionParams: request,
-                payloadHash: payloadDigest,
-            });
-            return {
-                taskId: operation.taskId ?? taskId,
-                operationId: operation.operationId,
-                complete: true,
-            };
-        },
-    };
-    const materializer = new FrontendSplitTaskMaterializer(splitMaterializationBackend);
-    const schedule = async (input) => {
-        const fact = {
-            schemaVersion: 1,
-            kind: "frontend-split-schedule-intent",
-            operationId: input.operationId,
-            generation: input.generation,
-            bindingDigest: input.bindingDigest,
-            recordedAt: new Date().toISOString(),
-        };
-        const name = `${sha256Json({
-            operationId: input.operationId,
-            generation: input.generation,
-            bindingDigest: input.bindingDigest,
-        })}.json`;
-        await writeSecureJson(path.join(splitScheduleDir, name), fact);
-    };
-    const auditStale = async (input) => {
-        const fact = {
-            schemaVersion: 1,
-            kind: "frontend-split-stale-audit",
-            operationId: input.operationId,
-            reason: input.reason,
-            fact: input.fact,
-            recordedAt: new Date().toISOString(),
-        };
-        await writeSecureJson(path.join(splitAuditDir, `${sha256Json(fact)}.json`), fact);
-    };
-    const prepareAggregate = async ({ operationId, aggregate, }) => {
-        const before = await operations.get(operationId);
-        if (!before) {
-            throw new Error(`cannot prepare aggregate: parent operation not found: ${operationId}`);
-        }
-        const aggregateFile = path.join(splitAggregateDir, `${aggregate.digest}.json`);
-        let parentRecordPath = "";
-        let wroteAggregate = false;
-        let wroteParent = false;
-        return {
-            committedRef: {
-                ref: aggregateFile,
-                digest: aggregate.digest,
-                commitState: "committed",
-            },
-            async commit(input) {
-                parentRecordPath = input.parentRecordPath;
-                await writeSecureJson(aggregateFile, {
-                    schemaVersion: 1,
-                    kind: "frontend-split-aggregate-closeout",
-                    operationId,
-                    aggregate,
-                });
-                wroteAggregate = true;
-                await writeSecureJson(input.parentRecordPath, input.parentRecord);
-                wroteParent = true;
-            },
-            async rollback() {
-                if (wroteAggregate)
-                    await rm(aggregateFile, { force: true });
-                if (wroteParent && parentRecordPath) {
-                    await writeSecureJson(parentRecordPath, before);
-                }
-            },
-        };
-    };
-    const splitOrchestrator = createFrontendSplitOperationAdapter({
-        store: operations,
-        materializer,
-        schedule,
-        auditStale,
-        prepareAggregate,
-    });
-    const humanDecisionAdapter = createFrontendHumanDecisionAdapter(operations);
     const drafts = new DraftStore(appData);
     const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
     const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
@@ -184,6 +83,29 @@ export async function createWorkspaceContext(record, deps) {
     const assessments = new AssessmentStore(appData);
     if (!deps.skipReconcile) {
         await operations.reconcileOnBoot();
+        const [expiredExports, expiredRevisions] = await Promise.all([
+            reconcileContextExports({ appData }),
+            reconcileArtifactRevisions({ appData }),
+        ]);
+        // Boot-time lifecycle evidence for what reconcile reclaimed. Only
+        // 32-hex ids are real export/revision identities; uploads/ and lock/
+        // entries are blob housekeeping and get no event.
+        await Promise.all([
+            ...expiredExports.removed
+                .filter((exportId) => /^[a-f0-9]{32}$/.test(exportId))
+                .map((exportId) => recordContextTransferEvent({
+                appData,
+                event: "context_export.expired",
+                fields: { exportId },
+            }).catch(() => undefined)),
+            ...expiredRevisions
+                .filter((revisionId) => /^[a-f0-9]{32}$/.test(revisionId))
+                .map((revisionId) => recordContextTransferEvent({
+                appData,
+                event: "artifact_revision.expired",
+                fields: { revisionId },
+            }).catch(() => undefined)),
+        ]);
     }
     const getReadiness = () => readinessCache;
     const refreshReadiness = async () => {
@@ -201,9 +123,6 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
-        splitOrchestrator,
-        humanDecisionAdapter,
-        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,
@@ -299,9 +218,6 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
-        splitOrchestrator,
-        humanDecisionAdapter,
-        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,

package/dist/worker/console/workspace-registry.js

@@ -19,8 +19,8 @@ import { createHash, randomBytes } from "node:crypto";
 import { realpathSync, statSync, unwatchFile, watchFile } from "node:fs";
 import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
-import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
+import { readJsonIfExists, writeSecureJson, } from "../../infrastructure/console/app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "../../infrastructure/console/repo-fingerprint.js";
 export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 3;
 /** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
 export function workspaceIdForRealpath(normalizedRealpath) {

package/dist/worker/continuation/worker-continuation.js

@@ -0,0 +1,278 @@
+import path from "node:path";
+import { deriveWorkerContinuationRunId, workerContinuationAuthorityV1Schema, } from "../../shared/context-transfer.js";
+import { controllerIdentityAnchor } from "../../shared/package-metadata.js";
+import { locateDagRun, readDagRunState, } from "../../workflows/dag/lifecycle.js";
+import { beginWorkerAttemptWithLease } from "../pool/begin-attempt-with-lease.js";
+import { readAttemptLease, releaseAttemptLease, } from "../pool/attempt-lease.js";
+import { readRunOwner } from "../pool/run-owner-store.js";
+import { findRunByWorkerRunId, recordTaskPoolRun, readTaskPoolState, writeTaskPoolState, } from "../pool/run-store.js";
+/**
+ * Resolve a Worker parent into an immutable continuation authority. Standalone
+ * and missing fixture parents return undefined; a detected Worker parent with
+ * incomplete Task Pool ownership fails closed.
+ */
+export async function resolveWorkerContinuationAuthority(input) {
+    const located = await locateDagRun(input.repoRoot, input.parentDagRunId);
+    if (!located)
+        return undefined;
+    const state = await readDagRunState(located.runDir);
+    const association = state.workerAssociation;
+    if (!association)
+        return undefined;
+    if (located.lifecycle !== "completed" || state.status !== "finished") {
+        throw new Error(`WORKER_CONTINUATION_AUTHORITY_MISMATCH: parent DAG is not completed: ${input.parentDagRunId}`);
+    }
+    const expectedChildWorkerRunId = deriveWorkerContinuationRunId(association.workerRunId, input.revisionId);
+    const [owner, parentRun, childRun, poolState, activeLease] = await Promise.all([
+        readRunOwner(input.repoRoot, association.workerRunId),
+        findRunByWorkerRunId(input.repoRoot, association.workerRunId),
+        findRunByWorkerRunId(input.repoRoot, expectedChildWorkerRunId),
+        readTaskPoolState(input.repoRoot, {
+            featureId: association.featureId,
+            taskId: association.taskId,
+        }),
+        readAttemptLease(input.repoRoot, association.featureId, association.taskId),
+    ]);
+    const parentOutcomeReady = poolState?.status === "Done" &&
+        poolState.workerRunId === association.workerRunId;
+    const matchingActiveContinuation = input.allowActiveRevision === true &&
+        poolState?.status === "Running" &&
+        poolState.workerRunId === expectedChildWorkerRunId &&
+        poolState.attemptKind === "artifact-continuation" &&
+        poolState.continuation?.parentWorkerRunId === association.workerRunId &&
+        poolState.continuation.parentDagRunId === input.parentDagRunId &&
+        poolState.continuation.revisionId === input.revisionId &&
+        activeLease?.workerRunId === expectedChildWorkerRunId &&
+        activeLease.revisionId === input.revisionId &&
+        activeLease.claimId === poolState.continuation.operationId;
+    const matchingTerminalContinuation = input.allowActiveRevision === true &&
+        poolState?.status === "Failed" &&
+        poolState.workerRunId === expectedChildWorkerRunId &&
+        poolState.attemptKind === "artifact-continuation" &&
+        poolState.continuation?.parentWorkerRunId === association.workerRunId &&
+        poolState.continuation.parentDagRunId === input.parentDagRunId &&
+        poolState.continuation.revisionId === input.revisionId &&
+        childRun?.status === "failed" &&
+        childRun.attemptKind === "artifact-continuation" &&
+        childRun.continuation?.operationId ===
+            poolState.continuation.operationId &&
+        activeLease === undefined;
+    if (!owner ||
+        !parentRun ||
+        owner.workerRunId !== association.workerRunId ||
+        owner.featureId !== association.featureId ||
+        owner.taskId !== association.taskId ||
+        parentRun.featureId !== association.featureId ||
+        parentRun.taskId !== association.taskId ||
+        parentRun.batchRunId !== owner.batchRunId ||
+        parentRun.status !== "succeeded" ||
+        (!parentOutcomeReady &&
+            !matchingActiveContinuation &&
+            !matchingTerminalContinuation)) {
+        throw new Error(`WORKER_CONTINUATION_AUTHORITY_MISMATCH: parent Worker ownership is incomplete for ${association.workerRunId}`);
+    }
+    const authority = workerContinuationAuthorityV1Schema.parse({
+        schemaVersion: 1,
+        parentWorkerRunId: association.workerRunId,
+        childWorkerRunId: expectedChildWorkerRunId,
+        featureId: association.featureId,
+        taskId: association.taskId,
+        batchRunId: owner.batchRunId,
+        revisionId: input.revisionId,
+    });
+    return { authority, parentDagRunId: input.parentDagRunId };
+}
+export async function beginWorkerContinuation(input) {
+    const { authority } = input.resolved;
+    const priorState = await readTaskPoolState(input.repoRoot, {
+        featureId: authority.featureId,
+        taskId: authority.taskId,
+    });
+    const existingLease = await readAttemptLease(input.repoRoot, authority.featureId, authority.taskId);
+    const freshParentOutcome = priorState?.status === "Done" &&
+        priorState.workerRunId === authority.parentWorkerRunId &&
+        priorState.lastContinuation?.revisionId !== authority.revisionId;
+    const sameCanonicalRunning = priorState?.status === "Running" &&
+        priorState.workerRunId === authority.childWorkerRunId &&
+        priorState.continuation?.operationId === input.operationId &&
+        existingLease?.workerRunId === authority.childWorkerRunId &&
+        existingLease.revisionId === authority.revisionId &&
+        existingLease.claimId === input.operationId;
+    if (!freshParentOutcome && !sameCanonicalRunning) {
+        throw new Error(`state-conflict for ${authority.featureId}/${authority.taskId}: continuation admission is not fresh`);
+    }
+    if (existingLease) {
+        const sameCanonicalOperation = existingLease.workerRunId === authority.childWorkerRunId &&
+            existingLease.revisionId === authority.revisionId &&
+            existingLease.claimId === input.operationId &&
+            priorState?.continuation?.operationId === input.operationId;
+        if (!sameCanonicalOperation) {
+            throw new Error(`attempt-lease-conflict for ${authority.featureId}/${authority.taskId}: held by ${existingLease.workerRunId}`);
+        }
+    }
+    const identity = input.client.getIdentity?.();
+    const lineage = buildLineage(input.resolved, input.operationId);
+    try {
+        await beginWorkerAttemptWithLease({
+            repoRoot: input.repoRoot,
+            featureId: authority.featureId,
+            taskId: authority.taskId,
+            workerRunId: authority.childWorkerRunId,
+            batchRunId: authority.batchRunId,
+            revisionId: authority.revisionId,
+            leaseClaimId: input.operationId,
+            ...(identity
+                ? {
+                    controllerAnchor: controllerIdentityAnchor(identity),
+                    skipProtocolPreflight: true,
+                }
+                : { skipProtocolPreflight: true }),
+            stateExtras: {
+                attemptKind: "artifact-continuation",
+                continuation: lineage,
+            },
+        });
+    }
+    catch (error) {
+        if (!existingLease) {
+            const lease = await readAttemptLease(input.repoRoot, authority.featureId, authority.taskId);
+            const ownsLease = lease?.workerRunId === authority.childWorkerRunId &&
+                lease.revisionId === authority.revisionId &&
+                lease.claimId === input.operationId;
+            if (ownsLease && lease) {
+                await releaseAttemptLease({
+                    repoRoot: input.repoRoot,
+                    featureId: authority.featureId,
+                    taskId: authority.taskId,
+                    token: lease.token,
+                    workerRunId: authority.childWorkerRunId,
+                }).catch(() => undefined);
+            }
+            const current = await readTaskPoolState(input.repoRoot, {
+                featureId: authority.featureId,
+                taskId: authority.taskId,
+            });
+            if (ownsLease &&
+                priorState &&
+                current?.workerRunId === authority.childWorkerRunId &&
+                current.continuation?.operationId === input.operationId) {
+                await writeTaskPoolState(input.repoRoot, priorState);
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Terminal projection is idempotent. needs-reconcile deliberately retains the
+ * Running state and Task lease so recovery cannot be raced by a new attempt.
+ */
+export async function settleWorkerContinuation(input) {
+    if (input.state === "needs-reconcile")
+        return;
+    if (input.state !== "succeeded" &&
+        input.state !== "failed" &&
+        input.state !== "timed-out")
+        return;
+    const { authority } = input.resolved;
+    const lineage = buildLineage(input.resolved, input.operation.operationId);
+    const existing = await findRunByWorkerRunId(input.repoRoot, authority.childWorkerRunId);
+    let terminalRun = existing;
+    if (existing) {
+        assertMatchingTerminalRecord(existing, lineage, authority);
+    }
+    else {
+        const located = await locateDagRun(input.repoRoot, authority.childWorkerRunId);
+        const succeeded = input.state === "succeeded" && input.info.ok;
+        terminalRun = {
+            schemaVersion: 1,
+            batchRunId: authority.batchRunId,
+            workerRunId: authority.childWorkerRunId,
+            taskId: authority.taskId,
+            featureId: authority.featureId,
+            status: succeeded ? "succeeded" : "failed",
+            attemptKind: "artifact-continuation",
+            continuation: lineage,
+            harnessTaskId: authority.childWorkerRunId,
+            ...(located
+                ? { dagPath: path.relative(input.repoRoot, located.runDir).split(path.sep).join("/") }
+                : {}),
+            recordedAt: input.operation.finishedAt ?? new Date().toISOString(),
+            ...(succeeded
+                ? {}
+                : {
+                    error: input.operation.errorMessage ?? input.info.errorCode ?? "artifact continuation failed",
+                    failure: {
+                        category: "Unknown",
+                        recommendedFollowUpKind: "manual-review",
+                        derivedFollowUpTaskId: `${authority.taskId}-continuation-review`,
+                        source: "runner-error",
+                    },
+                }),
+        };
+        await recordTaskPoolRun({
+            repoRoot: input.repoRoot,
+            run: terminalRun,
+        });
+    }
+    if (terminalRun?.status === "succeeded") {
+        const parentRun = await findRunByWorkerRunId(input.repoRoot, authority.parentWorkerRunId);
+        if (!parentRun || parentRun.status !== "succeeded") {
+            throw new Error(`parent Worker outcome is unavailable after continuation: ${authority.parentWorkerRunId}`);
+        }
+        await writeTaskPoolState(input.repoRoot, {
+            schemaVersion: 2,
+            featureId: authority.featureId,
+            taskId: authority.taskId,
+            status: "Done",
+            updatedAt: terminalRun.recordedAt,
+            workerRunId: authority.parentWorkerRunId,
+            ...(parentRun.runRecordPath
+                ? { lastRunRecordPath: parentRun.runRecordPath }
+                : {}),
+            lastContinuation: {
+                ...lineage,
+                status: "succeeded",
+                recordedAt: terminalRun.recordedAt,
+            },
+        });
+    }
+    const lease = await readAttemptLease(input.repoRoot, authority.featureId, authority.taskId);
+    if (!lease)
+        return;
+    if (lease.workerRunId !== authority.childWorkerRunId ||
+        lease.revisionId !== authority.revisionId ||
+        lease.claimId !== input.operation.operationId) {
+        throw new Error(`attempt lease ownership drift for ${authority.featureId}/${authority.taskId}`);
+    }
+    await releaseAttemptLease({
+        repoRoot: input.repoRoot,
+        featureId: authority.featureId,
+        taskId: authority.taskId,
+        token: lease.token,
+        workerRunId: authority.childWorkerRunId,
+    });
+}
+function buildLineage(resolved, operationId) {
+    return {
+        schemaVersion: 1,
+        kind: "artifact-continuation",
+        parentWorkerRunId: resolved.authority.parentWorkerRunId,
+        parentDagRunId: resolved.parentDagRunId,
+        childWorkerRunId: resolved.authority.childWorkerRunId,
+        revisionId: resolved.authority.revisionId,
+        operationId,
+    };
+}
+function assertMatchingTerminalRecord(run, lineage, authority) {
+    if (run.attemptKind !== "artifact-continuation" ||
+        run.featureId !== authority.featureId ||
+        run.taskId !== authority.taskId ||
+        run.batchRunId !== authority.batchRunId ||
+        run.continuation?.parentWorkerRunId !== lineage.parentWorkerRunId ||
+        run.continuation?.parentDagRunId !== lineage.parentDagRunId ||
+        run.continuation?.childWorkerRunId !== lineage.childWorkerRunId ||
+        run.continuation?.revisionId !== lineage.revisionId ||
+        run.continuation?.operationId !== lineage.operationId) {
+        throw new Error(`Worker continuation terminal record conflict: ${authority.childWorkerRunId}`);
+    }
+}

package/dist/worker/observability/read-model.js

@@ -2362,6 +2362,8 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
                 durationMs: readNumber(node, "durationMs"),
                 startedAt: readString(node, "startedAt"),
                 finishedAt: readString(node, "finishedAt"),
+                lastMeaningfulProgressAt: readString(node, "lastMeaningfulProgressAt"),
+                livenessStatus: readString(node, "livenessStatus"),
                 ...(outputPreview ? { outputPreview } : {}),
                 ...(errorPreview ? { errorPreview } : {}),
                 ...(attempts && attempts.length > 0
@@ -2407,6 +2409,8 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
             durationMs: readNumber(node, "durationMs"),
             startedAt: readString(node, "startedAt"),
             finishedAt: readString(node, "finishedAt"),
+            lastMeaningfulProgressAt: readString(node, "lastMeaningfulProgressAt"),
+            livenessStatus: readString(node, "livenessStatus"),
             ...(outputPreview ? { outputPreview } : {}),
             ...(errorPreview ? { errorPreview } : {}),
             ...(attempts && attempts.length > 0

package/dist/worker/observe/health.js

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { findPackageRoot, readPackageName, readPackageVersion, } from "../../shared/package-metadata.js";
-import { repoFingerprintV1 } from "../console/repo-fingerprint.js";
+import { repoFingerprintV1 } from "../../infrastructure/console/repo-fingerprint.js";
 /** Observe `/api/health` schema version (independent of Console product health). */
 export const OBSERVE_HEALTH_SCHEMA_VERSION = 1;
 function routeExists(routes, method, pathname) {