@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

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/materialize/frontend-split-task-materializer.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { computeFrontendSplitDigest } from "../../workflows/dag/frontend-split-orchestrator.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+const pathSchema = z.string().trim().min(1);
+export const frontendSplitTaskMaterializationRequestSchema = z.object({
+    kind: z.enum(["child", "integration"]),
+    parentOperationId: idSchema,
+    manifestDigest: digestSchema,
+    generation: positiveIntegerSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+    payloadDigest: digestSchema,
+    allowedPaths: z.array(pathSchema),
+    writeSet: z.array(pathSchema),
+    verifyRefs: z.array(idSchema),
+}).strict();
+export const frontendSplitTaskMaterializationResultSchema = z.object({
+    idempotencyKey: digestSchema,
+    requestDigest: digestSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+}).strict();
+function identityPayload(request) {
+    return { kind: request.kind, parentOperationId: request.parentOperationId, manifestDigest: request.manifestDigest, generation: request.generation, taskId: request.taskId, operationId: request.operationId };
+}
+export class FrontendSplitTaskMaterializer {
+    backend;
+    completed = new Map();
+    inFlight = new Map();
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async materialize(raw) {
+        const request = frontendSplitTaskMaterializationRequestSchema.parse(raw);
+        const idempotencyKey = computeFrontendSplitDigest(identityPayload(request));
+        const requestDigest = computeFrontendSplitDigest(request);
+        const existing = this.completed.get(idempotencyKey);
+        if (existing) {
+            if (existing.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return existing;
+        }
+        const pending = this.inFlight.get(idempotencyKey);
+        if (pending) {
+            const result = await pending;
+            if (result.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return result;
+        }
+        const promise = this.perform(request, idempotencyKey, requestDigest);
+        this.inFlight.set(idempotencyKey, promise);
+        try {
+            const result = await promise;
+            this.completed.set(idempotencyKey, result);
+            return result;
+        }
+        finally {
+            this.inFlight.delete(idempotencyKey);
+        }
+    }
+    async perform(request, idempotencyKey, requestDigest) {
+        const task = await this.backend.ensureTask({ idempotencyKey, taskId: request.taskId, payloadDigest: requestDigest, request });
+        if (!task.complete || task.taskId !== request.taskId)
+            throw new Error("frontend split task materialization incomplete or drifted");
+        const operation = await this.backend.ensureOperation({ idempotencyKey, taskId: request.taskId, operationId: request.operationId, payloadDigest: requestDigest, request });
+        if (!operation.complete || operation.taskId !== request.taskId || operation.operationId !== request.operationId)
+            throw new Error("frontend split operation materialization incomplete or drifted");
+        return frontendSplitTaskMaterializationResultSchema.parse({ idempotencyKey, requestDigest, taskId: request.taskId, operationId: request.operationId });
+    }
+}

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) {