@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.4

package/dist/workflows/dag/frontend-shape-capsule-store.js

@@ -0,0 +1,191 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { CANONICAL_TASK_ID_PATTERN } from "../../task/runtime.js";
+import { parseFrontendShapeTransitionCapsule, } from "./frontend-shape.js";
+const DIGEST_PATTERN = /^[a-f0-9]{64}$/;
+const RUN_ID_PATTERN = /^\d{8}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NON_CANONICAL_SHAPE_TERMINAL_STATUSES = new Set(["finished", "partial_failed", "superseded", "abandoned"]);
+const recordEnvelopeSchema = z.object({
+    schemaVersion: z.literal(1),
+    taskId: z.string().min(1),
+    parentRunId: z.string().min(1),
+    terminalOutcome: z.enum(["reshape-required", "split-required"]),
+    capsuleDigest: z.string().regex(DIGEST_PATTERN),
+    committedAt: z.string().datetime(),
+    capsule: z.unknown(),
+}).strict();
+function assertTaskId(taskId) {
+    if (!CANONICAL_TASK_ID_PATTERN.test(taskId)) {
+        throw new Error(`invalid frontend shape capsule taskId: ${taskId}`);
+    }
+}
+function assertRunId(runId) {
+    if (!RUN_ID_PATTERN.test(runId)) {
+        throw new Error(`invalid frontend shape capsule parentRunId: ${runId}`);
+    }
+}
+function assertDigest(digest) {
+    if (!DIGEST_PATTERN.test(digest)) {
+        throw new Error(`invalid frontend shape capsule digest: ${digest}`);
+    }
+}
+function canonicalEqual(left, right) {
+    return sha256OfCanonicalJson(left) === sha256OfCanonicalJson(right);
+}
+function parseRecord(value) {
+    const envelope = recordEnvelopeSchema.parse(value);
+    assertTaskId(envelope.taskId);
+    assertRunId(envelope.parentRunId);
+    const capsule = parseFrontendShapeTransitionCapsule(envelope.capsule);
+    if (envelope.capsuleDigest !== capsule.capsuleDigest) {
+        throw new Error("frontend shape capsule record digest drifted");
+    }
+    if (envelope.taskId !== capsule.taskId || envelope.parentRunId !== capsule.parentRunId) {
+        throw new Error("frontend shape capsule record task/run binding drifted");
+    }
+    if (envelope.committedAt !== capsule.committedAt) {
+        throw new Error("frontend shape capsule record committedAt drifted");
+    }
+    const expectedOutcome = capsule.kind === "split" ? "split-required" : "reshape-required";
+    if (envelope.terminalOutcome !== expectedOutcome) {
+        throw new Error("frontend shape capsule record terminal outcome drifted");
+    }
+    return { ...envelope, capsule };
+}
+export function frontendShapeCapsuleRecordPath(repoRoot, taskId, capsuleDigest) {
+    assertTaskId(taskId);
+    assertDigest(capsuleDigest);
+    return path.join(path.resolve(repoRoot), ".harness", "tasks", taskId, "artifacts", "frontend-shape-transitions", `${capsuleDigest}.json`);
+}
+export async function ensureFrontendShapeCapsuleRecord(input) {
+    assertTaskId(input.taskId);
+    assertRunId(input.parentRunId);
+    const capsule = parseFrontendShapeTransitionCapsule(input.capsule);
+    const record = parseRecord({
+        schemaVersion: 1,
+        taskId: input.taskId,
+        parentRunId: input.parentRunId,
+        terminalOutcome: input.terminalOutcome,
+        capsuleDigest: capsule.capsuleDigest,
+        committedAt: capsule.committedAt,
+        capsule,
+    });
+    const targetPath = frontendShapeCapsuleRecordPath(input.repoRoot, input.taskId, capsule.capsuleDigest);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    const tempPath = path.join(path.dirname(targetPath), `.${capsule.capsuleDigest}.${process.pid}.${randomUUID()}.tmp`);
+    await writeFile(tempPath, `${JSON.stringify(record, null, 2)}\n`, { flag: "wx" });
+    try {
+        await link(tempPath, targetPath);
+        return { path: targetPath, created: true, record };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EEXIST")
+            throw error;
+        let existing;
+        try {
+            existing = parseRecord(JSON.parse(await readFile(targetPath, "utf8")));
+        }
+        catch (parseError) {
+            throw new Error(`frontend shape capsule immutable record collision: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+        }
+        if (!canonicalEqual(existing, record)) {
+            throw new Error("frontend shape capsule immutable record collision");
+        }
+        return { path: targetPath, created: false, record: existing };
+    }
+    finally {
+        await unlink(tempPath).catch(() => { });
+    }
+}
+async function readCompletedState(repoRoot, parentRunId) {
+    const statePath = path.join(path.resolve(repoRoot), ".harness", "dag-runs", "completed", parentRunId, "state.json");
+    try {
+        return JSON.parse(await readFile(statePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error(`invalid completed frontend shape parent state ${parentRunId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function assertCompletedBinding(record, state) {
+    if (typeof state !== "object" || state === null || Array.isArray(state)) {
+        throw new Error("completed frontend shape parent state must be an object");
+    }
+    const value = state;
+    if (value.runId !== record.parentRunId)
+        throw new Error("completed frontend shape parent runId drifted");
+    const shapeState = value.frontendShapeState;
+    if (value.status !== "failed") {
+        if (NON_CANONICAL_SHAPE_TERMINAL_STATUSES.has(String(value.status)) &&
+            typeof shapeState === "object" &&
+            shapeState !== null &&
+            !Array.isArray(shapeState) &&
+            ["terminalOutcome", "transitionCommittedAt", "transitionCapsule"].some((key) => key in shapeState)) {
+            throw new Error(`completed frontend shape parent status ${String(value.status)} is not canonical`);
+        }
+        return false;
+    }
+    if (typeof shapeState !== "object" || shapeState === null || Array.isArray(shapeState))
+        return false;
+    const binding = shapeState;
+    if (binding.terminalOutcome !== record.terminalOutcome)
+        throw new Error("completed frontend shape terminal outcome drifted");
+    if (binding.transitionCommittedAt !== record.committedAt) {
+        throw new Error("completed frontend shape committedAt drifted");
+    }
+    let stateCapsule;
+    try {
+        stateCapsule = parseFrontendShapeTransitionCapsule(binding.transitionCapsule);
+    }
+    catch (error) {
+        throw new Error(`completed frontend shape capsule invalid: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!canonicalEqual(stateCapsule, record.capsule))
+        throw new Error("completed frontend shape capsule binding drifted");
+    return true;
+}
+export async function discoverLatestCommittedFrontendShapeCapsule(input) {
+    assertTaskId(input.taskId);
+    assertDigest(input.sourceDigest);
+    const directory = path.dirname(frontendShapeCapsuleRecordPath(input.repoRoot, input.taskId, "0".repeat(64)));
+    let entries;
+    try {
+        entries = await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    const candidates = [];
+    for (const entry of entries.filter((name) => name.endsWith(".json")).sort()) {
+        const digest = entry.slice(0, -5);
+        assertDigest(digest);
+        let record;
+        try {
+            record = parseRecord(JSON.parse(await readFile(path.join(directory, entry), "utf8")));
+        }
+        catch (error) {
+            throw new Error(`invalid frontend shape capsule record ${entry}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (record.taskId !== input.taskId || record.capsuleDigest !== digest) {
+            throw new Error(`frontend shape capsule record path binding drifted: ${entry}`);
+        }
+        const state = await readCompletedState(input.repoRoot, record.parentRunId);
+        if (state === undefined || !assertCompletedBinding(record, state))
+            continue;
+        if (record.capsule.sourceDigest !== input.sourceDigest)
+            continue;
+        candidates.push(record);
+    }
+    candidates.sort((left, right) => {
+        const byTime = right.committedAt.localeCompare(left.committedAt);
+        return byTime !== 0 ? byTime : right.capsuleDigest.localeCompare(left.capsuleDigest);
+    });
+    return candidates[0]?.capsule;
+}

package/dist/workflows/dag/frontend-shape-facts.js

@@ -0,0 +1,409 @@
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { buildFrontendShapeTransitionCapsule, deriveFrontendRuntimeShapeFacts, evaluateFrontendShapeEscalation, parseFrontendShapeTransitionCapsule, } from "./frontend-shape.js";
+import { createTypedEventStore, readCommittedEvents, } from "./frontend-typed-event-store.js";
+import { adoptTypedEventFact, stageTypedEventFact, } from "./frontend-typed-event-transaction.js";
+export const FRONTEND_SHAPE_BOUNDARIES = [
+    { boundary: "post-Contract", sourceNodeId: "frontend-contract-pi", targetNodeIds: ["frontend-scout-pi"] },
+    { boundary: "post-Scout", sourceNodeId: "frontend-scout-pi", targetNodeIds: ["frontend-plan-pi"] },
+    { boundary: "post-Plan", sourceNodeId: "frontend-plan-pi", targetNodeIds: ["frontend-design-policy-shell", "frontend-design-review-pi"] },
+    { boundary: "post-Policy", sourceNodeId: "frontend-design-policy-shell", targetNodeIds: ["frontend-writer-admission-shell"] },
+];
+function canonicalFactFields(fact) {
+    return {
+        ...fact,
+        evidenceRefs: [...new Set(fact.evidenceRefs)].sort(),
+    };
+}
+export function computeFrontendShapeNodeDigest(node) {
+    return sha256OfCanonicalJson({
+        status: node.status,
+        stdout: node.stdout ?? "",
+        stderr: node.stderr ?? "",
+        assistantText: node.assistantText ?? "",
+    });
+}
+export function buildCommittedFrontendShapeFact(input) {
+    if (!input.factId || !input.sourceNodeId || !input.taskId) {
+        throw new Error("committed frontend shape fact requires factId, sourceNodeId, and taskId");
+    }
+    if (!/^[a-f0-9]{64}$/.test(input.sourceNodeDigest)) {
+        throw new Error("committed frontend shape fact requires a canonical sourceNodeDigest");
+    }
+    if (input.evidenceRefs.length === 0 || input.evidenceRefs.some((ref) => !ref.trim())) {
+        throw new Error("committed frontend shape fact requires non-empty evidenceRefs");
+    }
+    const runtimeFacts = deriveFrontendRuntimeShapeFacts({
+        requirementMarkdown: input.shapeInput.requirementMarkdown,
+        constraintMarkdown: input.shapeInput.constraintMarkdown,
+        allowedPaths: input.shapeInput.allowedPaths,
+        splitRequired: input.shapeInput.splitSignal.splitRequired,
+    });
+    if (input.runtimeFacts && sha256OfCanonicalJson(input.runtimeFacts) !== sha256OfCanonicalJson(runtimeFacts)) {
+        throw new Error("committed frontend runtime facts do not match runtime recomputation");
+    }
+    const withoutDigest = canonicalFactFields({
+        schemaVersion: 1,
+        factId: input.factId,
+        phase: "committed",
+        sourceNodeId: input.sourceNodeId,
+        sourceNodeDigest: input.sourceNodeDigest,
+        taskId: input.taskId,
+        shapeInput: input.shapeInput,
+        runtimeFacts,
+        evidenceRefs: input.evidenceRefs,
+        committedAt: input.committedAt,
+        ...(input.typedEventBinding ? { typedEventBinding: input.typedEventBinding } : {}),
+    });
+    return {
+        ...withoutDigest,
+        factDigest: sha256OfCanonicalJson(withoutDigest),
+    };
+}
+const runtimeTopologyBindings = new WeakMap();
+export function bindFrontendShapeFactToRunTopology(fact, frozenTopology) {
+    runtimeTopologyBindings.set(fact, frozenTopology);
+}
+export function bindFrontendShapeStateToRunTopology(state) {
+    const shapeState = state.frontendShapeState;
+    if (!shapeState?.frozenTopology)
+        return;
+    for (const fact of Object.values(shapeState.committedFacts)) {
+        if (fact)
+            bindFrontendShapeFactToRunTopology(fact, shapeState.frozenTopology);
+    }
+}
+export function parseCommittedFrontendShapeFact(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("frontend shape fact must be an object");
+    const fact = value;
+    if (fact.schemaVersion !== 1 || fact.phase !== "committed")
+        throw new Error("frontend shape fact is not committed");
+    if (!fact.typedEventBinding ||
+        !fact.typedEventBinding.eventId ||
+        !fact.typedEventBinding.requestId ||
+        !fact.typedEventBinding.attemptId ||
+        !Number.isInteger(fact.typedEventBinding.revision) ||
+        fact.typedEventBinding.revision <= 0 ||
+        !/^[a-f0-9]{64}$/.test(fact.typedEventBinding.payloadSha256)) {
+        throw new Error("frontend shape fact lacks a valid committed typed-event binding");
+    }
+    const rebuilt = buildCommittedFrontendShapeFact(fact);
+    if (fact.factDigest !== rebuilt.factDigest)
+        throw new Error("frontend shape fact digest drifted");
+    return rebuilt;
+}
+export function boundaryForTargetNode(nodeId) {
+    return FRONTEND_SHAPE_BOUNDARIES.find((entry) => entry.targetNodeIds.includes(nodeId));
+}
+function canonicalStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
+}
+function parseFrontendShapeEvidence(evidence) {
+    if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) {
+        throw new Error("frontend shape evidence payload is missing");
+    }
+    const value = evidence;
+    const stringFields = ["sourceNodeId", "sourceNodeDigest", "taskId", "requirementMarkdown", "constraintMarkdown"];
+    for (const field of stringFields) {
+        if (typeof value[field] !== "string" || (field !== "constraintMarkdown" && !value[field].trim())) {
+            throw new Error(`frontend shape evidence requires ${field}`);
+        }
+    }
+    if (!/^[a-f0-9]{64}$/.test(value.sourceNodeDigest))
+        throw new Error("frontend shape evidence source digest is invalid");
+    if (!Array.isArray(value.targetPaths) || value.targetPaths.some((item) => typeof item !== "string"))
+        throw new Error("frontend shape evidence targetPaths are invalid");
+    if (!Array.isArray(value.routes) || value.routes.some((item) => typeof item !== "string"))
+        throw new Error("frontend shape evidence routes are invalid");
+    if (!Array.isArray(value.evidenceRefs) || value.evidenceRefs.length === 0 || value.evidenceRefs.some((item) => typeof item !== "string" || !item.trim()))
+        throw new Error("frontend shape evidence requires evidenceRefs");
+    if (typeof value.splitRequired !== "boolean")
+        throw new Error("frontend shape evidence requires splitRequired");
+    return {
+        sourceNodeId: value.sourceNodeId,
+        sourceNodeDigest: value.sourceNodeDigest,
+        taskId: value.taskId,
+        requirementMarkdown: value.requirementMarkdown,
+        constraintMarkdown: value.constraintMarkdown,
+        targetPaths: canonicalStrings(value.targetPaths),
+        routes: canonicalStrings(value.routes),
+        splitRequired: value.splitRequired,
+        evidenceRefs: canonicalStrings(value.evidenceRefs),
+    };
+}
+function parseShapeEvidenceRecord(record) {
+    if (record.phase !== "committed" || record.fact.kind !== "frontend-shape") {
+        throw new Error("frontend shape evidence must be a committed frontend-shape event");
+    }
+    return parseFrontendShapeEvidence(record.fact.evidence);
+}
+export function isCanonicalFrontendShapeDag(tasksById) {
+    return FRONTEND_SHAPE_BOUNDARIES.some((entry) => tasksById.has(entry.sourceNodeId) && entry.targetNodeIds.some((id) => tasksById.has(id)));
+}
+export async function commitFrontendShapeEvidenceTransaction(input) {
+    const validatedEvidence = parseFrontendShapeEvidence(input.evidence);
+    const mapping = FRONTEND_SHAPE_BOUNDARIES.find((entry) => entry.sourceNodeId === validatedEvidence.sourceNodeId);
+    if (!mapping || !input.state.frontendShapeState)
+        throw new Error("frontend shape evidence source is not a canonical enabled boundary");
+    const frozenTopology = input.state.frontendShapeState.frozenTopology;
+    const node = input.state.nodes[validatedEvidence.sourceNodeId];
+    if (!node || node.status !== "FINISHED")
+        throw new Error("frontend shape evidence source is not finished");
+    if (computeFrontendShapeNodeDigest(node) !== validatedEvidence.sourceNodeDigest)
+        throw new Error("frontend shape evidence source digest drifted before commit");
+    const staged = stageTypedEventFact({
+        store: input.store,
+        requestId: input.requestId,
+        attemptId: input.attemptId,
+        eventId: input.eventId,
+        fact: { kind: "frontend-shape", evidence: input.evidence },
+    });
+    const adopted = await adoptTypedEventFact({
+        store: input.store,
+        requestId: input.requestId,
+        attemptId: input.attemptId,
+        eventId: staged.eventId,
+        fact: { kind: "frontend-shape", evidence: input.evidence },
+        expectedRevision: input.expectedStoreRevision,
+    });
+    const [record] = readCommittedEvents(input.store, input.attemptId).filter((candidate) => candidate.eventId === adopted.eventId);
+    if (!record)
+        throw new Error("committed frontend shape evidence is not readable after adoption");
+    const evidence = parseShapeEvidenceRecord(record);
+    const shapeInput = {
+        allowedPaths: evidence.targetPaths,
+        requirementMarkdown: [evidence.requirementMarkdown, ...evidence.routes.map((route) => `runtime-route:${route}`)].join("\n"),
+        constraintMarkdown: evidence.constraintMarkdown,
+        splitSignal: { splitRequired: evidence.splitRequired, runtimeSupportsSplit: true },
+    };
+    const nextRevision = input.state.frontendShapeState.revision + 1;
+    const fact = buildCommittedFrontendShapeFact({
+        factId: `${input.state.runId}:${mapping.boundary}:${nextRevision}`,
+        sourceNodeId: evidence.sourceNodeId,
+        sourceNodeDigest: evidence.sourceNodeDigest,
+        taskId: evidence.taskId,
+        shapeInput,
+        evidenceRefs: evidence.evidenceRefs,
+        committedAt: record.recordedAt,
+        typedEventBinding: {
+            eventId: record.eventId,
+            requestId: record.requestId,
+            attemptId: record.attemptId,
+            payloadSha256: record.payloadSha256,
+            revision: record.revision,
+        },
+    });
+    if (frozenTopology)
+        bindFrontendShapeFactToRunTopology(fact, frozenTopology);
+    const outcome = evaluateFrontendShapeBoundary({
+        boundary: mapping.boundary,
+        sourceNode: { status: node.status, digest: evidence.sourceNodeDigest },
+        fact,
+        frozenTopology,
+    });
+    input.state.frontendShapeState.committedFacts[mapping.boundary] = fact;
+    input.state.frontendShapeState.revision = nextRevision;
+    return { fact, outcome };
+}
+function extractRuntimeShapeEvidence(input) {
+    const node = input.state.nodes[input.sourceNodeId];
+    const text = `${node.stdout ?? ""}\n${node.assistantText ?? ""}`;
+    const targetPaths = canonicalStrings([
+        ...(text.match(/(?:[A-Za-z0-9_.-]+\/)+(?:[A-Za-z0-9_.-]+|\*\*)/g) ?? []),
+    ]);
+    const routes = canonicalStrings(text.match(/\/(?:[A-Za-z0-9_:[\]-]+\/?)+/g) ?? []);
+    const splitRequired = /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
+    return {
+        sourceNodeId: input.sourceNodeId,
+        sourceNodeDigest: computeFrontendShapeNodeDigest(node),
+        taskId: input.taskId,
+        requirementMarkdown: [input.requirementMarkdown, text].filter(Boolean).join("\n"),
+        constraintMarkdown: input.constraintMarkdown ?? "",
+        targetPaths,
+        routes,
+        splitRequired,
+        evidenceRefs: [`node:${input.sourceNodeId}:stdout`],
+    };
+}
+/** Commit a typed, structured runtime fact immediately after a canonical source
+ * finishes. The scheduler later invokes the same evaluator and re-hashes the
+ * source record, so adoption is not a freshness shortcut. */
+export async function commitRuntimeFrontendShapeFact(input) {
+    const mapping = FRONTEND_SHAPE_BOUNDARIES.find((entry) => entry.sourceNodeId === input.sourceNodeId);
+    if (!mapping || !input.state.frontendShapeState)
+        return undefined;
+    const node = input.state.nodes[input.sourceNodeId];
+    if (!node || node.status !== "FINISHED")
+        return undefined;
+    const store = createTypedEventStore();
+    const committed = await commitFrontendShapeEvidenceTransaction({
+        state: input.state,
+        tasksById: input.tasksById,
+        store,
+        requestId: `${input.state.runId}:${mapping.boundary}`,
+        attemptId: `${input.state.runId}:${input.sourceNodeId}`,
+        eventId: `${input.state.runId}:${mapping.boundary}:shape-evidence`,
+        expectedStoreRevision: 0,
+        evidence: extractRuntimeShapeEvidence(input),
+    });
+    return committed.fact;
+}
+export function evaluateFrontendShapeBoundary(input) {
+    const mapping = FRONTEND_SHAPE_BOUNDARIES.find((entry) => entry.boundary === input.boundary);
+    if (!input.sourceNode || input.sourceNode.status !== "FINISHED") {
+        return { kind: "blocked", reason: `frontend-shape-source-not-finished:${mapping.sourceNodeId}` };
+    }
+    let fact;
+    try {
+        fact = parseCommittedFrontendShapeFact(input.fact);
+    }
+    catch (error) {
+        return { kind: "blocked", reason: `frontend-shape-fact-invalid:${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (fact.sourceNodeId !== mapping.sourceNodeId) {
+        return { kind: "blocked", reason: "frontend-shape-source-binding-mismatch" };
+    }
+    if (fact.sourceNodeDigest !== input.sourceNode.digest) {
+        return { kind: "blocked", reason: "frontend-shape-source-digest-drift" };
+    }
+    const frozenTopology = input.frozenTopology ?? (typeof input.fact === "object" && input.fact !== null
+        ? runtimeTopologyBindings.get(input.fact)
+        : undefined);
+    if (!frozenTopology) {
+        return { kind: "blocked", reason: "frontend-shape-current-topology-missing" };
+    }
+    const escalation = evaluateFrontendShapeEscalation({
+        ...fact.runtimeFacts,
+        currentTopologyCapability: frozenTopology.capability,
+    });
+    return { kind: escalation.outcome, reason: escalation.reason };
+}
+function downstreamPendingIds(tasksById, sourceNodeId, state) {
+    const downstream = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const task of tasksById.values()) {
+            if (downstream.has(task.id))
+                continue;
+            if (task.depends_on.includes(sourceNodeId) || task.depends_on.some((id) => downstream.has(id))) {
+                downstream.add(task.id);
+                changed = true;
+            }
+        }
+    }
+    return [...downstream].filter((id) => state.nodes[id]?.status === "PENDING");
+}
+function buildTransitionCapsule(state, request, taskSourceDigest) {
+    const frozenTopology = state.frontendShapeState?.frozenTopology;
+    if (!frozenTopology)
+        throw new Error("frontend shape transition requires current frozen topology");
+    const common = {
+        schemaVersion: 1,
+        taskId: request.fact.taskId,
+        parentRunId: state.runId,
+        sourceDigest: taskSourceDigest,
+        fromShapeDigest: frozenTopology.canonicalDigest,
+        shapeFactsDigest: request.fact.factDigest,
+        committedFactIds: [request.fact.factId],
+        evidenceRefs: request.fact.evidenceRefs,
+        committedAt: request.fact.committedAt,
+    };
+    const capsule = request.outcome === "split-required"
+        ? buildFrontendShapeTransitionCapsule({
+            ...common,
+            kind: "split",
+            splitProposalRef: request.fact.evidenceRefs[0],
+            splitProposalDigest: sha256OfCanonicalJson(request.fact.evidenceRefs),
+            requirementCoverageDigest: sha256OfCanonicalJson(request.fact.shapeInput.requirementMarkdown ?? ""),
+        })
+        : buildFrontendShapeTransitionCapsule({
+            ...common,
+            kind: "reshape",
+            requestedMinimumSize: "standard",
+            requestedMinimumRisk: "high",
+            escalationSignals: request.fact.runtimeFacts.escalationSignals,
+        });
+    return parseFrontendShapeTransitionCapsule(capsule);
+}
+export async function commitFrontendShapeTransitionCas(input) {
+    const current = input.state.frontendShapeState;
+    if (current?.transitionCapsule) {
+        let capsule;
+        let expected;
+        try {
+            capsule = parseFrontendShapeTransitionCapsule(current.transitionCapsule);
+            expected = buildTransitionCapsule(input.state, input.request, input.taskSourceDigest);
+        }
+        catch (error) {
+            return { ok: false, reason: `frontend-shape-capsule-invalid:${error instanceof Error ? error.message : String(error)}` };
+        }
+        if (input.state.status !== "failed" ||
+            current.terminalOutcome !== input.request.outcome ||
+            current.lastBoundary !== input.request.boundary ||
+            current.transitionCommittedAt !== capsule.committedAt ||
+            capsule.taskId !== input.request.fact.taskId ||
+            capsule.parentRunId !== input.state.runId ||
+            capsule.sourceDigest !== input.taskSourceDigest ||
+            capsule.shapeFactsDigest !== input.request.fact.factDigest ||
+            capsule.capsuleDigest !== expected.capsuleDigest) {
+            return { ok: false, reason: "frontend-shape-terminal-transition-conflict" };
+        }
+        try {
+            await input.ensureRecord(capsule, input.request.outcome);
+        }
+        catch (error) {
+            return { ok: false, reason: `frontend-shape-record-write-failed:${error instanceof Error ? error.message : String(error)}` };
+        }
+        return { ok: true, idempotent: true, capsule };
+    }
+    if (!current || current.revision !== input.request.expectedRevision) {
+        return { ok: false, reason: "frontend-shape-revision-conflict" };
+    }
+    if (["finished", "partial_failed", "failed", "superseded", "abandoned"].includes(input.state.status)) {
+        return { ok: false, reason: "frontend-shape-run-already-terminal" };
+    }
+    let capsule;
+    try {
+        capsule = buildTransitionCapsule(input.state, input.request, input.taskSourceDigest);
+    }
+    catch (error) {
+        return { ok: false, reason: `frontend-shape-capsule-invalid:${error instanceof Error ? error.message : String(error)}` };
+    }
+    try {
+        await input.ensureRecord(capsule, input.request.outcome);
+    }
+    catch (error) {
+        return { ok: false, reason: `frontend-shape-record-write-failed:${error instanceof Error ? error.message : String(error)}` };
+    }
+    const next = structuredClone(input.state);
+    const committedAt = capsule.committedAt;
+    next.status = "failed";
+    next.finishedAt = committedAt;
+    next.terminalReason = `frontend shape ${input.request.outcome} at ${input.request.boundary}: ${input.request.reason}`;
+    next.frontendShapeState = {
+        ...next.frontendShapeState,
+        revision: input.request.expectedRevision + 1,
+        lastBoundary: input.request.boundary,
+        lastOutcome: input.request.outcome,
+        terminalOutcome: input.request.outcome,
+        transitionCapsule: capsule,
+        transitionCommittedAt: committedAt,
+    };
+    for (const nodeId of downstreamPendingIds(input.tasksById, input.request.fact.sourceNodeId, next)) {
+        const node = next.nodes[nodeId];
+        node.status = "SKIPPED";
+        node.skippedReason = `frontend-shape-${input.request.outcome}`;
+        node.finishedAt = committedAt;
+    }
+    try {
+        await input.persist(next);
+    }
+    catch (error) {
+        return { ok: false, reason: `frontend-shape-state-write-failed:${error instanceof Error ? error.message : String(error)}` };
+    }
+    for (const key of Object.keys(input.state))
+        delete input.state[key];
+    Object.assign(input.state, next);
+    return { ok: true, idempotent: false, capsule };
+}