@tea-agent/loop-agent 0.8.0 → 0.10.0-alpha.0

package/dist/worker/pool/run-store.js

@@ -1,4 +1,5 @@
-import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 export const TASK_POOL_RELATIVE_ROOT = ".harness/task-pool";
 export function getTaskPoolRoot(repoRoot) {
@@ -19,6 +20,10 @@ export async function recordTaskPoolRun(input) {
     await writeTaskPoolState(input.repoRoot, stateFromRun(input.run));
     await appendJsonlFile(getEventsJsonlPath(input.repoRoot), eventFromRun(input.run));
 }
+export async function appendTaskPoolEvent(repoRoot, event) {
+    await ensurePoolDirs(repoRoot);
+    await appendJsonlFile(getEventsJsonlPath(repoRoot), event);
+}
 export async function findRunByWorkerRunId(repoRoot, workerRunId) {
     const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     return runs.find((run) => run.workerRunId === workerRunId);
@@ -99,7 +104,14 @@ export async function readAllTaskPoolStates(repoRoot) {
 export async function writeTaskPoolState(repoRoot, state) {
     const statePath = getTaskStatePath(repoRoot, state.taskId);
     await mkdir(path.dirname(statePath), { recursive: true });
-    await writeFile(statePath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(tempPath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+        await rename(tempPath, statePath);
+    }
+    finally {
+        await unlink(tempPath).catch(() => { });
+    }
 }
 export async function readJsonlFile(filePath) {
     try {

package/dist/worker/pool/validation.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { getRunsJsonlPath, getTaskPoolRoot } from "./run-store.js";
+export const taskPoolRunFactSchema = z.object({
+    schemaVersion: z.literal(1), batchRunId: z.string().min(1), workerRunId: z.string().min(1), taskId: z.string().min(1), featureId: z.string().min(1),
+    status: z.enum(["succeeded", "failed", "run-error"]), recordedAt: z.string().datetime(),
+}).passthrough();
+export const taskPoolStateFactSchema = z.object({
+    taskId: z.string().min(1), status: z.enum(["Draft", "Ready", "Queued", "Running", "AgentCompleted", "VerificationRunning", "HumanReview", "Done", "Failed", "Blocked", "Abandoned"]), updatedAt: z.string().datetime(),
+}).passthrough();
+export async function readValidTaskPoolRuns(repoRoot) {
+    const records = [];
+    const warnings = [];
+    try {
+        const raw = await readFile(getRunsJsonlPath(repoRoot), "utf-8");
+        for (const [index, line] of raw.split(/\r?\n/).filter(Boolean).entries())
+            try {
+                const parsed = taskPoolRunFactSchema.safeParse(JSON.parse(line));
+                if (parsed.success)
+                    records.push(parsed.data);
+                else
+                    warnings.push(`Task Pool runs.jsonl line ${index + 1} is semantically invalid`);
+            }
+            catch {
+                warnings.push(`Task Pool runs.jsonl line ${index + 1} is corrupt`);
+            }
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            warnings.push("Task Pool runs.jsonl is unreadable");
+    }
+    return { records, warnings };
+}
+export async function readValidTaskPoolStates(repoRoot) {
+    const records = {};
+    const warnings = [];
+    const stateDir = path.join(getTaskPoolRoot(repoRoot), "states");
+    try {
+        for (const entry of await readdir(stateDir))
+            if (entry.endsWith(".json"))
+                try {
+                    const parsed = taskPoolStateFactSchema.safeParse(JSON.parse(await readFile(path.join(stateDir, entry), "utf-8")));
+                    if (parsed.success && parsed.data.taskId === entry.slice(0, -5))
+                        records[parsed.data.taskId] = parsed.data;
+                    else
+                        warnings.push(`Task Pool state is semantically invalid: ${entry}`);
+                }
+                catch {
+                    warnings.push(`Task Pool state is corrupt: ${entry}`);
+                }
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            warnings.push("Task Pool states are unreadable");
+    }
+    return { records, warnings };
+}
+function isNotFound(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT"); }

package/dist/worker/preflight.js

@@ -1,14 +1,27 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
+import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "./loop-agent/loop-agent-client.js";
 export const DEFAULT_CHECK_REPO_TIMEOUT_MS = 300_000;
 export async function preflightTargetRepo(input) {
     const commands = [];
+    const identity = resolveControllerIdentity(input.client);
+    const expectationFailure = controllerIdentityExpectationFailure(identity, input.expectation);
+    if (expectationFailure) {
+        return {
+            ok: false,
+            code: expectationFailure.code,
+            message: expectationFailure.message,
+            commands,
+            controllerIdentity: identity,
+        };
+    }
     if (!(await exists(path.join(input.repoRoot, "harness.json")))) {
         return {
             ok: false,
             code: "target-not-initialized",
             message: "target repo is missing harness.json",
             commands,
+            controllerIdentity: identity,
         };
     }
     if (!(await exists(path.join(input.repoRoot, ".harness")))) {
@@ -17,6 +30,7 @@ export async function preflightTargetRepo(input) {
             code: "target-not-initialized",
             message: "target repo is missing .harness",
             commands,
+            controllerIdentity: identity,
         };
     }
     const version = await input.client.run(["--version"], {
@@ -30,8 +44,36 @@ export async function preflightTargetRepo(input) {
             code: "version-failed",
             message: "loop-agent --version failed",
             commands,
+            controllerIdentity: identity,
         };
     }
+    const reportedVersion = version.stdout.trim();
+    let controllerIdentity = identity
+        ? { ...identity, reportedVersion }
+        : undefined;
+    if (identity && reportedVersion !== identity.packageVersion) {
+        return {
+            ok: false,
+            code: "reported-version-mismatch",
+            message: `reported version ${reportedVersion} does not match package version ${identity.packageVersion}`,
+            commands,
+            controllerIdentity,
+        };
+    }
+    if (identity && input.client.observeReportedVersion) {
+        try {
+            controllerIdentity = input.client.observeReportedVersion(reportedVersion) ?? controllerIdentity;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: "reported-version-mismatch",
+                message: error instanceof Error ? error.message : String(error),
+                commands,
+                controllerIdentity,
+            };
+        }
+    }
     const inspect = await input.client.run(["inspect"], {
         cwd: input.repoRoot,
         artifactName: "inspect",
@@ -44,6 +86,7 @@ export async function preflightTargetRepo(input) {
             code: "inspect-failed",
             message: "loop-agent inspect failed or did not return JSON",
             commands,
+            controllerIdentity,
         };
     }
     const docsAudit = await input.client.run(["docs", "audit"], {
@@ -57,6 +100,7 @@ export async function preflightTargetRepo(input) {
             code: "docs-audit-failed",
             message: "loop-agent docs audit failed",
             commands,
+            controllerIdentity,
         };
     }
     const gitStatus = await input.client.runExternal("git", ["status", "--short", "--branch"], {
@@ -70,6 +114,7 @@ export async function preflightTargetRepo(input) {
             code: "git-status-failed",
             message: "git status --short --branch failed",
             commands,
+            controllerIdentity,
         };
     }
     if (input.runCheckRepo) {
@@ -86,15 +131,18 @@ export async function preflightTargetRepo(input) {
                 code: "check-repo-failed",
                 message: `${[command, ...args].join(" ")} failed`,
                 commands,
+                controllerIdentity,
             };
         }
     }
     return {
         ok: true,
-        version: version.stdout.trim(),
+        version: reportedVersion,
+        reportedVersion: controllerIdentity?.reportedVersion,
         inspect: inspect.json,
         gitStatus: gitStatus.stdout,
         commands,
+        controllerIdentity,
     };
 }
 async function exists(filePath) {

package/dist/worker/report/morning-report.js

@@ -1,17 +1,30 @@
-import { access, writeFile, mkdir } from "node:fs/promises";
+import { access, writeFile, mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { getRunsJsonlPath, readAllTaskPoolStates, readJsonlFile, } from "../pool/run-store.js";
+import YAML from "yaml";
+import { followUpActionCardSchema } from "../follow-up/schema.js";
+import { readFollowUpIndex, resolveRepoFile } from "../follow-up/store.js";
+import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
+import { readValidTaskPoolRuns, readValidTaskPoolStates } from "../pool/validation.js";
 export async function renderMorningReport(options) {
-    const runs = (await readJsonlFile(getRunsJsonlPath(options.repoRoot))).filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
+    const { features } = await loadFeatureDecisionModels(options.repoRoot);
+    const allRuns = (await readValidTaskPoolRuns(options.repoRoot)).records;
+    const runs = allRuns.filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
     const total = runs.length;
     const succeeded = runs.filter((run) => run.status === "succeeded").length;
     const failed = runs.filter((run) => run.status === "failed").length;
     const followUps = runs.filter((run) => run.failure).length;
-    const states = await readAllTaskPoolStates(options.repoRoot);
+    const states = (await readValidTaskPoolStates(options.repoRoot)).records;
     const blocked = Object.values(states).filter((state) => state.status === "Blocked").length;
     const lines = [
         "# Nightly Worker Report",
         "",
+        "## Feature Decision Summary",
+        "",
+        ...(features.length === 0 ? ["- Status: no Feature Packet discovered", "- Next Action: add or locate a Feature Packet", "- Why: no shared Feature read model is available", "- Evidence: none"] : features.flatMap((feature) => {
+            const why = feature.blockingItems[0]?.message ?? `${feature.summary.tasksSucceeded}/${feature.summary.tasksTotal} tasks; ${feature.summary.requiredAcCovered}/${feature.summary.requiredAcTotal} required AC`;
+            const evidence = [feature.evidence.delivery, feature.evidence.closeout, feature.evidence.morningReport, feature.evidence.observeSnapshot, ...feature.blockingItems.flatMap((item) => item.evidence)].find(Boolean) ?? "none";
+            return [`### ${feature.featureId}`, "", `- Status: ${feature.status}`, `- Next Action: ${feature.nextAction?.command ?? feature.nextAction?.label ?? "none"}`, `- Why: ${why}`, `- Evidence: ${evidence}`, ""];
+        })),
         "## Summary",
         "",
         `- Total: ${total}`,
@@ -26,16 +39,38 @@ export async function renderMorningReport(options) {
         "|---|---|---|---|---|---|",
     ];
     for (const run of runs) {
-        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
+        const followUp = await followUpSummary(run, options.repoRoot);
+        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${followUp ?? run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
     }
     if (followUps > 0) {
         lines.push("", "## Human Actions", "");
         for (const run of runs.filter((candidate) => candidate.failure)) {
-            lines.push(`- ${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`);
+            const followUp = await followUpSummary(run, options.repoRoot);
+            lines.push(`- ${followUp ?? `${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`}`);
         }
     }
     return `${lines.join("\n")}\n`;
 }
+async function followUpSummary(run, repoRoot) {
+    if (!run.failure)
+        return undefined;
+    try {
+        const index = await readFollowUpIndex(repoRoot, run.featureId);
+        const entry = index.entries.find((candidate) => candidate.workerRunId === run.workerRunId && candidate.status !== "Superseded" && candidate.status !== "Rejected");
+        if (!entry)
+            return undefined;
+        if (entry.kind === "TaskDraft") {
+            return entry.status === "Approved"
+                ? `${entry.followUpId}: approved as ${entry.proposedTaskId}`
+                : `${entry.followUpId}: approve ${entry.proposedTaskId}`;
+        }
+        const card = followUpActionCardSchema.parse(YAML.parse(await readFile(await resolveRepoFile(repoRoot, entry.draftPath), "utf-8")));
+        return `${entry.followUpId}: ${card.command ?? card.label}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function writeMorningReport(input) {
     const markdown = await renderMorningReport(input);
     await mkdir(path.dirname(input.outputPath), { recursive: true });

package/dist/worker/run-task/run-task.js

@@ -3,12 +3,18 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
 import { redactForPreview, truncatePreview } from "../observability/events.js";
+import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "../loop-agent/loop-agent-client.js";
 import { materializeTaskSpec, } from "../materialize/harness-task-materializer.js";
 import { preflightTargetRepo } from "../preflight.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
 export const DEFAULT_RUN_DAG_TIMEOUT_MS = 1_800_000;
 export const MAX_WORKER_TIMEOUT_MS = 7_200_000;
 export async function runTaskSpec(options) {
+    let controllerIdentity = resolveControllerIdentity(options.client, options.controllerIdentity);
+    const identityFailure = controllerIdentityExpectationFailure(controllerIdentity, options.controllerExpectation);
+    if (identityFailure) {
+        throw new Error(`${identityFailure.code}: ${identityFailure.message}`);
+    }
     const now = options.now ?? new Date();
     const workerRunId = options.workerRunId ?? buildWorkerRunId(options.taskSpec.id, now);
     const commands = [];
@@ -26,11 +32,13 @@ export async function runTaskSpec(options) {
                 repoRoot: options.repoRoot,
                 client,
                 ...(typeof options.preflight === "object" ? options.preflight : {}),
+                ...(options.controllerExpectation ? { expectation: options.controllerExpectation } : {}),
             });
             if (!preflight.ok) {
                 progress.note(`preflight FAILED: ${preflight.code}`);
                 throw new Error(`target repo preflight failed: ${preflight.code}: ${preflight.message}`);
             }
+            controllerIdentity = preflight.controllerIdentity ?? controllerIdentity;
         });
         progress.step(`preflight ok in ${formatDuration(Date.now() - preflightStartedAt)}`);
     }
@@ -66,7 +74,6 @@ export async function runTaskSpec(options) {
             dagPath,
             "--cwd",
             options.repoRoot,
-            ...noCursorArgs(options.taskSpec),
         ], true, undefined, eventCtx);
     });
     progress.step(`dag generated in ${formatDuration(Date.now() - dagGenStartedAt)}`);
@@ -90,7 +97,6 @@ export async function runTaskSpec(options) {
             "--strict-governance",
             "--spine-task",
             materializeManifest.harnessTaskId,
-            ...forbidCursorArgs(options.taskSpec),
         ], true, undefined, eventCtx);
     });
     progress.step(`dag validated in ${formatDuration(Date.now() - validateStartedAt)}`);
@@ -111,7 +117,6 @@ export async function runTaskSpec(options) {
             "--events-jsonl",
             dagEventsPath,
             ...maxConcurrentArgs(options.taskSpec),
-            ...noCursorArgs(options.taskSpec),
         ], resolveRunDagTimeoutMs(options.taskSpec), eventCtx);
     });
     progress.step(`run-dag finished in ${formatDuration(Date.now() - runDagStartedAt)}`);
@@ -156,7 +161,7 @@ export async function runTaskSpec(options) {
             taskArtifactsDir,
             eventCtx,
         });
-    if (reportDecision.succeeded) {
+    if (reportDecision.succeeded && !options.skipSuccessFinalization) {
         await runObservedStep(eventCtx, "promote-run", async () => {
             progress.step("promote run");
             await runRequiredCommand(options.repoRoot, client, "promote-run", ["promote-run", materializeManifest.harnessTaskId, "--run-id", workerRunId], true, undefined, eventCtx);
@@ -180,6 +185,7 @@ export async function runTaskSpec(options) {
         reportDecision,
         commands,
         ...(failureArtifacts ? { failureArtifacts } : {}),
+        ...(controllerIdentity ? { controllerIdentity } : {}),
     };
     await writeFile(runRecordPath, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
     emit(progress, {
@@ -407,6 +413,12 @@ class RecordingRunTaskClient {
         this.delegate = delegate;
         this.records = records;
     }
+    getIdentity() {
+        return this.delegate.getIdentity?.();
+    }
+    observeReportedVersion(reportedVersion) {
+        return this.delegate.observeReportedVersion?.(reportedVersion);
+    }
     async run(args, options) {
         const result = await this.delegate.run(args, options);
         this.records.push({
@@ -452,6 +464,12 @@ class ObservedRunTaskClient {
         this.delegate = delegate;
         this.eventCtx = eventCtx;
     }
+    getIdentity() {
+        return this.delegate.getIdentity();
+    }
+    observeReportedVersion(reportedVersion) {
+        return this.delegate.observeReportedVersion(reportedVersion);
+    }
     run(args, options) {
         return this.runObserved(args, options, (observedOptions) => this.delegate.run(args, observedOptions));
     }
@@ -544,12 +562,6 @@ function commandRecordName(args, artifactName) {
         return "new-task";
     return artifactName;
 }
-function noCursorArgs(taskSpec) {
-    return taskSpec.loop_agent.no_cursor ? ["--no-cursor"] : [];
-}
-function forbidCursorArgs(taskSpec) {
-    return taskSpec.loop_agent.no_cursor ? ["--forbid-executor", "cursor"] : [];
-}
 function maxConcurrentArgs(taskSpec) {
     return ["--max-concurrent", String(taskSpec.loop_agent.max_concurrent)];
 }
@@ -563,14 +575,12 @@ function strictModelsArgs(piModel) {
 }
 /**
  * Rewrite `executorModels.pi.{LOW,MED,HIGH}` in an already-generated DAG JSON
- * so every pi executor node resolves to the smoke override model. Cursor / shell
- * slots are left untouched.
+ * so every pi executor node resolves to the smoke override model.
  */
 export async function applyPiModelOverride(dagPath, piModel) {
     const raw = await readFile(dagPath, "utf-8");
     const spec = JSON.parse(raw);
     spec.executorModels = {
-        ...(spec.executorModels?.cursor ? { cursor: spec.executorModels.cursor } : {}),
         pi: {
             LOW: piModel,
             MED: piModel,

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, {
@@ -66,6 +93,7 @@ export async function runReadyTasks(options) {
                     status: "reused",
                     runRecordPath: existing.runRecordPath,
                 });
+                await options.onTaskFinalized?.({ status: "reused", taskSpec, workerRunId, ...(existing.runRecordPath ? { runRecordPath: existing.runRecordPath } : {}) });
                 continue;
             }
         }
@@ -80,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, {
@@ -106,12 +134,11 @@ export async function runReadyTasks(options) {
                 client: options.client,
                 now,
                 workerRunId,
-                preflight: {
-                    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) {
@@ -128,6 +155,7 @@ export async function runReadyTasks(options) {
                 status: "failed",
                 message,
             });
+            let recorded = false;
             try {
                 await recordTaskPoolRun({
                     repoRoot: options.repoRoot,
@@ -142,18 +170,23 @@ export async function runReadyTasks(options) {
                         error: message,
                         failure,
                         ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
+                        ...(controllerIdentity ? { controllerIdentity } : {}),
                     },
                 });
+                recorded = true;
             }
             catch (recordError) {
+                await options.onTaskFinalized?.({ status: "run-error", taskSpec, workerRunId });
                 tasks.push({
                     taskId,
                     workerRunId,
                     status: "record-error",
                     error: errorMessage(recordError),
                 });
-                continue;
+                break;
             }
+            if (recorded)
+                await options.onTaskFinalized?.({ status: "run-error", taskSpec, workerRunId });
             tasks.push({
                 taskId,
                 workerRunId,
@@ -206,9 +239,12 @@ export async function runReadyTasks(options) {
             ...(failure ? { failure } : {}),
             ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
+            ...(controllerIdentity ? { controllerIdentity } : {}),
         };
+        let recorded = false;
         try {
             await recordTaskPoolRun({ repoRoot: options.repoRoot, run });
+            recorded = true;
             tasks.push({
                 taskId,
                 workerRunId: result.workerRunId,
@@ -217,6 +253,7 @@ export async function runReadyTasks(options) {
             });
         }
         catch (error) {
+            await options.onTaskFinalized?.({ status: result.status, taskSpec, workerRunId: result.workerRunId, runRecordPath: result.runRecordPath });
             tasks.push({
                 taskId,
                 workerRunId: result.workerRunId,
@@ -224,7 +261,10 @@ export async function runReadyTasks(options) {
                 error: errorMessage(error),
                 runRecordPath: result.runRecordPath,
             });
+            break;
         }
+        if (recorded)
+            await options.onTaskFinalized?.({ status: result.status, taskSpec, workerRunId: result.workerRunId, runRecordPath: result.runRecordPath });
     }
     const summary = summarize(tasks);
     const batchRunPath = path.join(getTaskPoolRoot(options.repoRoot), "artifacts", batchRunId, "batch-run.json");
@@ -237,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");
@@ -260,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/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,