@tea-agent/loop-agent 0.10.0 → 0.12.0

package/dist/worker/runner/run-ready.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
+import { controllerIdentitiesMatch, controllerIdentityExpectationFailure, resolveControllerIdentity, } from "../loop-agent/loop-agent-client.js";
 import { deriveFailureRoute, deriveFailureRouteFromError, } from "../pool/failure-routing.js";
 import { findRunByWorkerRunId, getTaskPoolRoot, readAllTaskPoolStates, recordTaskPoolRun, writeTaskPoolState, } from "../pool/run-store.js";
 import { runTaskSpec, } from "../run-task/run-task.js";
@@ -9,7 +10,26 @@ import { formatDuration, noopProgressReporter, } from "../progress-reporter.js";
 import { computeReadyQueue } from "../task-graph/ready-queue.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
 import { taskSpecSchema } from "../task-spec/schema.js";
+import { preflightTargetRepo } from "../preflight.js";
 export async function runReadyTasks(options) {
+    let controllerIdentity = resolveControllerIdentity(options.client, options.controllerIdentity);
+    const identityFailure = controllerIdentityExpectationFailure(controllerIdentity, options.controllerExpectation);
+    if (identityFailure) {
+        throw new Error(`${identityFailure.code}: ${identityFailure.message}`);
+    }
+    if (!options.skipTaskPreflight && !options.runTask) {
+        const preflight = await preflightTargetRepo({
+            repoRoot: options.repoRoot,
+            client: options.client,
+            runCheckRepo: options.runCheckRepo,
+            ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
+            ...(options.controllerExpectation ? { expectation: options.controllerExpectation } : {}),
+        });
+        if (!preflight.ok) {
+            throw new Error(`target repo preflight failed: ${preflight.code}: ${preflight.message}`);
+        }
+        controllerIdentity = preflight.controllerIdentity ?? controllerIdentity;
+    }
     const now = options.now ?? new Date();
     const startedAt = now.toISOString();
     const batchRunId = options.batchRunId ?? buildBatchRunId(now);
@@ -43,12 +63,19 @@ export async function runReadyTasks(options) {
         const taskSpecPath = path.join(options.featureDir, "tasks", node?.task ?? `${taskId}.yaml`);
         const taskSpec = await loadTaskSpec(taskSpecPath);
         const retryOfWorkerRunId = states[taskId]?.retryOfWorkerRunId;
-        const workerRunId = retryOfWorkerRunId
+        let workerRunId = retryOfWorkerRunId
             ? buildRetryWorkerRunId(taskId, retryOfWorkerRunId, now)
             : options.workerRunIdForTask?.(taskId, taskSpec) ??
-                buildStableWorkerRunId(taskId, taskSpec, now);
+                buildStableWorkerRunId(taskId, taskSpec, now, controllerIdentity);
         if (workerRunId) {
-            const existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
+            let existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
+            if (existing && !controllerRunCanBeReused(existing, controllerIdentity)) {
+                workerRunId = buildControllerScopedWorkerRunId(workerRunId, controllerIdentity);
+                existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
+                if (existing && !controllerRunCanBeReused(existing, controllerIdentity)) {
+                    throw new Error(`workerRunId collision has incompatible controller identity: ${workerRunId}`);
+                }
+            }
             if (existing) {
                 progress.task(`task ${index}/${total} ${taskId}: reuse existing run ${workerRunId}`);
                 emit(progress, {
@@ -81,7 +108,7 @@ export async function runReadyTasks(options) {
             workerRunId,
             status: "running",
         });
-        progress.step(`preflight → materialize → dag-run-task → validate → run-dag → report`);
+        progress.step(`materialize → dag-run-task → validate → run-dag → report`);
         let result;
         try {
             await writeTaskPoolState(options.repoRoot, {
@@ -107,14 +134,11 @@ export async function runReadyTasks(options) {
                 client: options.client,
                 now,
                 workerRunId,
-                preflight: options.skipTaskPreflight
-                    ? false
-                    : {
-                        runCheckRepo: options.runCheckRepo,
-                        ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
-                    },
+                preflight: false,
                 progress,
                 ...(options.piModel ? { piModel: options.piModel } : {}),
+                ...(controllerIdentity ? { controllerIdentity } : {}),
+                ...(options.controllerExpectation ? { controllerExpectation: options.controllerExpectation } : {}),
             });
         }
         catch (error) {
@@ -146,6 +170,7 @@ export async function runReadyTasks(options) {
                         error: message,
                         failure,
                         ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
+                        ...(controllerIdentity ? { controllerIdentity } : {}),
                     },
                 });
                 recorded = true;
@@ -214,6 +239,7 @@ export async function runReadyTasks(options) {
             ...(failure ? { failure } : {}),
             ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
+            ...(controllerIdentity ? { controllerIdentity } : {}),
         };
         let recorded = false;
         try {
@@ -251,6 +277,7 @@ export async function runReadyTasks(options) {
         summary,
         tasks,
         batchRunPath,
+        ...(controllerIdentity ? { controllerIdentity } : {}),
     };
     await mkdir(path.dirname(batchRunPath), { recursive: true });
     await writeFile(batchRunPath, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
@@ -274,18 +301,55 @@ function emit(progress, input) {
 export function buildBatchRunId(now) {
     return `batch-${now.toISOString().replace(/[-:.]/g, "").slice(0, 15)}`;
 }
-export function buildStableWorkerRunId(taskId, taskSpec, now) {
+export function buildStableWorkerRunId(taskId, taskSpec, now, controllerIdentity) {
     const date = now.toISOString().slice(0, 10).replace(/-/g, "");
     const slug = taskId
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
     const hash = createHash("sha256")
-        .update(`${taskSpec.feature_id}:${taskSpec.id}:${taskSpec.title}`)
+        .update([
+        taskSpec.feature_id,
+        taskSpec.id,
+        taskSpec.title,
+        ...(controllerIdentity
+            ? [
+                controllerIdentity.packageName,
+                controllerIdentity.packageVersion,
+                controllerIdentity.binarySha256,
+                controllerIdentity.packageFingerprint.value,
+            ]
+            : []),
+    ].join(":"))
         .digest("hex")
         .slice(0, 10);
     return `wr-${date}-${slug}-${hash}`;
 }
+function buildControllerScopedWorkerRunId(baseWorkerRunId, controllerIdentity) {
+    const hash = createHash("sha256")
+        .update(controllerIdentity
+        ? JSON.stringify({
+            packageName: controllerIdentity.packageName,
+            binName: controllerIdentity.binName,
+            packageVersion: controllerIdentity.packageVersion,
+            binarySha256: controllerIdentity.binarySha256,
+            packageFingerprint: controllerIdentity.packageFingerprint.value,
+            requested: controllerIdentity.requested,
+            entry: controllerIdentity.entry,
+            realEntry: controllerIdentity.realEntry,
+            launch: controllerIdentity.launch,
+            packageRoot: controllerIdentity.packageRoot,
+        })
+        : "legacy-unpinned-controller")
+        .digest("hex")
+        .slice(0, 10);
+    return `${baseWorkerRunId}-controller-${hash}`;
+}
+function controllerRunCanBeReused(existing, controllerIdentity) {
+    if (!existing.controllerIdentity && !controllerIdentity)
+        return true;
+    return controllerIdentitiesMatch(existing.controllerIdentity, controllerIdentity);
+}
 /** A retry is a distinct execution attempt and must not collide with failed evidence. */
 export function buildRetryWorkerRunId(taskId, previousWorkerRunId, now) {
     const date = now.toISOString().slice(0, 10).replace(/-/g, "");

package/dist/worker/task-spec/schema.js

@@ -97,7 +97,6 @@ export const taskSpecSchema = z
         profile_policy: z.literal("mapped"),
         strict_models: z.boolean().optional().default(true),
         strict_governance: z.boolean().optional().default(true),
-        no_cursor: z.boolean().optional().default(false),
         max_concurrent: z.number().int().positive().optional().default(1),
     })
         .strict(),

package/dist/workflows/dag/controller-identity.js

@@ -0,0 +1,104 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { controllerIdentitiesMatch, resolveRunningControllerIdentity, } from "../../shared/package-metadata.js";
+export const CONTROLLER_IDENTITY_ARTIFACT_NAME = "controller-identity.json";
+function hashArtifact(artifact) {
+    return createHash("sha256")
+        .update(`${JSON.stringify(artifact, null, 2)}\n`)
+        .digest("hex");
+}
+function summaryFields(identity) {
+    if (!identity)
+        return {};
+    return {
+        packageName: identity.packageName,
+        packageVersion: identity.packageVersion,
+        packageFingerprint: identity.packageFingerprint.value,
+        binarySha256: identity.binarySha256,
+    };
+}
+/**
+ * Capture the running controller identity as a run-owned fact and persist it
+ * under `runDir/controller-identity.json`. Returns the ref (with content hash)
+ * to store on DagRunState. When the identity cannot be resolved, records a
+ * `legacy-unpinned` artifact instead of fabricating an identity.
+ */
+export async function captureControllerIdentity(input) {
+    const capturedAt = (input.now ?? new Date()).toISOString();
+    const identity = input.identity !== undefined
+        ? input.identity
+        : (resolveRunningControllerIdentity({
+            ...(input.argv ? { argv: input.argv } : {}),
+            ...(input.now ? { now: input.now } : {}),
+        }) ?? null);
+    const artifact = identity
+        ? { schemaVersion: 1, status: "pinned", capturedAt, identity }
+        : {
+            schemaVersion: 1,
+            status: "legacy-unpinned",
+            capturedAt,
+            identity: null,
+            reason: "running controller identity could not be resolved at run creation",
+        };
+    await writeJsonAtomic(path.join(input.runDir, CONTROLLER_IDENTITY_ARTIFACT_NAME), artifact);
+    return {
+        schemaVersion: 1,
+        path: CONTROLLER_IDENTITY_ARTIFACT_NAME,
+        sha256: hashArtifact(artifact),
+        capturedAt,
+        status: artifact.status,
+        ...summaryFields(identity),
+    };
+}
+export async function readControllerIdentityArtifact(runDir) {
+    try {
+        const raw = await readFile(path.join(runDir, CONTROLLER_IDENTITY_ARTIFACT_NAME), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function shortIdentity(identity) {
+    return `${identity.packageName}@${identity.packageVersion} (fingerprint ${identity.packageFingerprint.value}, binary ${identity.binarySha256.slice(0, 12)})`;
+}
+/**
+ * Recompute the current controller identity and compare it to the pinned run
+ * fact before resuming. Fails closed on drift; reports (without inventing an
+ * identity). Legacy/unpinned runs remain readable but cannot be resumed.
+ */
+export async function verifyControllerIdentityForResume(input) {
+    const ref = input.state.controllerIdentityRef;
+    if (!ref || ref.status === "legacy-unpinned") {
+        throw new Error(`dag run ${input.state.runId} has no pinned controller identity; legacy/unpinned runs remain readable but cannot be resumed safely`);
+    }
+    const artifact = await readControllerIdentityArtifact(input.runDir);
+    if (!artifact) {
+        throw new Error(`dag run ${input.state.runId} is pinned but ${CONTROLLER_IDENTITY_ARTIFACT_NAME} is missing; refuse to resume`);
+    }
+    const persistedHash = createHash("sha256")
+        .update(`${JSON.stringify(artifact, null, 2)}\n`)
+        .digest("hex");
+    if (persistedHash !== ref.sha256) {
+        throw new Error(`dag run ${input.state.runId} controller identity artifact was tampered with (hash mismatch); refuse to resume`);
+    }
+    const pinned = artifact.identity;
+    if (!pinned) {
+        throw new Error(`dag run ${input.state.runId} is pinned but the identity artifact has no identity payload; refuse to resume`);
+    }
+    const current = input.currentIdentity !== undefined
+        ? input.currentIdentity
+        : (resolveRunningControllerIdentity({
+            ...(input.argv ? { argv: input.argv } : {}),
+            ...(input.now ? { now: input.now } : {}),
+        }) ?? null);
+    if (!current) {
+        throw new Error(`dag run ${input.state.runId} was pinned to ${shortIdentity(pinned)} but the current controller identity could not be resolved; refuse to resume`);
+    }
+    if (!controllerIdentitiesMatch(pinned, current)) {
+        throw new Error(`dag run ${input.state.runId} controller identity drifted; pinned=${shortIdentity(pinned)} current=${shortIdentity(current)}; start a new run instead of resuming`);
+    }
+    return { status: "pinned-match", identity: current };
+}

package/dist/workflows/dag/convergence/controller.js

@@ -5,7 +5,7 @@ import { freshNodeRecord } from "../dynamic-runtime/shared.js";
 const CONVERGENCE_CHAIN_NODE_IDS = [
     "process-supervisor-pi",
     "process-gate-shell",
-    "repair-cursor",
+    "repair-pi",
     "hard-verify-shell",
 ];
 const CONVERGENCE_NON_RETRY_FAILURES = new Set([

package/dist/workflows/dag/executor-registry.js

@@ -1,4 +1,3 @@
-import { executeDagCursorNode } from "../../executors/dag-cursor-executor.js";
 import { executeDagPiNode } from "../../executors/dag-pi-executor.js";
 import { executeDagShellNode } from "../../executors/shell-executor.js";
 import { executeDagStaticNode } from "../../executors/dag-static-executor.js";
@@ -9,7 +8,6 @@ function requireModel(input) {
     return input;
 }
 export const DEFAULT_DAG_EXECUTOR_REGISTRY = {
-    cursor: (input, meta) => executeDagCursorNode(requireModel(input), meta),
     pi: (input, meta) => executeDagPiNode(requireModel(input), meta),
     shell: executeDagShellNode,
     static: executeDagStaticNode,