@tea-agent/loop-agent 0.43.0-next.4 → 0.43.0-next.6

package/dist/workflows/dag/frontend-plan-completeness.js

@@ -0,0 +1,186 @@
+import { collectCanonicalStateFlowNames } from "./frontend-contract-facts.js";
+export function committedFactFromPlanRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.phase !== undefined && record.phase !== "committed")
+        return undefined;
+    const fact = record.fact;
+    return fact && typeof fact === "object" && !Array.isArray(fact)
+        ? fact
+        : typeof record.kind === "string"
+            ? record
+            : undefined;
+}
+export function planFactStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+export function planFactScopeIntersects(fact, requirementIds) {
+    return planFactStringList(fact.scopeRequirementIds).some((id) => requirementIds.has(id));
+}
+/** Compute the authoritative coverage queue from the committed plan ledger. */
+export function collectFrontendPlanMissingFacts(input) {
+    const requirements = new Map();
+    const standaloneEvidenceGaps = new Set();
+    const verificationTargetIds = new Set();
+    const verificationTargetRequirements = new Map();
+    for (const value of input.committedFacts) {
+        const fact = committedFactFromPlanRecord(value);
+        if (!fact || fact.origin !== "plan")
+            continue;
+        if (fact.kind === "plan-requirement" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            if (typeof entry.id === "string" && entry.id.trim())
+                requirements.set(entry.id, entry);
+        }
+        if (fact.kind === "plan-verification-target" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            const id = entry.id;
+            if (typeof id === "string" && id.trim()) {
+                verificationTargetIds.add(id);
+                verificationTargetRequirements.set(id, new Set(Array.isArray(entry.requirementIds)
+                    ? entry.requirementIds.filter((value) => typeof value === "string")
+                    : []));
+            }
+        }
+        if (fact.kind === "plan-evidence-gap" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            const requirementId = entry.requirementId;
+            const description = entry.description;
+            if (typeof requirementId === "string" && requirementId.trim() && typeof description === "string" && description.trim()) {
+                standaloneEvidenceGaps.add(requirementId);
+            }
+        }
+    }
+    const missing = [];
+    for (const id of input.requirementIds) {
+        const entry = requirements.get(id);
+        if (!entry) {
+            missing.push({
+                kind: "plan-requirement",
+                id,
+                requirementIds: [id],
+                reason: `requirement ${id} has no committed plan-requirement fact`,
+            });
+            continue;
+        }
+        const targetIds = Array.isArray(entry.verificationTargetIds)
+            ? entry.verificationTargetIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+            : [];
+        const gap = entry.evidenceGap && typeof entry.evidenceGap === "object"
+            ? entry.evidenceGap
+            : undefined;
+        const hasEvidenceGap = (typeof gap?.description === "string" && gap.description.trim().length > 0) ||
+            standaloneEvidenceGaps.has(id);
+        if (targetIds.length === 0 && !hasEvidenceGap) {
+            missing.push({
+                kind: "plan-verification-target",
+                requirementIds: [id],
+                reason: `requirement ${id} declares neither a verification target nor a non-empty evidenceGap`,
+            });
+            continue;
+        }
+        for (const targetId of targetIds) {
+            if (!verificationTargetIds.has(targetId) ||
+                !verificationTargetRequirements.get(targetId)?.has(id)) {
+                missing.push({
+                    kind: "plan-verification-target",
+                    id: targetId,
+                    requirementIds: [id],
+                    reason: `requirement ${id} references verification target ${targetId}, but that target is not committed`,
+                });
+            }
+        }
+    }
+    return missing;
+}
+/** Completeness checks for phases whose facts are committed incrementally. */
+export function collectFrontendPlanPhaseMissingFacts(input) {
+    const facts = input.committedFacts
+        .map(committedFactFromPlanRecord)
+        .filter((fact) => Boolean(fact && fact.origin === "plan"));
+    if (input.phase === "ux-registry") {
+        return facts.some((fact) => fact.kind === "state-registry")
+            ? []
+            : [
+                {
+                    kind: "state-registry",
+                    requirementIds: [...input.requirementIds],
+                    reason: "global UX vocabulary phase has no committed state-registry fact",
+                },
+            ];
+    }
+    if (input.phase === "ux-local") {
+        // One snapshot per check: no cross-revision cache to invalidate.
+        const required = new Set(input.behaviorRequiredRequirementIds ?? []);
+        const requested = new Set(input.requirementIds.filter(id => required.has(id)));
+        if (!requested.size)
+            return [];
+        const byRequirement = new Map();
+        for (const fact of facts) {
+            for (const id of new Set(planFactStringList(fact.scopeRequirementIds))) {
+                if (!requested.has(id))
+                    continue;
+                const entries = byRequirement.get(id) ?? [];
+                entries.push(fact);
+                byRequirement.set(id, entries);
+            }
+        }
+        const liveStateFlow = collectCanonicalStateFlowNames(facts);
+        const missing = [];
+        for (const id of input.requirementIds) {
+            if (!required.has(id))
+                continue;
+            const scopedFacts = byRequirement.get(id) ?? [];
+            const hasChoice = scopedFacts.some((fact) => fact.kind === "component-choice" &&
+                Array.isArray(fact.uiComponentChoices) &&
+                fact.uiComponentChoices.length > 0);
+            const canonicalStateFlow = collectCanonicalStateFlowNames(scopedFacts);
+            const hasStateFlow = [...canonicalStateFlow.uiStateNames].some(name => liveStateFlow.uiStateNames.has(name)) ||
+                [...canonicalStateFlow.interactionNames].some(name => liveStateFlow.interactionNames.has(name));
+            if (!hasChoice) {
+                missing.push({
+                    kind: "component-choice",
+                    requirementIds: [id],
+                    reason: "behaviour-required UX slice has no committed component-choice fact",
+                });
+            }
+            if (!hasStateFlow) {
+                missing.push({
+                    kind: "state-flow",
+                    requirementIds: [id],
+                    reason: "behaviour-required UX slice has no committed state-flow fact",
+                });
+            }
+        }
+        return missing;
+    }
+    const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
+    const allInteractions = collectCanonicalStateFlowNames(facts).interactionNames;
+    const requested = new Set(input.requirementIds);
+    const liveInteractions = new Set([...collectCanonicalStateFlowNames(facts.filter(f => !planFactStringList(f.scopeRequirementIds).length || planFactScopeIntersects(f, requested))).interactionNames].filter(name => allInteractions.has(name)));
+    const coveredInteractions = new Set(facts
+        .filter((fact) => fact.kind === "data-flow")
+        .flatMap((fact) => planFactStringList(fact.interactions)));
+    const missing = [];
+    if (!hasMockApi) {
+        missing.push({
+            kind: "mock-api",
+            requirementIds: [...input.requirementIds],
+            reason: "global Mock/data phase has no committed mock-api fact",
+        });
+    }
+    for (const interaction of liveInteractions) {
+        if (coveredInteractions.has(interaction))
+            continue;
+        missing.push({
+            kind: "data-flow",
+            id: interaction,
+            requirementIds: [...input.requirementIds],
+            reason: `interaction ${interaction} has no committed data-flow fact`,
+        });
+    }
+    return missing;
+}

package/dist/workflows/dag/frontend-plan-recovery-policy.js

@@ -0,0 +1,18 @@
+/** Precise failures own their recovery. A stale transport length marker must
+ * never turn cancellation, provider rejection or policy failure into progress. */
+export function classifyFrontendPlanRecovery(result) {
+    const category = result.failureCategory ?? "";
+    if (result.timedOut || result.stopReason === "aborted" ||
+        /interrupt|termination-unconfirmed|budget_breach/.test(category) ||
+        ["cancelled", "auth", "missing-api-key", "rate-limit", "quota", "timeout", "tool-policy", "write-guard", "path-violation", "governance-blocked", "human-rejected"].includes(category))
+        return "stop";
+    if (result.ok)
+        return "none";
+    if (category === "output-limit")
+        return "output";
+    if (["context-overflow", "context-budget-exhausted"].includes(category))
+        return "context";
+    if (result.stopReason === "length" && ["", "empty-output", "network", "nonzero-exit", "unknown"].includes(category))
+        return "output";
+    return "none";
+}

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

@@ -1,4 +1,5 @@
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { FRONTEND_MAX_IMPLEMENTATION_FILES, frontendConcreteDeliveryFiles } from "./frontend-capacity.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";
@@ -222,7 +223,13 @@ function extractRuntimeShapeEvidence(input) {
         !sourceText.includes(path) &&
         /(?:\.[A-Za-z0-9]+|\*\*)$/.test(path));
     const routes = canonicalStrings(text.match(/\/(?:[A-Za-z0-9_:[\]-]+\/?)+/g) ?? []);
-    const splitRequired = /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
+    // The frozen delivery inventory is available before Plan. Do not spend
+    // coverage/UX sessions building a contract the same capacity gate will reject.
+    // allowedPaths and text mentions are permissions/evidence, never this count.
+    const skeleton = input.tasksById.get("frontend-plan-pi")?.structuredContractOutput?.skeleton;
+    const deliveryFiles = frontendConcreteDeliveryFiles(skeleton?.targets?.files);
+    const capacitySplit = deliveryFiles.length > FRONTEND_MAX_IMPLEMENTATION_FILES;
+    const splitRequired = capacitySplit || /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
     return {
         sourceNodeId: input.sourceNodeId,
         sourceNodeDigest: computeFrontendShapeNodeDigest(node),
@@ -232,7 +239,10 @@ function extractRuntimeShapeEvidence(input) {
         targetPaths,
         routes,
         splitRequired,
-        evidenceRefs: [`node:${input.sourceNodeId}:stdout`],
+        evidenceRefs: [
+            ...(capacitySplit ? ["dag:frontend-plan-pi:structuredContractOutput.skeleton.targets.files"] : []),
+            `node:${input.sourceNodeId}:stdout`,
+        ],
     };
 }
 /** Commit a typed, structured runtime fact immediately after a canonical source

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.4",
+  "version": "0.43.0-next.6",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/frontend-plan/SKILL.md

@@ -29,6 +29,13 @@ cite `evidencePath` of an existing file; greenfield is `decision=new`.
 Bind every file in the Contract-owned `requiredDeliverables` inventory. It records
 explicit source obligations, not every path mentioned by a requirement.
 
+Large UX work runs in bounded scopes against that shared registry. Complete every
+assigned requirement; preserve earlier scopes' shared bindings when correcting an
+entry. Ledger previews are incomplete. Use `read_plan_facts` to retrieve full
+fields, following `nextOffset` with `expectedRevision` pinned. For oversized
+strings use `stringOffset` and follow `nextStringOffset`; restart pagination when
+the revision changes. Never submit a truncated preview as a replacement payload.
+
 Cross-slice citations must close in the same session: when a requirement cites a
 verification target committed in another slice's session, re-commit that target
 here with the same id and `replace=true` (union backfill) before finalize. A

package/dist/worker/console/static/assets/channel-CEMRpNm-.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-C-5IQMP_.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-C9lhaZkR.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-CS6-PjCZ.js";import{_ as i}from"./mermaid.core-C-5IQMP_.js";import"./chunk-5VM5RSS4-CEB3AvU2.js";import"./chunk-XXDRQBXY-BVm1bnX6.js";import"./chunk-KBJHAD2P-DkB0QX3q.js";import"./chunk-2GRJ4B5K-CQPwOv_j.js";import"./index-CJkCY1XR.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-C9lhaZkR.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-CS6-PjCZ.js";import{_ as i}from"./mermaid.core-C-5IQMP_.js";import"./chunk-5VM5RSS4-CEB3AvU2.js";import"./chunk-XXDRQBXY-BVm1bnX6.js";import"./chunk-KBJHAD2P-DkB0QX3q.js";import"./chunk-2GRJ4B5K-CQPwOv_j.js";import"./index-CJkCY1XR.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};