@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.3

package/dist/workflows/dag/frontend-human-decision.js

@@ -0,0 +1,182 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+const id = z.string().trim().min(1);
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const revision = z.number().int().positive();
+const instant = z.string().datetime();
+const factRef = z.object({ ref: id, digest }).strict();
+function canonicalValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonicalValue(item)]));
+    return value;
+}
+export function canonicalFrontendHumanDecisionJson(value) {
+    return JSON.stringify(canonicalValue(value));
+}
+export function computeFrontendHumanDecisionDigest(value) {
+    return createHash("sha256").update(canonicalFrontendHumanDecisionJson(value), "utf8").digest("hex");
+}
+const baseEnvelope = {
+    operationId: id,
+    runId: id,
+    operationRevision: revision,
+    targetDigest: digest,
+    staleOnTargetDigestChange: z.literal(true),
+    expiresAt: instant.optional(),
+};
+const contractEnvelopeInput = z.object({ ...baseEnvelope, kind: z.literal("contract-decision"), resumeAction: z.literal("resume-contract"), payload: z.object({ questionFactIds: z.array(id).min(1) }).strict() }).strict();
+const highEnvelopeInput = z.object({ ...baseEnvelope, kind: z.literal("high-admission"), resumeAction: z.literal("admit-high"), payload: z.object({ admissionCandidateRef: factRef }).strict() }).strict();
+const splitEnvelopeInput = z.object({ ...baseEnvelope, kind: z.literal("split-materialization-approval"), resumeAction: z.literal("materialize-split"), payload: z.object({ splitManifestRef: factRef }).strict() }).strict();
+const baselineEnvelopeInput = z.object({ ...baseEnvelope, kind: z.literal("baseline-debt-acceptance"), resumeAction: z.literal("accept-baseline-debt"), payload: z.object({ baselineEvidenceRefs: z.array(factRef).min(1), candidateDigest: digest, commandDigest: digest, resultingPolicy: z.literal("allow-non-regression") }).strict() }).strict();
+const verificationEnvelopeInput = z.object({ ...baseEnvelope, kind: z.literal("verification-config"), resumeAction: z.literal("select-verification-config"), payload: z.object({ unresolvedEntrypointRefs: z.array(factRef).min(1), allowlistedResolvers: z.array(id).min(1) }).strict() }).strict();
+export const frontendHumanDecisionEnvelopeInputSchema = z.discriminatedUnion("kind", [contractEnvelopeInput, highEnvelopeInput, splitEnvelopeInput, baselineEnvelopeInput, verificationEnvelopeInput]);
+const envelopeSchemas = [contractEnvelopeInput.extend({ digest }).strict(), highEnvelopeInput.extend({ digest }).strict(), splitEnvelopeInput.extend({ digest }).strict(), baselineEnvelopeInput.extend({ digest }).strict(), verificationEnvelopeInput.extend({ digest }).strict()];
+const envelopeStructuralSchema = z.discriminatedUnion("kind", envelopeSchemas);
+export const frontendHumanDecisionEnvelopeSchema = envelopeStructuralSchema.superRefine((value, ctx) => {
+    const { digest: actual, ...payload } = value;
+    if (computeFrontendHumanDecisionDigest(payload) !== actual)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "envelope digest mismatch" });
+});
+export function buildFrontendHumanDecisionEnvelope(raw) {
+    const payload = frontendHumanDecisionEnvelopeInputSchema.parse(raw);
+    return envelopeStructuralSchema.parse({ ...payload, digest: computeFrontendHumanDecisionDigest(payload) });
+}
+export function parseFrontendHumanDecisionEnvelope(value) { return frontendHumanDecisionEnvelopeSchema.parse(value); }
+const receiptBase = { operationId: id, runId: id, operationRevision: revision, targetDigest: digest, receiptId: id, envelopeDigest: digest, commitState: z.literal("committed"), consumeState: z.enum(["unconsumed", "consumed"]) };
+const resolutionFact = { resolutionFactRef: factRef };
+const contractReceiptInput = z.object({ ...receiptBase, kind: z.literal("contract-decision"), resumeAction: z.literal("resume-contract"), resolution: z.object({ questionFactIds: z.array(id).min(1), outcome: z.literal("resume-contract"), ...resolutionFact }).strict() }).strict();
+const highReceiptInput = z.object({ ...receiptBase, kind: z.literal("high-admission"), resumeAction: z.literal("admit-high"), resolution: z.object({ admissionCandidateRef: factRef, outcome: z.literal("admitted-high"), ...resolutionFact }).strict() }).strict();
+const splitReceiptInput = z.object({ ...receiptBase, kind: z.literal("split-materialization-approval"), resumeAction: z.literal("materialize-split"), resolution: z.object({ splitManifestRef: factRef, ...resolutionFact }).strict() }).strict();
+const baselineReceiptInput = z.object({ ...receiptBase, kind: z.literal("baseline-debt-acceptance"), resumeAction: z.literal("accept-baseline-debt"), resolution: z.object({ baselineEvidenceRefs: z.array(factRef).min(1), candidateDigest: digest, commandDigest: digest, resultingPolicy: z.literal("allow-non-regression"), outcome: z.literal("accepted-baseline-debt"), remediated: z.literal(false), ...resolutionFact }).strict() }).strict();
+const verificationReceiptInput = z.object({ ...receiptBase, kind: z.literal("verification-config"), resumeAction: z.literal("select-verification-config"), resolution: z.object({ entrypointRef: factRef, resolver: id, sourceDigest: digest, commandDigest: digest, ...resolutionFact }).strict() }).strict();
+export const frontendHumanDecisionReceiptInputSchema = z.discriminatedUnion("kind", [contractReceiptInput, highReceiptInput, splitReceiptInput, baselineReceiptInput, verificationReceiptInput]);
+const receiptStructuralSchema = z.discriminatedUnion("kind", [contractReceiptInput.extend({ digest }).strict(), highReceiptInput.extend({ digest }).strict(), splitReceiptInput.extend({ digest }).strict(), baselineReceiptInput.extend({ digest }).strict(), verificationReceiptInput.extend({ digest }).strict()]);
+export const frontendHumanDecisionReceiptSchema = receiptStructuralSchema.superRefine((value, ctx) => {
+    const { digest: actual, ...payload } = value;
+    if (computeFrontendHumanDecisionDigest(payload) !== actual)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "receipt digest mismatch" });
+});
+export function buildFrontendHumanDecisionReceipt(raw) {
+    const payload = frontendHumanDecisionReceiptInputSchema.parse(raw);
+    return receiptStructuralSchema.parse({ ...payload, digest: computeFrontendHumanDecisionDigest(payload) });
+}
+export function parseFrontendHumanDecisionReceipt(value) { return frontendHumanDecisionReceiptSchema.parse(value); }
+const activeInput = z.object({ status: z.literal("active"), operationId: id, runId: id, revision }).strict();
+const blockedInput = z.object({ status: z.literal("blocked-human"), operationId: id, runId: id, revision, envelope: frontendHumanDecisionEnvelopeSchema }).strict();
+const resolvedInput = z.object({ status: z.literal("resolved"), operationId: id, runId: id, revision, receipt: frontendHumanDecisionReceiptSchema }).strict();
+export const frontendHumanDecisionProjectionInputSchema = z.discriminatedUnion("status", [activeInput, blockedInput, resolvedInput]);
+const projectionStructuralSchema = z.discriminatedUnion("status", [activeInput.extend({ digest }).strict(), blockedInput.extend({ digest }).strict(), resolvedInput.extend({ digest }).strict()]);
+export const frontendHumanDecisionProjectionSchema = projectionStructuralSchema.superRefine((value, ctx) => { const { digest: actual, ...payload } = value; if (computeFrontendHumanDecisionDigest(payload) !== actual)
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "projection digest mismatch" }); });
+export function buildFrontendHumanDecisionProjection(raw) { const payload = frontendHumanDecisionProjectionInputSchema.parse(raw); return projectionStructuralSchema.parse({ ...payload, digest: computeFrontendHumanDecisionDigest(payload) }); }
+export function parseFrontendHumanDecisionProjection(value) { return frontendHumanDecisionProjectionSchema.parse(value); }
+const reject = (projection, reason) => ({ outcome: "rejected", reason, projection });
+export function materializeFrontendHumanDecision(input) {
+    const projection = parseFrontendHumanDecisionProjection(input.projection);
+    const envelope = parseFrontendHumanDecisionEnvelope(input.envelope);
+    if (projection.status !== "active")
+        return reject(projection, "projection is not active");
+    if (projection.revision !== input.expectedRecordRevision || projection.digest !== input.expectedProjectionDigest)
+        return reject(projection, "revision or projection digest conflict");
+    if (envelope.operationId !== projection.operationId || envelope.runId !== projection.runId || envelope.operationRevision !== projection.revision)
+        return reject(projection, "envelope binding mismatch");
+    return { outcome: "applied", projection: buildFrontendHumanDecisionProjection({ status: "blocked-human", operationId: projection.operationId, runId: projection.runId, revision: projection.revision + 1, envelope }) };
+}
+function receiptMatchesEnvelope(receipt, envelope) {
+    if (receipt.kind !== envelope.kind || receipt.resumeAction !== envelope.resumeAction || receipt.operationId !== envelope.operationId || receipt.runId !== envelope.runId || receipt.operationRevision !== envelope.operationRevision || receipt.targetDigest !== envelope.targetDigest || receipt.envelopeDigest !== envelope.digest)
+        return false;
+    switch (envelope.kind) {
+        case "contract-decision": return receipt.kind === envelope.kind && canonicalFrontendHumanDecisionJson(receipt.resolution.questionFactIds) === canonicalFrontendHumanDecisionJson(envelope.payload.questionFactIds);
+        case "high-admission": return receipt.kind === envelope.kind && canonicalFrontendHumanDecisionJson(receipt.resolution.admissionCandidateRef) === canonicalFrontendHumanDecisionJson(envelope.payload.admissionCandidateRef);
+        case "split-materialization-approval": return receipt.kind === envelope.kind && canonicalFrontendHumanDecisionJson(receipt.resolution.splitManifestRef) === canonicalFrontendHumanDecisionJson(envelope.payload.splitManifestRef);
+        case "baseline-debt-acceptance": return receipt.kind === envelope.kind && receipt.resolution.candidateDigest === envelope.payload.candidateDigest && receipt.resolution.commandDigest === envelope.payload.commandDigest && canonicalFrontendHumanDecisionJson(receipt.resolution.baselineEvidenceRefs) === canonicalFrontendHumanDecisionJson(envelope.payload.baselineEvidenceRefs);
+        case "verification-config": return receipt.kind === envelope.kind && envelope.payload.allowlistedResolvers.includes(receipt.resolution.resolver) && envelope.payload.unresolvedEntrypointRefs.some((item) => canonicalFrontendHumanDecisionJson(item) === canonicalFrontendHumanDecisionJson(receipt.resolution.entrypointRef));
+    }
+}
+export function consumeFrontendHumanDecision(input) {
+    const projection = parseFrontendHumanDecisionProjection(input.projection);
+    if (projection.status !== "blocked-human")
+        return reject(projection, "projection has no pending envelope");
+    const consumeInput = z.object({ expectedRecordRevision: revision, expectedProjectionDigest: digest, currentTargetDigest: digest, now: instant }).strict().safeParse({
+        expectedRecordRevision: input.expectedRecordRevision,
+        expectedProjectionDigest: input.expectedProjectionDigest,
+        currentTargetDigest: input.currentTargetDigest,
+        now: input.now,
+    });
+    if (!consumeInput.success)
+        return reject(projection, "invalid consume input");
+    const receipt = parseFrontendHumanDecisionReceipt(input.receipt);
+    if (projection.revision !== input.expectedRecordRevision || projection.digest !== input.expectedProjectionDigest)
+        return reject(projection, "revision or projection digest conflict");
+    if (input.currentTargetDigest !== projection.envelope.targetDigest) {
+        const payload = { kind: "frontend-human-decision-stale", operationId: projection.operationId, envelopeDigest: projection.envelope.digest, previousTargetDigest: projection.envelope.targetDigest, currentTargetDigest: input.currentTargetDigest };
+        return { outcome: "stale", reason: "target digest changed", projection, auditFact: { ...payload, digest: computeFrontendHumanDecisionDigest(payload) } };
+    }
+    if (projection.envelope.expiresAt && Date.parse(input.now) >= Date.parse(projection.envelope.expiresAt))
+        return reject(projection, "envelope expired");
+    if (receipt.commitState !== "committed" || receipt.consumeState !== "unconsumed" || !receiptMatchesEnvelope(receipt, projection.envelope))
+        return reject(projection, "receipt freshness or payload mismatch");
+    const { digest: _digest, ...receiptPayload } = receipt;
+    const consumed = buildFrontendHumanDecisionReceipt({ ...receiptPayload, consumeState: "consumed" });
+    return { outcome: "applied", projection: buildFrontendHumanDecisionProjection({ status: "resolved", operationId: projection.operationId, runId: projection.runId, revision: projection.revision + 1, receipt: consumed }) };
+}
+/* ------------------------------------------------------------------ *
+ * A+B producer/consumer wiring (no new envelope schema in the frozen  *
+ * five-kind union).                                                    *
+ * ------------------------------------------------------------------ */
+/**
+ * A+B (AC-002): contract `blocked` uniquely maps to `blocked-human`
+ * (contract-decision envelope) or `blocked-external` (wait-external), reusing
+ * the existing five-envelope schema without widening it. Any other disposition
+ * is `not-blocked`.
+ */
+export function mapContractBlockedOwner(input) {
+    if (input.disposition !== "blocked")
+        return "not-blocked";
+    return input.blockingOwner === "blocked-external"
+        ? "blocked-external"
+        : "blocked-human";
+}
+/**
+ * A+B (AC-007): High-topology `high-admission-receipt`. The receipt is a
+ * runtime-materialized catalog (not a sixth human-decision envelope): a receipt
+ * whose candidate digest matches the admission digest resolves to `accepted`;
+ * any digest drift resolves to `stale`.
+ */
+export const highAdmissionReceiptSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal("high-admission-receipt-v1"),
+    candidateDigest: digest,
+    admissionDigest: digest,
+    status: z.enum(["accepted", "stale"]),
+})
+    .strict();
+export function evaluateHighAdmissionReceipt(input) {
+    return highAdmissionReceiptSchema.parse({
+        schemaVersion: 1,
+        schemaId: "high-admission-receipt-v1",
+        candidateDigest: input.candidateDigest,
+        admissionDigest: input.admissionDigest,
+        status: input.candidateDigest === input.admissionDigest
+            ? "accepted"
+            : "stale",
+    });
+}
+/**
+ * A+B (AC-008): verification-config routing. A verification-config signal
+ * either restarts the contract or produces a verification-config-decision
+ * (independent of the frozen `verification-config` envelope). Fail-closed to
+ * contract restart when the signal is untyped.
+ */
+export function routeVerificationConfig(input) {
+    const entrypointRefs = [...new Set(input.unresolvedEntrypointRefs)].filter((item) => item.length > 0);
+    return {
+        decision: entrypointRefs.length > 0
+            ? "verification-config-decision"
+            : "contract-restart",
+        entrypointRefs,
+    };
+}