@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/worker/console/static/assets/stateDiagram-v2-UEYNNEHI-zBMYiUyi.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-5RXB4S5H-DuhvpIr7.js";import{_ as i}from"./mermaid.core-Cxg8kX8V.js";import"./chunk-XXDRQBXY-3iOSHdbM.js";import"./chunk-KBJHAD2P-CiVrxKHU.js";import"./chunk-2GRJ4B5K-D8K6adhU.js";import"./index-DLt4ZFvD.js";var u={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/worker/console/static/assets/swimlanesDiagram-ULZ7WXOC-d_rms-5i.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-UKHOOZJN-MrhLzNau.js";import{_ as a}from"./mermaid.core-Cxg8kX8V.js";import"./chunk-5VM5RSS4-BnK6dC49.js";import"./chunk-XXDRQBXY-3iOSHdbM.js";import"./chunk-KBJHAD2P-CiVrxKHU.js";import"./chunk-2GRJ4B5K-D8K6adhU.js";import"./channel-bnXW0U3C.js";import"./index-DLt4ZFvD.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,n=r({defaultLayout:"swimlane",styles:s});export{n as diagram};

package/dist/worker/console/static-src/active-run-badge.js

@@ -1,17 +0,0 @@
-/** Active run badge state resolved from active DAG run count. */
-/**
- * Resolve badge tone/label from the active DAG run count.
- *
- * - count === 0 → muted "0 active"（灰禁用态）
- * - 1 <= count <= 99 → active "<N> active"
- * - count > 99 → active "99+"（按 AC 字面量，不追加 " active" 后缀）
- *
- * 纯函数、零 IO、无副作用；非正输入统一钳制为 muted "0 active"。
- */
-export function deriveActiveRunBadgeState(count) {
-    if (count <= 0)
-        return { tone: "muted", label: "0 active" };
-    if (count > 99)
-        return { tone: "active", label: "99+" };
-    return { tone: "active", label: `${count} active` };
-}

package/dist/worker/materialize/frontend-split-task-materializer.js

@@ -1,72 +0,0 @@
-import { z } from "zod";
-import { computeFrontendSplitDigest } from "../../workflows/dag/frontend-split-orchestrator.js";
-const idSchema = z.string().trim().min(1);
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
-const positiveIntegerSchema = z.number().int().positive();
-const pathSchema = z.string().trim().min(1);
-export const frontendSplitTaskMaterializationRequestSchema = z.object({
-    kind: z.enum(["child", "integration"]),
-    parentOperationId: idSchema,
-    manifestDigest: digestSchema,
-    generation: positiveIntegerSchema,
-    taskId: idSchema,
-    operationId: idSchema,
-    payloadDigest: digestSchema,
-    allowedPaths: z.array(pathSchema),
-    writeSet: z.array(pathSchema),
-    verifyRefs: z.array(idSchema),
-}).strict();
-export const frontendSplitTaskMaterializationResultSchema = z.object({
-    idempotencyKey: digestSchema,
-    requestDigest: digestSchema,
-    taskId: idSchema,
-    operationId: idSchema,
-}).strict();
-function identityPayload(request) {
-    return { kind: request.kind, parentOperationId: request.parentOperationId, manifestDigest: request.manifestDigest, generation: request.generation, taskId: request.taskId, operationId: request.operationId };
-}
-export class FrontendSplitTaskMaterializer {
-    backend;
-    completed = new Map();
-    inFlight = new Map();
-    constructor(backend) {
-        this.backend = backend;
-    }
-    async materialize(raw) {
-        const request = frontendSplitTaskMaterializationRequestSchema.parse(raw);
-        const idempotencyKey = computeFrontendSplitDigest(identityPayload(request));
-        const requestDigest = computeFrontendSplitDigest(request);
-        const existing = this.completed.get(idempotencyKey);
-        if (existing) {
-            if (existing.requestDigest !== requestDigest)
-                throw new Error("frontend split materialization payload drift");
-            return existing;
-        }
-        const pending = this.inFlight.get(idempotencyKey);
-        if (pending) {
-            const result = await pending;
-            if (result.requestDigest !== requestDigest)
-                throw new Error("frontend split materialization payload drift");
-            return result;
-        }
-        const promise = this.perform(request, idempotencyKey, requestDigest);
-        this.inFlight.set(idempotencyKey, promise);
-        try {
-            const result = await promise;
-            this.completed.set(idempotencyKey, result);
-            return result;
-        }
-        finally {
-            this.inFlight.delete(idempotencyKey);
-        }
-    }
-    async perform(request, idempotencyKey, requestDigest) {
-        const task = await this.backend.ensureTask({ idempotencyKey, taskId: request.taskId, payloadDigest: requestDigest, request });
-        if (!task.complete || task.taskId !== request.taskId)
-            throw new Error("frontend split task materialization incomplete or drifted");
-        const operation = await this.backend.ensureOperation({ idempotencyKey, taskId: request.taskId, operationId: request.operationId, payloadDigest: requestDigest, request });
-        if (!operation.complete || operation.taskId !== request.taskId || operation.operationId !== request.operationId)
-            throw new Error("frontend split operation materialization incomplete or drifted");
-        return frontendSplitTaskMaterializationResultSchema.parse({ idempotencyKey, requestDigest, taskId: request.taskId, operationId: request.operationId });
-    }
-}

package/dist/workflows/dag/dag-retry-schema.js

@@ -1,138 +0,0 @@
-import { z } from "zod";
-/**
- * Leaf module for the retry-policy schema surface: failure-category constants,
- * the zod retry-policy schema, and the target-template transient retry profile
- * literal.
- *
- * `types.ts` reads `dagRetryPolicySchema` / `TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE`
- * during its own module initialization, and the retry-policy module transitively
- * reaches `types.ts` (retry-policy → frontend-recovery-capsule →
- * frontend-recovery-lineage → frontend-implementation-contract → types). With
- * these definitions living in retry-policy itself, a run whose entry module is
- * retry-policy (e.g. test/dag-node-retry.test.ts) evaluates `types.ts` while
- * retry-policy is still initializing and reads an undefined
- * `dagRetryPolicySchema`. Keeping this module a leaf (zod is its only import)
- * makes the cycle resolve order-independently; retry-policy re-exports
- * everything for source compatibility.
- */
-/**
- * Failure categories that are safe to auto-retry for read-only Pi nodes.
- *
- * These are failures with no repository write side-effects: model connection
- * interruption, provider rate-limiting, temporary provider unavailability,
- * request timeout, or a settled read-only turn with no assistant text.
- *
- * `quota` is intentionally NOT included: a quota exhaustion is an account
- * billing/plan state, not a transient rate limit, and retrying immediately
- * will not help and may waste budget.
- */
-export const DEFAULT_DAG_RETRY_CATEGORIES = [
-    "timeout",
-    "network",
-    "rate-limit",
-    "unavailable",
-    "empty-output",
-];
-export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
-export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
-/** Recoverable model artifact/schema formatting failure on read-only structured nodes. */
-export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
-/** Provider stopReason=length truncated the response before the JSON contract completed. */
-export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
-/**
- * The review node emitted a verdict in response text (e.g. "VERDICT: pass")
- * but never committed the authoritative typed terminal tool call
- * (approve_review / request_review_changes). Read-only and safe to retry with
- * a corrected instruction; the typed terminal is the only authority.
- */
-export const REVIEW_TERMINAL_MISSING_RETRY_CATEGORY = "review-terminal-missing";
-/**
- * The plan node issued too many read-only tool calls (read/grep/ls/find),
- * blowing up the context window and eventually a 400 request-too-large. The
- * plan should trust upstream typed facts instead of re-reading contract/scout
- * outputs and source files repeatedly. Read-only and safe to retry with a
- * reduced-reading instruction.
- */
-export const READ_BURST_RETRY_CATEGORY = "read-burst";
-/**
- * Provider returned a context-overflow error (400 request-too-large / context
- * window exceeded). The SDK compacts and auto-retries once internally; when it
- * still surfaces, the executor classifies this so retry policies and reports
- * treat it as overflow (not empty-output) and can retry with a compacted
- * session / fresh context.
- */
-export const CONTEXT_OVERFLOW_RETRY_CATEGORY = "context-overflow";
-/** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
-export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
-/** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
-export const INCOMPLETE_WRITE_SET_RETRY_CATEGORY = "incomplete-write-set";
-/**
- * Provider/transport stall or absolute timeout on a Pi exclusive writer that
- * left zero attributed workspace writes and zero write-tool calls. Safe to
- * retry once because the attempt was a pure provider flake (no side effects).
- * Partial writes keep the original `timeout` category and do NOT retry.
- */
-export const WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY = "writer-clean-timeout";
-export const STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES = [
-    ...DEFAULT_DAG_RETRY_CATEGORIES,
-    STRUCTURED_OUTPUT_RETRY_CATEGORY,
-    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
-    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
-];
-/** Categories allowed on nodes that declare a machine-readable outputProtocol. */
-export const PROTOCOL_AWARE_DAG_RETRY_CATEGORIES = [
-    ...DEFAULT_DAG_RETRY_CATEGORIES,
-    PROTOCOL_INVALID_RETRY_CATEGORY,
-    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
-];
-export const ALL_DAG_RETRY_CATEGORIES = [
-    ...DEFAULT_DAG_RETRY_CATEGORIES,
-    STRUCTURED_OUTPUT_RETRY_CATEGORY,
-    PROTOCOL_INVALID_RETRY_CATEGORY,
-    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
-    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
-    WRITER_EMPTY_DIFF_RETRY_CATEGORY,
-    INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
-    WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
-    REVIEW_TERMINAL_MISSING_RETRY_CATEGORY,
-    READ_BURST_RETRY_CATEGORY,
-    CONTEXT_OVERFLOW_RETRY_CATEGORY,
-];
-export const dagRetryCategorySchema = z.enum(ALL_DAG_RETRY_CATEGORIES);
-export const dagRetryBackoffSchema = z.enum(["exponential"]);
-/**
- * Opt-in retry policy for a DagTask. Generated for safe read-only Pi nodes,
- * except the single validation-gated writer-empty-diff policy. Validation
- * rejects all other writers, dynamic, shell, static, and decision-gate nodes.
- */
-export const dagRetryPolicySchema = z
-    .object({
-    /**
-     * Total number of attempts (including the first try). Must be 1..5.
-     * A value of 1 disables retry (one attempt, no retry).
-     */
-    maxAttempts: z.number().int().positive().max(5),
-    backoff: dagRetryBackoffSchema.default("exponential"),
-    /** Initial delay before the second attempt, in milliseconds. */
-    initialDelayMs: z.number().int().nonnegative().default(2000),
-    /** Upper bound on a single backoff delay, in milliseconds. */
-    maxDelayMs: z.number().int().nonnegative().default(30000),
-    /**
-     * Explicit set of failure categories eligible for retry. Defaults to
-     * {@link DEFAULT_DAG_RETRY_CATEGORIES}. `quota` and other categories
-     * are never retried.
-     */
-    retryCategories: z
-        .array(dagRetryCategorySchema)
-        .default([...DEFAULT_DAG_RETRY_CATEGORIES]),
-})
-    .superRefine((policy, ctx) => {
-    if (policy.maxDelayMs < policy.initialDelayMs) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "retryPolicy.maxDelayMs must be >= retryPolicy.initialDelayMs",
-            path: ["maxDelayMs"],
-        });
-    }
-});
-export const TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE = "standard-reviewed-supervised-v1";

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

@@ -1,221 +0,0 @@
-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";
-}