@tea-agent/loop-agent 0.10.0 → 0.11.0

package/dist/worker/feature/run.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { realpath } from "node:fs/promises";
+import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "../loop-agent/loop-agent-client.js";
 import { buildGlobalSnapshot } from "../observability/read-model.js";
 import { createSnapshotStore } from "../observability/snapshot-store.js";
 import { preflightTargetRepo } from "../preflight.js";
@@ -29,6 +30,37 @@ export async function runFeature(options) {
     let gitTransaction;
     const gitTasks = [];
     const expectedArtifacts = expectedArtifactPaths(repoRoot, batchRunId);
+    let controllerIdentity;
+    try {
+        controllerIdentity = resolveControllerIdentity(options.client, options.controllerIdentity);
+    }
+    catch (error) {
+        return failedResult({
+            featureId,
+            mode: options.dryRun ? "dry-run" : "executed",
+            steps: [{ id: "preflight", status: "failed", durationMs: 0, message: errorMessage(error) }],
+            limitApplied,
+            code: "controller-identity-client-mismatch",
+            message: errorMessage(error),
+            evidence: [],
+            expectedArtifacts,
+            controllerIdentity: options.controllerIdentity,
+        });
+    }
+    const identityFailure = controllerIdentityExpectationFailure(controllerIdentity, options.controllerExpectation);
+    if (identityFailure) {
+        return failedResult({
+            featureId,
+            mode: options.dryRun ? "dry-run" : "executed",
+            steps: [{ id: "preflight", status: "failed", durationMs: 0, message: identityFailure.message }],
+            limitApplied,
+            code: identityFailure.code,
+            message: identityFailure.message,
+            evidence: [],
+            expectedArtifacts,
+            controllerIdentity,
+        });
+    }
     progress.step("feature validate");
     const validation = await timedStep(steps, "validate", async () => dependencies.validateFeature(featureDir));
     if (!validation.value?.ok) {
@@ -44,6 +76,7 @@ export async function runFeature(options) {
             evidence: errors.flatMap((error) => error.path ? [error.path] : []),
             nextCommand: `agent-worker task validate-feature ${JSON.stringify(featureDir)}`,
             expectedArtifacts,
+            controllerIdentity,
         });
     }
     featureId = validation.value.featureId;
@@ -56,11 +89,14 @@ export async function runFeature(options) {
             client: options.client,
             runCheckRepo: options.runCheckRepo,
             ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
+            ...(options.controllerExpectation ? { expectation: options.controllerExpectation } : {}),
         }));
         if (!preflight.value?.ok) {
             markLastStepFailed(steps, preflight.value && !preflight.value.ok ? preflight.value.message : preflight.error ?? "target repo preflight failed");
-            return preflightFailure({ featureId, repoRoot, steps, limitApplied, preflight: preflight.value, fallbackMessage: preflight.error, expectedArtifacts });
+            return preflightFailure({ featureId, repoRoot, steps, limitApplied, preflight: preflight.value, fallbackMessage: preflight.error, expectedArtifacts,
+                controllerIdentity: preflight.value?.controllerIdentity ?? controllerIdentity });
         }
+        controllerIdentity = preflight.value.controllerIdentity ?? controllerIdentity;
         steps.at(-1).artifacts = preflight.value.commands.map((command) => command.result.artifacts.resultPath);
     }
     if (checkpointMode) {
@@ -68,7 +104,8 @@ export async function runFeature(options) {
         const canonicalFeature = await realpath(featureDir).catch(() => featureDir);
         const featureRelative = path.relative(canonicalRepo, canonicalFeature);
         if (featureRelative.startsWith("..") || path.isAbsolute(featureRelative)) {
-            return failedResult({ featureId, mode: options.dryRun ? "dry-run" : "executed", steps, limitApplied, code: "git-feature-repo-mismatch", message: "Feature Packet must be inside the Git target repo for checkpoint mode", evidence: [featureDir, repoRoot], expectedArtifacts });
+            return failedResult({ featureId, mode: options.dryRun ? "dry-run" : "executed", steps, limitApplied, code: "git-feature-repo-mismatch", message: "Feature Packet must be inside the Git target repo for checkpoint mode", evidence: [featureDir, repoRoot], expectedArtifacts,
+                controllerIdentity });
         }
         if (options.dryRun) {
             steps.push(planned("git-preflight", `create or reuse agent/${featureId.toLowerCase()} and checkpoint each task`));
@@ -76,14 +113,16 @@ export async function runFeature(options) {
         else {
             const gitStep = await timedStep(steps, "git-preflight", async () => dependencies.startGit({ repoRoot, featureId, now }));
             if (!gitStep.value)
-                return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "git-preflight-failed", message: gitStep.error ?? "Git transaction preflight failed", evidence: [], expectedArtifacts });
+                return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "git-preflight-failed", message: gitStep.error ?? "Git transaction preflight failed", evidence: [], expectedArtifacts,
+                    controllerIdentity });
             gitTransaction = gitStep.value;
             steps.at(-1).artifacts = [gitTransaction.recordPath];
         }
     }
     const beforeStep = await timedStep(steps, "review-before", async () => dependencies.review({ featureDir, repoRoot }));
     if (!beforeStep.value) {
-        return failedResult({ featureId, mode: options.dryRun ? "dry-run" : "executed", steps, limitApplied, code: "feature-review-failed", message: beforeStep.error ?? "Feature review failed", evidence: [], expectedArtifacts });
+        return failedResult({ featureId, mode: options.dryRun ? "dry-run" : "executed", steps, limitApplied, code: "feature-review-failed", message: beforeStep.error ?? "Feature review failed", evidence: [], expectedArtifacts,
+            controllerIdentity });
     }
     before = beforeStep.value;
     const readyTasks = before.tasks.filter((task) => task.status === "Ready").map((task) => task.taskId);
@@ -108,6 +147,7 @@ export async function runFeature(options) {
             batch: null,
             gitTasks,
             limitApplied,
+            controllerIdentity,
         };
     }
     if (readyTasks.length > 0 && limitApplied > 0) {
@@ -122,6 +162,8 @@ export async function runFeature(options) {
             progress,
             skipTaskPreflight: true,
             ...(options.piModel ? { piModel: options.piModel } : {}),
+            ...(controllerIdentity ? { controllerIdentity } : {}),
+            ...(options.controllerExpectation ? { controllerExpectation: options.controllerExpectation } : {}),
             ...(gitTransaction ? { onTaskFinalized: async (task) => {
                     const gitResult = await dependencies.finalizeGit(gitTransaction, { ...task, keepFailedDiff: options.keepFailedDiff, now });
                     gitTasks.push(gitResult);
@@ -132,7 +174,8 @@ export async function runFeature(options) {
         batch = runStep.value;
         if (!batch) {
             const kept = runStep.error?.startsWith("git-keep-failed-diff:") ?? false;
-            const failed = failedResult({ featureId, mode: "executed", steps, limitApplied, code: kept ? "git-failed-diff-kept" : "run-ready-failed", message: kept ? "Failed task diff was kept by explicit request; automatic execution stopped" : runStep.error ?? "run-ready failed", evidence: kept ? [runStep.error.slice("git-keep-failed-diff:".length)] : [], before, readyTasks, expectedArtifacts });
+            const failed = failedResult({ featureId, mode: "executed", steps, limitApplied, code: kept ? "git-failed-diff-kept" : "run-ready-failed", message: kept ? "Failed task diff was kept by explicit request; automatic execution stopped" : runStep.error ?? "run-ready failed", evidence: kept ? [runStep.error.slice("git-keep-failed-diff:".length)] : [], before, readyTasks, expectedArtifacts,
+                controllerIdentity });
             return kept ? { ...failed, status: "needs-action", gitTasks, artifacts: { ...failed.artifacts, gitTransaction: gitTransaction?.recordPath ?? null } } : failed;
         }
         steps.at(-1).artifacts = [batch.batchRunPath];
@@ -147,7 +190,8 @@ export async function runFeature(options) {
     progress.step("refresh morning report");
     const report = await timedStep(steps, "morning-report", async () => dependencies.writeReport({ repoRoot, ...(batch ? { batchRunId: batch.batchRunId } : {}), outputPath: morningReportPath }));
     if (!report.value)
-        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "morning-report-failed", message: report.error ?? "morning report failed", evidence: [], before, readyTasks, batch, expectedArtifacts });
+        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "morning-report-failed", message: report.error ?? "morning report failed", evidence: [], before, readyTasks, batch, expectedArtifacts,
+            controllerIdentity });
     steps.at(-1).artifacts = [report.value];
     const snapshotPath = path.join(getTaskPoolRoot(repoRoot), "observability", "snapshot.json");
     progress.step("refresh Observe snapshot");
@@ -157,12 +201,14 @@ export async function runFeature(options) {
         return snapshotPath;
     });
     if (!snapshot.value)
-        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "observe-snapshot-failed", message: snapshot.error ?? "Observe snapshot failed", evidence: [report.value], before, readyTasks, batch, artifacts: { morningReport: report.value }, expectedArtifacts });
+        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "observe-snapshot-failed", message: snapshot.error ?? "Observe snapshot failed", evidence: [report.value], before, readyTasks, batch, artifacts: { morningReport: report.value }, expectedArtifacts,
+            controllerIdentity });
     steps.at(-1).artifacts = [snapshot.value];
     progress.step("derive final Feature review");
     const after = await timedStep(steps, "review-after", async () => dependencies.review({ featureDir, repoRoot }));
     if (!after.value)
-        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "feature-review-failed", message: after.error ?? "final Feature review failed", evidence: [report.value, snapshot.value], before, readyTasks, batch, artifacts: { morningReport: report.value, observeSnapshot: snapshot.value }, expectedArtifacts });
+        return failedResult({ featureId, mode: "executed", steps, limitApplied, code: "feature-review-failed", message: after.error ?? "final Feature review failed", evidence: [report.value, snapshot.value], before, readyTasks, batch, artifacts: { morningReport: report.value, observeSnapshot: snapshot.value }, expectedArtifacts,
+            controllerIdentity });
     const taskFailures = batch?.tasks.filter((task) => task.status === "failed") ?? [];
     const runInfrastructureFailed = batch?.status === "failed";
     const executionError = runInfrastructureFailed
@@ -190,6 +236,7 @@ export async function runFeature(options) {
         gitTasks,
         ...(executionError ? { error: executionError } : {}),
         limitApplied,
+        controllerIdentity,
     };
 }
 export function renderFeatureRun(result) {
@@ -271,6 +318,7 @@ function failedResult(input) {
         batch: input.batch ?? null,
         error: { code: input.code, message: input.message, evidence: input.evidence, ...(input.nextCommand ? { nextCommand: input.nextCommand } : {}) },
         limitApplied: input.limitApplied,
+        controllerIdentity: input.controllerIdentity,
     };
 }
 function expectedArtifactPaths(repoRoot, batchRunId) {
@@ -309,5 +357,9 @@ function preflightFailure(input) {
         evidence: failed?.commands.flatMap((command) => [command.result.artifacts.resultPath]) ?? [],
         nextCommand: `cd ${JSON.stringify(input.repoRoot)} && loop-agent doctor`,
         expectedArtifacts: input.expectedArtifacts,
+        controllerIdentity: failed?.controllerIdentity ?? input.controllerIdentity,
     });
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}