@tea-agent/loop-agent 0.10.0 → 0.12.0

package/dist/worker/delivery/package.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import YAML from "yaml";
 import { z } from "zod";
+import { controllerIdentitiesMatch, LOOP_AGENT_PACKAGE_NAME, } from "../loop-agent/loop-agent-client.js";
 import { getRunsJsonlPath, getTaskPoolRoot, readAllTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
 import { acceptanceSpecSchema } from "../task-graph/acceptance-schema.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
@@ -34,10 +35,50 @@ export const deliveryManifestSchema = z.object({
     riskSummary: z.object({ high: z.number().int().nonnegative(), medium: z.number().int().nonnegative(), low: z.number().int().nonnegative() }).strict(),
 }).strict();
 const waiverSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), items: z.array(z.object({ acId: z.string(), owner: z.string().min(1), reason: z.string().min(1), decidedAt: z.string().datetime() }).strict()) }).strict();
-const evidenceRunSchema = z.object({ taskId: z.string(), workerRunId: z.string(), recordedAt: z.string().datetime() }).strict();
+const controllerIdentityEvidenceSchema = z.object({
+    schemaVersion: z.literal(1),
+    packageName: z.literal(LOOP_AGENT_PACKAGE_NAME),
+    binName: z.string().min(1),
+    requested: z.string().min(1),
+    entry: z.string().min(1),
+    realEntry: z.string().min(1),
+    launch: z.object({ command: z.string().min(1), argsPrefix: z.array(z.string()) }).strict(),
+    binarySha256: z.string().regex(/^[a-f0-9]{64}$/),
+    packageRoot: z.string().min(1),
+    packageVersion: z.string().min(1),
+    reportedVersion: z.string().min(1).optional(),
+    packageFingerprint: z.object({
+        algorithm: z.literal("sha256"),
+        scopeVersion: z.literal(1),
+        scope: z.tuple([
+            z.literal("package.json"),
+            z.literal("bin/**"),
+            z.literal("dist/**"),
+            z.literal("skills/**"),
+        ]),
+        value: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+        fileCount: z.number().int().positive(),
+    }).strict(),
+    resolvedAt: z.string().datetime(),
+}).strict().superRefine((identity, ctx) => {
+    if (identity.reportedVersion !== undefined
+        && identity.reportedVersion !== identity.packageVersion) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["reportedVersion"],
+            message: "reportedVersion must match packageVersion",
+        });
+    }
+});
+const evidenceRunSchema = z.object({
+    taskId: z.string(),
+    workerRunId: z.string(),
+    recordedAt: z.string().datetime(),
+    controllerIdentity: controllerIdentityEvidenceSchema.optional(),
+}).strict();
 const qaEvidenceSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), verdict: z.literal("passed"), acIds: z.array(z.string()).min(1), runs: z.array(evidenceRunSchema).min(1) }).strict();
 const finalVerificationSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), kind: z.literal("final-verification"), status: z.literal("passed"), headSha: z.string().regex(/^[a-f0-9]{40}$/), run: evidenceRunSchema, shellSummary: hashedRefSchema }).strict();
-const workerRunEvidenceSchema = z.object({ schemaVersion: z.literal(1), status: z.literal("succeeded"), workerRunId: z.string(), businessId: z.string(), featureId: z.string(), reportDecision: z.object({ succeeded: z.literal(true) }).passthrough(), commands: z.array(z.object({ name: z.string(), result: z.object({ ok: z.literal(true) }).passthrough() }).passthrough()).min(1) }).passthrough();
+const workerRunEvidenceSchema = z.object({ schemaVersion: z.literal(1), status: z.literal("succeeded"), workerRunId: z.string(), businessId: z.string(), featureId: z.string(), reportDecision: z.object({ succeeded: z.literal(true) }).passthrough(), commands: z.array(z.object({ name: z.string(), result: z.object({ ok: z.literal(true) }).passthrough() }).passthrough()).min(1), controllerIdentity: controllerIdentityEvidenceSchema.optional() }).passthrough();
 export async function prepareFeatureDelivery(input) {
     const repoRoot = path.resolve(input.repoRoot);
     const featureDir = path.resolve(input.featureDir);
@@ -300,8 +341,8 @@ async function canonicalQaEvidence(repoRoot, ref, featureId, runs, specs, now, b
         if (data.featureId !== featureId)
             throw new Error("Feature ownership mismatch");
         for (const entry of data.runs) {
-            assertEvidenceRun(entry, featureId, runs, specs, now, true);
-            await readCanonicalWorkerRun(repoRoot, featureId, entry.taskId, entry.workerRunId, runs);
+            const run = assertEvidenceRun(entry, featureId, runs, specs, now, true);
+            await readCanonicalWorkerRun(repoRoot, run);
         }
         const allowedAcIds = new Set(data.runs.flatMap((entry) => specs.get(entry.taskId)?.acceptance_refs ?? []));
         for (const acId of data.acIds)
@@ -322,13 +363,13 @@ async function canonicalFinalEvidence(repoRoot, ref, featureId, runs, specs, rec
         const data = finalVerificationSchema.parse(JSON.parse(await readFile(await safeRepoPath(repoRoot, ref), "utf-8")));
         if (data.featureId !== featureId)
             throw new Error("Feature ownership mismatch");
-        assertEvidenceRun(data.run, featureId, runs, specs, now, true);
+        const taskPoolRun = assertEvidenceRun(data.run, featureId, runs, specs, now, true);
         if (data.headSha !== record.lastCheckpoint)
             throw new Error("final verification is not bound to Delivery HEAD");
         const latestCheckpointAt = Math.max(...record.checkpoints.map((entry) => new Date(entry.createdAt).getTime()));
         if (new Date(data.run.recordedAt).getTime() < latestCheckpointAt)
             throw new Error("final verification predates the last checkpoint");
-        const runRecord = await readCanonicalWorkerRun(repoRoot, featureId, data.run.taskId, data.run.workerRunId, runs);
+        const runRecord = await readCanonicalWorkerRun(repoRoot, taskPoolRun);
         if (!runRecord.commands.some((command) => command.name === "run-dag"))
             throw new Error("final verification run is missing a successful run-dag command");
         const spec = specs.get(data.run.taskId);
@@ -360,6 +401,8 @@ function assertEvidenceRun(entry, featureId, runs, specs, now, requireQa) {
     const age = now.getTime() - new Date(run.recordedAt).getTime();
     if (age < 0 || age > 24 * 60 * 60 * 1000)
         throw new Error(`run is not fresh within 24 hours: ${entry.workerRunId}`);
+    assertControllerIdentityPair(entry.controllerIdentity, run.controllerIdentity, "evidence and Task Pool run");
+    return run;
 }
 async function canonicalTaskRunEvidence(repoRoot, featureId, taskId, runs, blockers, workerRunId) {
     const run = [...runs].reverse().find((candidate) => candidate.featureId === featureId && candidate.taskId === taskId && candidate.status === "succeeded" && candidate.runRecordPath && (!workerRunId || candidate.workerRunId === workerRunId));
@@ -369,7 +412,7 @@ async function canonicalTaskRunEvidence(repoRoot, featureId, taskId, runs, block
     if (!hashed)
         return undefined;
     try {
-        await readCanonicalWorkerRun(repoRoot, featureId, taskId, run.workerRunId, runs);
+        await readCanonicalWorkerRun(repoRoot, run);
         return hashed;
     }
     catch (error) {
@@ -377,15 +420,25 @@ async function canonicalTaskRunEvidence(repoRoot, featureId, taskId, runs, block
         return undefined;
     }
 }
-async function readCanonicalWorkerRun(repoRoot, featureId, taskId, workerRunId, runs) {
-    const run = runs.find((candidate) => candidate.featureId === featureId && candidate.taskId === taskId && candidate.workerRunId === workerRunId && candidate.status === "succeeded" && candidate.runRecordPath);
+async function readCanonicalWorkerRun(repoRoot, run) {
     if (!run?.runRecordPath)
         throw new Error("Task Pool run record path is missing");
     const record = workerRunEvidenceSchema.parse(JSON.parse(await readFile(await safeRepoPath(repoRoot, run.runRecordPath), "utf-8")));
-    if (record.featureId !== featureId || record.businessId !== taskId || record.workerRunId !== workerRunId)
+    if (record.featureId !== run.featureId || record.businessId !== run.taskId || record.workerRunId !== run.workerRunId)
         throw new Error("run record ownership mismatch");
+    assertControllerIdentityPair(run.controllerIdentity, record.controllerIdentity, "Task Pool run and worker run record");
     return record;
 }
+function assertControllerIdentityPair(left, right, label) {
+    if (left === undefined && right === undefined)
+        return;
+    if (left === undefined || right === undefined)
+        throw new Error(`controller identity presence mismatch between ${label}`);
+    const parsedLeft = controllerIdentityEvidenceSchema.parse(left);
+    const parsedRight = controllerIdentityEvidenceSchema.parse(right);
+    if (!controllerIdentitiesMatch(parsedLeft, parsedRight))
+        throw new Error(`controller identity mismatch between ${label}`);
+}
 async function writeDeliveryArtifacts(artifacts, coverage, manifest) {
     const deliveryDir = path.dirname(artifacts.manifest);
     const parent = path.dirname(deliveryDir);

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);
+}