@tea-agent/loop-agent 0.44.0-next.8 → 0.44.0-next.9

package/dist/application/evaluation/frontend-run-observation.js

@@ -0,0 +1,144 @@
+import { readFrontendCorpusBrowserAcceptance } from "./frontend-corpus-browser-acceptance.js";
+import { readFrontendGatewayGraph } from "./frontend-gateway-evidence.js";
+import { readFrontendSharedEvidence } from "./frontend-shared-evidence.js";
+import { readFrontendBrowserAcceptance } from "./frontend-browser-acceptance.js";
+import { computeCampaignPlanHash } from "./campaign-hash.js";
+import { readCampaignPlan } from "../../infrastructure/evaluation/campaign-store.js";
+import { realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
+import { locateDagRun, readDagRunSpec, readDagRunState } from "../../workflows/dag/lifecycle.js";
+import { readFrontendRootObservation } from "../../workflows/dag/frontend-root-observation.js";
+import { verifyControllerIdentityForResume } from "../../workflows/dag/controller-identity.js";
+import { assertFrontendPairExecution } from "./frontend-pair-registration.js";
+import { summarizeFrontendTaskPairs } from "./frontend-paired-summary.js";
+/** Collect run/cost facts. FINISHED is deliberately not converted to a passed
+ * product: independent acceptance and shared-identity admission are separate. */
+export async function readFrontendTaskRunObservation(input) {
+    if (input.acceptance && input.corpusBrowser)
+        throw Error("conflicting browser acceptance evidence");
+    const root = await readFrontendRootObservation(input.repoRoot, input.runId);
+    if (!root.runIds.length)
+        throw Error("frontend observation root missing");
+    const snapshots = [];
+    let binding;
+    let sharedRegistration;
+    let registeredAcceptance;
+    let firstStatus;
+    let lastState;
+    for (const runId of root.runIds) {
+        const located = await locateDagRun(input.repoRoot, runId);
+        if (!located)
+            throw Error("frontend observation run missing");
+        const read = (name) => readFileBoundarySafe({ boundaryRoot: located.runDir,
+            targetPath: path.join(located.runDir, name), label: "frontend run observation" });
+        const snapshot = { runDir: located.runDir, state: await read("state.json"), spec: await read("run.json"), controller: await read("controller-identity.json") };
+        const state = await readDagRunState(located.runDir), spec = await readDagRunSpec(located.runDir);
+        if (await realpath(state.cwd) !== await realpath(input.repoRoot))
+            throw Error("frontend observation workspace mismatch");
+        firstStatus ??= state.status;
+        if (state.runId !== runId || !state.evaluation?.frontendPair || !spec.evaluation?.frontendPair ||
+            JSON.stringify(state.evaluation) !== JSON.stringify(spec.evaluation))
+            throw Error("frontend observation frozen evaluation mismatch");
+        if (binding && JSON.stringify(binding) !== JSON.stringify(state.evaluation))
+            throw Error("frontend observation recovery evaluation drift");
+        binding = state.evaluation;
+        const artifact = JSON.parse(snapshot.controller.toString("utf8"));
+        if (state.controllerIdentityRef?.path !== "controller-identity.json" || artifact.status !== "pinned" || !artifact.identity)
+            throw Error("frontend observation controller not pinned");
+        const pinned = await verifyControllerIdentityForResume({ runDir: located.runDir, state, currentIdentity: artifact.identity });
+        const registration = await assertFrontendPairExecution({ repoRoot: input.repoRoot, binding,
+            controllerFingerprint: pinned.identity.packageFingerprint.value, startedAt: state.startedAt });
+        sharedRegistration = registration;
+        registeredAcceptance = registration.shared.acceptance;
+        snapshots.push(snapshot);
+        lastState = state;
+    }
+    let acceptance;
+    if (input.acceptance) {
+        if (input.acceptance.contract.sha256 !== registeredAcceptance)
+            throw Error("browser acceptance contract not registered for run");
+        acceptance = await readFrontendBrowserAcceptance({ repoRoot: input.repoRoot, runDir: snapshots.at(-1).runDir, ...input.acceptance });
+    }
+    let corpusBrowserEvidence;
+    if (input.corpusBrowser) {
+        if (input.corpusBrowser.contract.sha256 !== registeredAcceptance)
+            throw Error("corpus browser contract not registered for run");
+        corpusBrowserEvidence = await readFrontendCorpusBrowserAcceptance({ repoRoot: input.repoRoot, runDir: snapshots.at(-1).runDir, ...input.corpusBrowser });
+    }
+    // A failed required browser behavior disproves delivery. Passing browser
+    // checks alone does not prove the remaining product quality gates.
+    const productVerdict = corpusBrowserEvidence?.browserPassed === false || acceptance?.passed === false ? false : null;
+    const sharedEvidence = sharedRegistration?.sharedArtifacts ? await readFrontendSharedEvidence({
+        repoRoot: input.repoRoot, runDirs: snapshots.map(snapshot => snapshot.runDir),
+        artifacts: sharedRegistration.sharedArtifacts, expected: sharedRegistration.shared,
+    }) : undefined;
+    let gatewayObservation;
+    if (input.gatewaySnapshots) {
+        if (!sharedRegistration?.gatewayTopology)
+            throw Error("frontend run gateway topology not registered");
+        const graph = await readFrontendGatewayGraph({ repoRoot: input.repoRoot,
+            topology: sharedRegistration.gatewayTopology, expectedPlanHash: sharedRegistration.planHash,
+            evidence: input.gatewaySnapshots });
+        const providerAttempts = graph.providerAttempts.filter(row => row.originCellId === binding.frontendPair.cellId);
+        if (providerAttempts.some(row => row.originTaskRef !== binding.taskRef))
+            throw Error("frontend gateway task binding mismatch");
+        gatewayObservation = {
+            evidenceKind: "registered-cell-gateway-observations",
+            cellId: binding.frontendPair.cellId, taskRef: binding.taskRef,
+            topologySha256: graph.topologySha256, snapshots: input.gatewaySnapshots,
+            observedProviderAttempts: providerAttempts.length,
+            reportedProviderTokens: graph.diagnostics.length || providerAttempts.some(row => row.totalTokens === null)
+                ? null : providerAttempts.reduce((sum, row) => sum + row.totalTokens, 0),
+            providerAttempts,
+            // Graph-wide unresolved hops remain conservative even for another cell.
+            diagnostics: [...graph.diagnostics, "gateway-run-coverage-not-proven"],
+        };
+    }
+    for (const snapshot of snapshots)
+        for (const [file, expected] of [["state.json", snapshot.state], ["run.json", snapshot.spec], ["controller-identity.json", snapshot.controller]]) {
+            const actual = await readFileBoundarySafe({ boundaryRoot: snapshot.runDir, targetPath: path.join(snapshot.runDir, file), label: "frontend observation recheck" });
+            if (!actual.equals(expected))
+                throw Error("frontend observation changed during collection");
+        }
+    const recheckedRoot = await readFrontendRootObservation(input.repoRoot, input.runId);
+    if (JSON.stringify(recheckedRoot) !== JSON.stringify(root))
+        throw Error("frontend root observations changed during collection");
+    const knownFailure = root.complete && ["failed", "partial_failed"].includes(lastState.status);
+    const consumed = root.cumulativeBudget?.consumed;
+    // Reservations precede dispatch and can survive a failed dispatch. The root
+    // timer starts at DAG allocation, after task/source preparation. Keep these
+    // useful facts, but do not relabel them as task-wide request/time metrics.
+    const observedBudget = {
+        reservedRequests: root.complete ? consumed?.providerRequests ?? null : null,
+        cumulativeTokens: root.complete && consumed?.missingTokenNodeIds.length === 0 ? consumed.tokens : null,
+        dagWallClockMs: root.dagWallClockMs,
+    };
+    const metricDiagnostics = ["task-provider-request-count-not-observed", "task-wallclock-not-observed"];
+    if (!root.sourceUsage?.complete)
+        metricDiagnostics.push("task-source-usage-not-observed");
+    const observation = {
+        cellId: binding.frontendPair.cellId, bundleHash: binding.bundleHash, runId: root.runIds[0],
+        firstPassed: root.complete && root.runIds.length === 1 ? (knownFailure ? false : productVerdict) : root.complete && ["failed", "partial_failed"].includes(firstStatus) ? false : null,
+        finalPassed: root.complete ? (knownFailure ? false : productVerdict) : null,
+        requests: null,
+        tokens: root.sourceUsage?.complete ? observedBudget.cumulativeTokens : null,
+        wallClockMs: null,
+    };
+    return { campaignId: binding.campaignId, observation, outcome: root.complete ? lastState.status : null,
+        diagnostics: [...root.diagnostics, ...metricDiagnostics, ...(gatewayObservation?.diagnostics ?? ["gateway-snapshots-not-supplied"]), ...(corpusBrowserEvidence?.diagnostics ?? acceptance?.diagnostics ?? ["independent-acceptance-pending"]), ...(sharedEvidence?.diagnostics ?? ["shared-identity-admission-pending"])],
+        acceptance, corpusBrowserEvidence, sharedEvidence, observedBudget, gatewayObservation,
+        runs: snapshots.map((snapshot, index) => ({ runId: root.runIds[index], stateSha256: createHash("sha256").update(snapshot.state).digest("hex"), runSha256: createHash("sha256").update(snapshot.spec).digest("hex") })) };
+}
+export async function collectFrontendTaskPairSummary(input) {
+    const stored = await readCampaignPlan(input.repoRoot, input.plan.campaignId);
+    if (!stored || input.plan.planHash !== stored.planHash || computeCampaignPlanHash(input.plan.campaignId, input.plan.cells) !== stored.planHash)
+        throw Error("frontend summary registered plan mismatch");
+    const collected = [];
+    for (const runId of input.runIds)
+        collected.push(await readFrontendTaskRunObservation({ repoRoot: input.repoRoot, runId, corpusBrowser: input.corpusBrowserByRun?.[runId], gatewaySnapshots: input.gatewaySnapshotsByRun?.[runId], acceptance: input.acceptanceByRun?.[runId] }));
+    if (collected.some(row => row.campaignId !== input.plan.campaignId))
+        throw Error("frontend summary campaign mismatch");
+    return { summary: summarizeFrontendTaskPairs({ ...input, observations: collected.map(row => row.observation) }), collected };
+}

package/dist/application/evaluation/frontend-shared-evidence.js

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { z } from "zod";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { readDagRunSpec } from "../../workflows/dag/lifecycle.js";
+import { readFrontendSessionBudgetReceipts } from "../../workflows/dag/frontend-session-budget.js";
+import { verifyFrozenSourceUsage } from "../../task/source-prepare/source-provider-budget.js";
+import { frontendSharedArtifactsSchema } from "./frontend-pair-registration.js";
+export async function readFrontendSharedEvidence(input) {
+    if (!input.runDirs.length)
+        throw Error("shared evidence requires a root run");
+    const artifacts = frontendSharedArtifactsSchema.parse(input.artifacts);
+    const snapshots = [];
+    const read = async (root, name, expected) => {
+        const target = path.resolve(root, name);
+        const bytes = await readFileBoundarySafe({ boundaryRoot: root, targetPath: target, label: "frontend shared evidence" });
+        if (expected && createHash("sha256").update(bytes).digest("hex") !== expected)
+            throw Error(`shared artifact hash mismatch: ${name}`);
+        snapshots.push({ root, target, bytes });
+        return JSON.parse(bytes.toString("utf8"));
+    };
+    const values = {};
+    for (const key of ["source", "budget", "model", "initialTree"]) {
+        if (artifacts[key].sha256 !== input.expected[key])
+            throw Error(`shared artifact not registered: ${key}`);
+        values[key] = await read(input.repoRoot, artifacts[key].path, artifacts[key].sha256);
+    }
+    const model = z.object({ model: z.string().min(1), parameters: z.record(z.unknown()).optional() }).strict().parse(values.model);
+    const diagnostics = [];
+    if (model.parameters && Object.keys(model.parameters).length)
+        diagnostics.push("model-sampling-parameters-not-observed");
+    const expectedTree = z.object({ gitHeadSha: z.string().regex(/^[a-f0-9]{40,64}$/), changedPaths: z.array(z.unknown()), stableGovernanceInputs: z.array(z.unknown()) }).strict().parse(values.initialTree);
+    const checkpoint = await read(input.runDirs[0], ".runtime/workspace-checkpoint-start.json");
+    const actualTree = { gitHeadSha: checkpoint.gitHeadSha, changedPaths: checkpoint.changedPaths, stableGovernanceInputs: checkpoint.stableGovernanceInputs ?? [] };
+    if (sha256OfCanonicalJson(actualTree) !== sha256OfCanonicalJson(expectedTree))
+        throw Error("shared initial tree mismatch");
+    let attempts = 0;
+    const inspected = new Map();
+    const inspect = (receipt) => {
+        if (receipt.identity.executionKind !== "model")
+            return;
+        const key = JSON.stringify([receipt.identity.runId ?? receipt.identity.taskId, receipt.identity.sessionId]);
+        const contentHash = sha256OfCanonicalJson(receipt);
+        if (inspected.has(key)) {
+            if (inspected.get(key) !== contentHash)
+                throw Error("conflicting shared model receipt");
+            return;
+        }
+        inspected.set(key, contentHash);
+        if (receipt.completion !== "complete" || !receipt.attempts.length || !receipt.planned?.capabilities.model)
+            diagnostics.push("shared model observation incomplete");
+        if (receipt.planned?.capabilities.model && receipt.planned.capabilities.model !== model.model)
+            throw Error("shared planned model mismatch");
+        for (const attempt of receipt.attempts) {
+            if (attempt.model !== model.model)
+                throw Error("shared attempt model mismatch");
+            if (attempt.completion !== "complete")
+                diagnostics.push("shared model observation incomplete");
+            attempts++;
+        }
+    };
+    const sourceReceipts = new Set();
+    for (const runDir of input.runDirs) {
+        await read(runDir, "run.json");
+        const spec = await readDagRunSpec(runDir);
+        if (sha256OfCanonicalJson(spec.sourceBinding ?? null) !== sha256OfCanonicalJson(values.source))
+            throw Error("shared source mismatch");
+        if (sha256OfCanonicalJson(spec.budget ?? null) !== sha256OfCanonicalJson(values.budget))
+            throw Error("shared budget mismatch");
+        const state = await read(runDir, "state.json");
+        for (const task of spec.tasks) {
+            const receipts = await readFrontendSessionBudgetReceipts(runDir, task.id);
+            const node = state.nodes?.[task.id];
+            if (task.executor === "pi" && node && !["PENDING", "SKIPPED"].includes(node.status) && node.origin?.kind !== "imported" && !receipts.length)
+                diagnostics.push(`missing model receipts: ${task.id}`);
+            for (const receipt of receipts)
+                inspect(receipt);
+        }
+        if (spec.sourceProviderBudget) {
+            const verified = await verifyFrozenSourceUsage(input.repoRoot, spec.sourceProviderBudget);
+            diagnostics.push(...verified.diagnostics);
+            for (const source of spec.sourceProviderBudget.evidence?.receipts ?? []) {
+                if (sourceReceipts.has(source.sha256))
+                    continue;
+                sourceReceipts.add(source.sha256);
+                inspect(JSON.parse(source.content));
+            }
+        }
+    }
+    if (!attempts)
+        diagnostics.push("shared model has no observed attempts");
+    // Sampling settings are not yet present in session receipts; matching model
+    // names alone cannot prove every parameter used by the SDK/provider.
+    if (!diagnostics.includes("model-sampling-parameters-not-observed"))
+        diagnostics.push("model-sampling-parameters-not-observed");
+    diagnostics.push("provider-resolved-model-not-observed");
+    for (const snapshot of snapshots) {
+        const latest = await readFileBoundarySafe({ boundaryRoot: snapshot.root, targetPath: snapshot.target, label: "shared evidence recheck" });
+        if (!latest.equals(snapshot.bytes))
+            throw Error("shared evidence changed during collection");
+    }
+    return { diagnostics: [...new Set(diagnostics)], model: model.model, observedAttempts: attempts,
+        verified: { source: true, budget: true, initialTree: true, modelReference: attempts > 0 && diagnostics.every(item => ["model-sampling-parameters-not-observed", "provider-resolved-model-not-observed"].includes(item)), samplingParameters: false } };
+}

package/dist/application/evaluation/types.js

@@ -265,18 +265,51 @@ const corpusManifestObjectSchema = z
         .optional(),
 })
     .strict();
-export const corpusManifestInputSchema = corpusManifestObjectSchema.superRefine(refineCorpusTasks);
-export const corpusManifestSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    corpusId: corpusIdSchema,
-    createdAt: z.string().min(1),
-    description: z.string().optional(),
-    tasks: z.array(corpusTaskSchema).min(12).max(20),
-    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-})
-    .strict()
-    .superRefine(refineCorpusTasks);
+// The six-case exploratory frontend protocol is distinct from the heterogeneous
+// dogfood corpus. All six are public execution tasks, not held-out claims.
+const frontendCorpusCategories = [
+    "local-interaction", "form-validation", "component-reuse",
+    "table-filter-pagination", "multi-api-mock-boundary", "shared-context-domains",
+];
+const frontendCorpusFileSchema = z.object({
+    path: z.string().min(1).refine(value => !value.includes("\\") && !value.includes(":") &&
+        !value.startsWith("/") && value.split("/").every(part => part !== "" && part !== "." && part !== ".."), "corpus artifact must be a normalized relative file path"),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+}).strict();
+const frontendCorpusFilesSchema = z.array(frontendCorpusFileSchema).min(1).superRefine((files, ctx) => {
+    if (new Set(files.map(file => file.path)).size !== files.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "duplicate corpus artifact path" });
+});
+const frontendCorpusTaskSchema = corpusTaskSchema.extend({
+    class: z.literal("frontend"), split: z.literal("public"),
+    category: z.enum(frontendCorpusCategories),
+    requirements: frontendCorpusFilesSchema,
+    initialFiles: frontendCorpusFilesSchema,
+    oracleFiles: frontendCorpusFilesSchema,
+}).superRefine((task, ctx) => {
+    if (task.seeds.length !== 3)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "frontend corpus requires three planned repetitions" });
+});
+const frontendCorpusObjectSchema = z.object({
+    schemaVersion: z.literal(2), purpose: z.literal("frontend-task-pairs"),
+    corpusId: corpusIdSchema, createdAt: z.string().datetime(), description: z.string().optional(),
+    tasks: z.array(frontendCorpusTaskSchema).length(6),
+    corpusHash: z.string().regex(/^(sha256:)?[a-f0-9]{64}$/i).optional(),
+}).strict();
+function refineFrontendCorpus(manifest, ctx) {
+    if (new Set(manifest.tasks.map(task => task.category)).size !== frontendCorpusCategories.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "frontend corpus requires all six categories exactly once" });
+    if (new Set(manifest.tasks.map(task => task.taskRef)).size !== manifest.tasks.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "duplicate frontend corpus taskRef" });
+}
+export const corpusManifestInputSchema = z.union([
+    corpusManifestObjectSchema.superRefine(refineCorpusTasks),
+    frontendCorpusObjectSchema.superRefine(refineFrontendCorpus),
+]);
+export const corpusManifestSchema = z.union([
+    corpusManifestObjectSchema.extend({ corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/) }).superRefine(refineCorpusTasks),
+    frontendCorpusObjectSchema.extend({ corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/) }).superRefine(refineFrontendCorpus),
+]);
 // --- Private Verifier + Campaign (M4) ---
 export const privateVerifierIdSchema = z
     .string()

package/dist/application/task-lifecycle/observe.js

@@ -198,6 +198,10 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
     const recorded = new Map((record?.runAssociations ?? []).map((entry) => [entry.runId, entry.source]));
     const entries = await listAllDagRunEntries(repoRoot);
     const related = [];
+    // Recency key per run. `runId` is NOT chronological (a later recovery run can
+    // sort before an earlier one lexicographically, e.g. `dag-…` vs `2026…`), so
+    // ordering by runId alone reports a superseded run as the latest.
+    const startedAtByRunId = new Map();
     for (const entry of entries) {
         let source = recorded.get(entry.runId) ?? null;
         let stateStatus;
@@ -207,6 +211,9 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
         try {
             const state = await readDagRunState(entry.runDir);
             stateStatus = state.status;
+            if (typeof state.startedAt === "string") {
+                startedAtByRunId.set(entry.runId, state.startedAt);
+            }
             const liveness = assessDagRunLiveness({ state });
             const activeNode = Object.values(state.nodes ?? {}).find((node) => node.status === "RUNNING");
             lastMeaningfulProgressAt =
@@ -266,7 +273,25 @@ export async function listExplicitlyAssociatedRuns(repoRoot, taskId) {
             contractBinding,
         });
     }
-    return related.sort((a, b) => a.runId.localeCompare(b.runId));
+    // Chronological order by run start time; runs without a readable start time
+    // sort first so a run with real timing is never displaced by an unknown.
+    // runId breaks ties deterministically.
+    return related.sort((a, b) => {
+        const aStarted = startedAtByRunId.get(a.runId);
+        const bStarted = startedAtByRunId.get(b.runId);
+        if (aStarted !== bStarted) {
+            if (aStarted === undefined)
+                return -1;
+            if (bStarted === undefined)
+                return 1;
+            const aTime = Date.parse(aStarted);
+            const bTime = Date.parse(bStarted);
+            if (Number.isFinite(aTime) && Number.isFinite(bTime) && aTime !== bTime) {
+                return aTime - bTime;
+            }
+        }
+        return a.runId.localeCompare(b.runId);
+    });
 }
 function deriveLifecycleState(input) {
     if (!input.exists)

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.8",
-  "gitSha": "e100bbbeba403ae8cbe6c9a93ccce76cbadf434e",
-  "builtAt": "2026-09-16T23:48:41.706Z"
+  "version": "0.44.0-next.9",
+  "gitSha": "e4db199463a7b550af890295b630d91660e4239f",
+  "builtAt": "2026-09-17T01:09:20.426Z"
 }

package/dist/cli/command-definitions.js

@@ -1,4 +1,5 @@
 import { runDoctor } from "../commands/doctor.js";
+import { runPromoteRun } from "../commands/promote-run.js";
 import { runDocsArchive } from "../commands/docs-archive.js";
 import { runDocsAudit } from "../commands/docs-audit.js";
 import { runEval } from "../commands/eval.js";
@@ -197,6 +198,16 @@ export const COMMAND_DEFINITIONS = [
             await runDoctor(adapter, repoRoot, rest.filter((arg) => Boolean(arg)));
         },
     },
+    {
+        name: "promote-run",
+        adapter: "required",
+        tier: "operator",
+        intent: "Promote deterministic evidence from a completed DAG or one-shot run into task artifacts (修改记录.md, 验证结果.md).",
+        usage: "promote-run <task-id> --run-id <run-id>",
+        handler: async ({ adapter, repoRoot, rest }) => {
+            await runPromoteRun(repoRoot, rest.filter((arg) => Boolean(arg)));
+        },
+    },
     {
         name: "docs",
         adapter: "required",

package/dist/cli/program.js

@@ -29,6 +29,7 @@ import { runDocsArchive } from "../commands/docs-archive.js";
 import { runDocsAudit } from "../commands/docs-audit.js";
 import { runEval } from "../commands/eval.js";
 import { runDoctor } from "../commands/doctor.js";
+import { runPromoteRun } from "../commands/promote-run.js";
 import { runExamples } from "../commands/examples.js";
 import { runGoal } from "../commands/goal.js";
 import { runHandoffCheck } from "../commands/handoff-check.js";
@@ -149,6 +150,9 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
         case "doctor":
             await runDoctor(ctx.adapter, ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
+        case "promote-run":
+            await runPromoteRun(ctx.repoRoot, compactArgs([subcommand, ...rest]));
+            return;
         case "docs":
             await runDocsCommand(ctx.repoRoot, subcommand, rest);
             return;

package/dist/commands/task-advance.js

@@ -1,3 +1,4 @@
+import { capabilityBoundarySchema } from "../task/config-types.js";
 import { advanceTaskLifecycle, } from "../application/task-lifecycle/index.js";
 import { backendTestConfigSchema, } from "../task/config-types.js";
 import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
@@ -145,13 +146,10 @@ export function parseTaskAdvanceArgs(args) {
         if (token === "--capability-boundary") {
             try {
                 const parsed = JSON.parse(next());
-                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                    throw new Error("not an object");
-                }
-                options.capabilityBoundary = parsed;
+                options.capabilityBoundary = capabilityBoundarySchema.parse(parsed);
             }
             catch (error) {
-                throw new Error(`--capability-boundary must be a JSON object {allowed?, forbidden?}: ${error.message}`);
+                throw new Error(`--capability-boundary must be a JSON object {allowed?, forbidden?, requiredClauses?}: ${error.message}`);
             }
             continue;
         }

package/dist/commands/task-source-prepare.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { stdin as stdinStream } from "node:process";
-import { parseAcceptanceFlag, parseVerifyFlag, parseVerifyTimeoutFlag, prepareTaskSource, PREPARE_MAX_FILE_BYTES, } from "../task/source-prepare/index.js";
+import { parseAcceptanceFlag, parseVerifyFlag, parseVerifyLaneFlag, parseVerifyTimeoutFlag, prepareTaskSource, PREPARE_MAX_FILE_BYTES, } from "../task/source-prepare/index.js";
 import { parseTaskContractDraft } from "../task/contract/schema.js";
 import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
 const COMMAND = "task source prepare";
@@ -28,6 +28,7 @@ const USAGE = `usage:
     [--open-question <text>]...
     [--verify <label:command>]...
     [--verify-timeout <label:timeoutMs>]...
+    [--verify-lane <label:static|behavior>]...
     [--request-id <id>]
     [--dry-run | --apply]
     [--force-overwrite-source]
@@ -157,6 +158,10 @@ export function parseTaskSourcePrepareArgs(args) {
             options.verifyTimeout = pushList(options.verifyTimeout, next());
             continue;
         }
+        if (token === "--verify-lane") {
+            options.verifyLane = pushList(options.verifyLane, next());
+            continue;
+        }
         if (token === "--request-id") {
             options.requestId = next();
             continue;
@@ -287,13 +292,20 @@ function buildFlags(options) {
             const parsed = parseVerifyTimeoutFlag(raw);
             timeouts.set(parsed.label, parsed.timeoutMs);
         }
+        const lanes = new Map();
+        for (const raw of options.verifyLane ?? []) {
+            const parsed = parseVerifyLaneFlag(raw);
+            lanes.set(parsed.label, parsed.mode);
+        }
         const commands = (options.verify ?? []).map((raw) => {
             const parsed = parseVerifyFlag(raw);
             const timeoutMs = timeouts.get(parsed.label);
+            const mode = lanes.get(parsed.label);
             return {
                 label: parsed.label,
                 command: parsed.command,
                 ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                ...(mode !== undefined ? { mode } : {}),
             };
         });
         // If only timeouts provided without verify, treat as empty explicit list? No — only set when --verify appears.

package/dist/executors/dag-pi/tools/design-terminal-tools.js

@@ -16,7 +16,7 @@ export async function createFrontendDesignTerminalTools(input) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
-    const { approveDesignFactSchema, readCommittedEvents, requestDesignChangesFactSchema, writeTypedEventStoreJsonl, } = await import("../../../workflows/dag/frontend-typed-event-store.js");
+    const { approveDesignFactSchema, readCommittedEvents, requestDesignChangesFactSchema, reviewFindingSchema, writeTypedEventStoreJsonl, } = await import("../../../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../../../workflows/dag/frontend-typed-event-transaction.js");
     let store = input.store;
     const attemptId = input.attemptId;
@@ -26,6 +26,7 @@ export async function createFrontendDesignTerminalTools(input) {
         line: Type.Optional(Type.Integer({ minimum: 1 })),
         issue: Type.String({ minLength: 1 }),
         requiredChange: Type.Optional(Type.String({ minLength: 1 })),
+        repairAssertions: Type.Optional(Type.Unknown()),
     }, { additionalProperties: false });
     const scopeProtocol = createFrontendReviewScopeProtocol({ phase: "design", inventory: input.inventory, getStore: () => store, attemptId });
     const savedFindings = () => [...new Map(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "design-finding").map(r => [r.fact.id, r.fact.finding])).values()];
@@ -35,12 +36,21 @@ export async function createFrontendDesignTerminalTools(input) {
         description: "Save one finding with a stable id. Submit findings incrementally, then finalize without repeating the findings array. Saved blocking findings cannot be omitted from approval; correct a finding explicitly with replace:true.",
         parameters: Type.Object({ id: Type.String({ minLength: 1 }), finding: findingSchema }, { additionalProperties: false }),
         async execute(_callId, params) {
-            const fact = { kind: "design-finding", id: params.id, finding: params.finding };
-            const requestId = `${attemptId}:finding:${randomUUID()}`;
-            const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
-            const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
-            const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
-            return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            try {
+                const previous = readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "design-finding" && r.fact.id === params.id).at(-1);
+                const scopeIds = scopeProtocol.findingScopeIds(previous?.fact.scopeIds);
+                const fact = { kind: "design-finding", id: params.id, finding: reviewFindingSchema.parse(params.finding), ...(scopeIds ? { scopeIds } : {}) };
+                const requestId = `${attemptId}:finding:${randomUUID()}`;
+                const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
+                const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
+                const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
+            catch (error) {
+                const code = error.code ?? "FRONTEND_INPUT_SCOPE_VIOLATION";
+                const details = { ok: false, code, error: error instanceof Error ? error.message : String(error) };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
         },
     });
     const approveParameters = Type.Object({

package/dist/executors/dag-pi/tools/review-terminal-tools.js

@@ -16,7 +16,7 @@ export async function createFrontendReviewTerminalTools(input) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
-    const { approveReviewFactSchema, readCommittedEvents, requestReviewChangesFactSchema, writeTypedEventStoreJsonl, } = await import("../../../workflows/dag/frontend-typed-event-store.js");
+    const { approveReviewFactSchema, readCommittedEvents, requestReviewChangesFactSchema, reviewFindingSchema, writeTypedEventStoreJsonl, } = await import("../../../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../../../workflows/dag/frontend-typed-event-transaction.js");
     let store = input.store;
     const attemptId = input.attemptId;
@@ -26,6 +26,7 @@ export async function createFrontendReviewTerminalTools(input) {
         line: Type.Optional(Type.Integer({ minimum: 1 })),
         issue: Type.String({ minLength: 1 }),
         requiredChange: Type.Optional(Type.String({ minLength: 1 })),
+        repairAssertions: Type.Optional(Type.Unknown()),
     }, { additionalProperties: false });
     const scopeProtocol = createFrontendReviewScopeProtocol({ phase: "review", inventory: input.inventory, getStore: () => store, attemptId });
     const savedFindings = () => [...new Map(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "review-finding").map(r => [r.fact.id, r.fact.finding])).values()];
@@ -35,12 +36,21 @@ export async function createFrontendReviewTerminalTools(input) {
         description: "Save one finding with a stable id. Submit findings incrementally, then finalize without repeating the findings array. Saved blocking findings cannot be omitted from approval; correct a finding explicitly with replace:true.",
         parameters: Type.Object({ id: Type.String({ minLength: 1 }), finding: findingSchema }, { additionalProperties: false }),
         async execute(_callId, params) {
-            const fact = { kind: "review-finding", id: params.id, finding: params.finding };
-            const requestId = `${attemptId}:finding:${randomUUID()}`;
-            const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
-            const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
-            const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
-            return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            try {
+                const previous = readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "review-finding" && r.fact.id === params.id).at(-1);
+                const scopeIds = scopeProtocol.findingScopeIds(previous?.fact.scopeIds);
+                const fact = { kind: "review-finding", id: params.id, finding: reviewFindingSchema.parse(params.finding), ...(scopeIds ? { scopeIds } : {}) };
+                const requestId = `${attemptId}:finding:${randomUUID()}`;
+                const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
+                const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
+                const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
+            catch (error) {
+                const code = error.code ?? "FRONTEND_INPUT_SCOPE_VIOLATION";
+                const details = { ok: false, code, error: error instanceof Error ? error.message : String(error) };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
         },
     });
     const approveParameters = Type.Object({