@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.11

package/dist/workflows/dag/failure-category.js

@@ -1,118 +1,9 @@
 import { z } from "zod";
-export const dagNormalizedFailureCategorySchema = z.enum([
-    "success",
-    "validation",
-    "executor",
-    "write-guard",
-    "timeout",
-    "auth",
-    "human-required",
-    "human-rejected",
-    "shell-command",
-    "static-error",
-    "decision-envelope",
-    "skipped",
-    "unknown",
-]);
+import { DAG_NORMALIZED_FAILURE_CATEGORY_VALUES } from "../../shared/dag-failure-category.js";
+// The pure classification core lives in src/shared/dag-failure-category.ts so
+// the Operator Console projection can normalize raw CLI categories without
+// importing the workflows kernel (console/workflows boundary test). This
+// module keeps the schema surface for the DAG kernel's existing consumers.
+export { isDagFailureCategory, normalizeDagFailureCategory, } from "../../shared/dag-failure-category.js";
+export const dagNormalizedFailureCategorySchema = z.enum(DAG_NORMALIZED_FAILURE_CATEGORY_VALUES);
 export const DAG_NORMALIZED_FAILURE_CATEGORIES = dagNormalizedFailureCategorySchema.options;
-const RAW_TO_NORMALIZED = {
-    success: "success",
-    "write-guard": "write-guard",
-    timeout: "timeout",
-    // Clean implementer stall with zero writes — still a timeout class for report,
-    // but retryable under WRITER_TRANSPORT_RETRY_POLICY.
-    "writer-clean-timeout": "timeout",
-    "missing-api-key": "auth",
-    auth: "auth",
-    "human-rejected": "human-rejected",
-    "human-required": "human-required",
-    "decision-envelope-invalid": "decision-envelope",
-    "nonzero-exit": "shell-command",
-    "spawn-error": "shell-command",
-    "static-error": "static-error",
-    "invalid-output": "validation",
-    "path-violation": "validation",
-    "empty-output": "validation",
-    "verify-failure": "validation",
-    "test-failure": "validation",
-    "verification-plan-stale": "validation",
-    network: "executor",
-    quota: "executor",
-    "rate-limit": "executor",
-    unavailable: "executor",
-    unknown: "unknown",
-};
-function isFinishedStatus(status) {
-    return status === "FINISHED" || status === "finished";
-}
-function isInProgressStatus(status) {
-    return (status === "PENDING" ||
-        status === "RUNNING" ||
-        status === "pending" ||
-        status === "running");
-}
-function isFailureStatus(status) {
-    return (status === "ERROR" ||
-        status === "failed" ||
-        status === "partial_failed");
-}
-function mapRawCategory(raw) {
-    const direct = RAW_TO_NORMALIZED[raw];
-    if (direct)
-        return direct;
-    const lower = raw.toLowerCase();
-    if (lower.includes("timeout"))
-        return "timeout";
-    if (lower.includes("validation") ||
-        lower.includes("invalid") ||
-        lower.includes("verification-plan-stale") ||
-        lower.includes("plan-stale"))
-        return "validation";
-    if (lower.includes("auth") || lower.includes("api-key"))
-        return "auth";
-    if (lower.includes("write-guard") || lower.includes("write_guard"))
-        return "write-guard";
-    if (lower.includes("decision-envelope") || lower.includes("decision_envelope"))
-        return "decision-envelope";
-    if (lower.includes("human-rejected"))
-        return "human-rejected";
-    if (lower.includes("human-required"))
-        return "human-required";
-    if (lower.includes("static-error"))
-        return "static-error";
-    if (lower.includes("nonzero-exit") ||
-        lower.includes("spawn-error") ||
-        lower.includes("shell"))
-        return "shell-command";
-    return undefined;
-}
-export function isDagFailureCategory(value) {
-    return DAG_NORMALIZED_FAILURE_CATEGORIES.includes(value);
-}
-export function normalizeDagFailureCategory(raw, status) {
-    if (status === "SKIPPED") {
-        return "skipped";
-    }
-    if (raw !== undefined) {
-        const mapped = mapRawCategory(raw);
-        if (mapped) {
-            if (mapped === "success") {
-                return isFinishedStatus(status) ? "success" : "unknown";
-            }
-            return mapped;
-        }
-    }
-    if (raw === undefined && isFinishedStatus(status)) {
-        return "success";
-    }
-    if (isInProgressStatus(status)) {
-        return "unknown";
-    }
-    if (isFailureStatus(status)) {
-        return "unknown";
-    }
-    if (raw === "success" && isFinishedStatus(status)) {
-        return "success";
-    }
-    return "unknown";
-}

package/dist/workflows/dag/frontend-closeout.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+export { buildFrontendShapeTransitionCapsule, computeFrontendShapeSourceDigest, evaluateFrontendShapeEscalation, FRONTEND_SHAPE_NODE_COUNTS, frontendShapeTransitionCapsuleSchema, frontendShapeTransitionReshapeCapsuleSchema, frontendShapeTransitionSplitCapsuleSchema, parseFrontendShapeTransitionCapsule, resolveFrontendTaskShape, } from "./frontend-shape.js";
+/**
+ * Deterministic frontend closeout facts + renderer (M7).
+ *
+ * The functions here are pure (no I/O, no model, no side effects). The closeout
+ * renderer reads only committed facts, never model summaries or node prose, so
+ * a weak conclusion (failed / not-run / baseline-debt / mock-backed / pending)
+ * can never be rewritten into a stronger one (passed / real-integrated).
+ *
+ * Canonical shape routing and transition capsules live in `frontend-shape.ts`
+ * and are re-exported here for callers that also consume closeout contracts.
+ */
+export const FRONTEND_CLOSEOUT_FACTS_SCHEMA_ID = "frontend-closeout-facts-v1";
+/* ------------------------------------------------------------------ *
+ * Enums + facts schema                                                 *
+ * ------------------------------------------------------------------ */
+export const frontendCoverageStatusSchema = z.enum([
+    "passed",
+    "failed",
+    "not-run",
+    "blocked",
+    "unavailable",
+]);
+export const frontendLintStatusSchema = z.enum([
+    "passed",
+    "baseline-debt",
+    "failed",
+    "unavailable",
+]);
+export const frontendIntegrationFactsSchema = z.enum([
+    "real-api",
+    "mock-backed",
+    "local-no-remote",
+    "unavailable",
+]);
+export const frontendCloseoutFactsSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_CLOSEOUT_FACTS_SCHEMA_ID),
+    coverageMatrix: z.array(z
+        .object({
+        verificationTargetId: z.string().min(1),
+        status: frontendCoverageStatusSchema,
+    })
+        .strict()),
+    lintStatus: frontendLintStatusSchema,
+    integrationFacts: frontendIntegrationFactsSchema,
+    reviewApproval: z
+        .object({
+        typedVerdict: z
+            .enum(["approve_review", "request_review_changes"])
+            .nullable(),
+        legacyVerdict: z.enum(["pass", "request-revision"]).nullable(),
+        match: z.boolean(),
+    })
+        .strict(),
+    cumulativeDiff: z
+        .object({
+        cumulativeDigest: z.string().min(1),
+        empty: z.boolean(),
+    })
+        .strict(),
+    notRun: z
+        .object({
+        browser: z.literal("not-run"),
+        visual: z.literal("not-run"),
+    })
+        .strict(),
+    pendingRealIntegration: z.boolean(),
+    residualRisks: z.array(z.string().min(1)).optional(),
+    evidenceGaps: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+/* ------------------------------------------------------------------ *
+ * FrontendTestHandoff (A+B AC-010)                                   *
+ * ------------------------------------------------------------------ */
+export const FRONTEND_TEST_HANDOFF_SCHEMA_ID = "frontend-test-handoff-v1";
+/**
+ * A+B (AC-010): deterministic frontend-test handoff. Bound to the task id,
+ * source digest, and candidate hash; browser/visual/runtime-a11y are always
+ * `not-run` and the handoff is always `deferred-to-frontend-test`, so a weak
+ * closeout can never block implementation and can never be rewritten as
+ * passed.
+ */
+export const frontendTestHandoffSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_TEST_HANDOFF_SCHEMA_ID),
+    taskId: z.string().min(1),
+    sourceDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    candidateHash: z.string().regex(/^[a-f0-9]{64}$/),
+    executionStatus: z.literal("not-run"),
+    handoffStatus: z.literal("deferred-to-frontend-test"),
+    nonBlocking: z.literal(true),
+})
+    .strict();
+export function buildFrontendTestHandoff(input) {
+    return frontendTestHandoffSchema.parse({
+        schemaVersion: 1,
+        schemaId: FRONTEND_TEST_HANDOFF_SCHEMA_ID,
+        taskId: input.taskId,
+        sourceDigest: input.sourceDigest,
+        candidateHash: input.candidateHash,
+        executionStatus: "not-run",
+        handoffStatus: "deferred-to-frontend-test",
+        nonBlocking: true,
+    });
+}
+/**
+ * Deterministic, fail-closed mapping from structured evidence to integration
+ * facts. Never reads model text. `real-api` is the only value that may report
+ * real integration, and it requires both real passed evidence and satisfied
+ * required verification evidence. Anything else downgrades to pending.
+ */
+export function deriveFrontendIntegrationFacts(input) {
+    const requiredEvidenceSatisfied = input.verificationTargets.length > 0 &&
+        input.verificationTargets.every((target) => target.status === "ok");
+    if (input.realApiEvidence.present &&
+        input.realApiEvidence.passed &&
+        requiredEvidenceSatisfied) {
+        return "real-api";
+    }
+    // Required evidence not satisfied → never report real-integrated or
+    // mock/locally-validated; evidence is unavailable.
+    if (!requiredEvidenceSatisfied) {
+        return "unavailable";
+    }
+    if (input.mockStrategy !== "not-needed" && input.mockEvidenceBound) {
+        return "mock-backed";
+    }
+    if (input.mockStrategy === "not-needed" && !input.realApiEvidence.present) {
+        return "local-no-remote";
+    }
+    return "unavailable";
+}
+/* ------------------------------------------------------------------ *
+ * Deterministic closeout renderer                                     *
+ * ------------------------------------------------------------------ */
+function bulletList(items) {
+    if (!items || items.length === 0)
+        return "";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function coverageLines(facts) {
+    const lines = facts.coverageMatrix.map((entry) => `- ${entry.verificationTargetId}: ${entry.status}`);
+    return lines.length > 0 ? lines.join("\n") : "_(none)_";
+}
+function frontendStatus(facts) {
+    switch (facts.integrationFacts) {
+        case "real-api":
+            return "Frontend status: real-integrated";
+        case "mock-backed":
+            return "Frontend status: mock-validated";
+        case "local-no-remote":
+            return "Frontend status: locally-validated";
+        case "unavailable":
+            return "Frontend status: unverified";
+    }
+}
+function integrationStatus(facts) {
+    return facts.integrationFacts === "real-api"
+        ? "Real integration: validated"
+        : `Real integration: pending (${facts.integrationFacts})`;
+}
+function reviewApprovalLines(facts) {
+    const { typedVerdict, legacyVerdict, match } = facts.reviewApproval;
+    return [
+        `typed: ${typedVerdict ?? "none"}`,
+        `legacy: ${legacyVerdict ?? "none"}`,
+        `match: ${match}`,
+    ].join("\n");
+}
+/**
+ * Render a deterministic closeout Markdown document from committed facts only.
+ * The same facts always render byte-identical output; weak statuses are
+ * emitted verbatim and never promoted to `passed` / real-integrated.
+ */
+export function renderFrontendCloseout(facts) {
+    const lintLine = facts.lintStatus === "baseline-debt"
+        ? `${facts.lintStatus} (explicit debt; not passed)`
+        : facts.lintStatus;
+    return [
+        "# Frontend Closeout",
+        "",
+        "## Coverage Matrix",
+        coverageLines(facts),
+        "",
+        "## Lint Status",
+        lintLine,
+        "",
+        "## Integration Facts",
+        facts.integrationFacts,
+        "",
+        "## Frontend Status",
+        frontendStatus(facts),
+        "",
+        "## Real Integration Status",
+        integrationStatus(facts),
+        "",
+        "## Real Integration Pending",
+        facts.pendingRealIntegration ? "yes" : "no",
+        "",
+        "## Review Approval",
+        reviewApprovalLines(facts),
+        "",
+        "## Cumulative Diff",
+        `digest: ${facts.cumulativeDiff.cumulativeDigest}`,
+        `empty: ${facts.cumulativeDiff.empty}`,
+        "",
+        "## Browser / Visual",
+        `Browser: ${facts.notRun.browser}`,
+        `Visual: ${facts.notRun.visual}`,
+        "",
+        "## Residual Risks",
+        bulletList(facts.residualRisks) || "_(none)_",
+        "",
+        "## Evidence Gaps",
+        bulletList(facts.evidenceGaps) || "_(none)_",
+    ].join("\n") + "\n";
+}