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

package/dist/workflows/dag/frontend-review-scopes.js

@@ -4,6 +4,11 @@ import path from "node:path";
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
 import { readCommittedEvents } from "./frontend-typed-event-store.js";
 import { stageTypedEventFact, adoptTypedEventFact } from "./frontend-typed-event-transaction.js";
+const invalidScope = (message) => Object.assign(new Error(`FRONTEND_REVIEW_SCOPE_INVALID: ${message}`), { code: "FRONTEND_REVIEW_SCOPE_INVALID" });
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const isArtifactReference = (value) => isRecord(value)
+    && typeof value.path === "string" && value.path.length > 0
+    && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256);
 const hash = (text) => createHash("sha256").update(text).digest("hex");
 /** The section index is navigation; reconstruct coverage against the canonical source before using it. */
 export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
@@ -12,7 +17,7 @@ export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
     async function read(relative, expected) {
         const absolute = path.resolve(root, relative);
         if (!absolute.startsWith(root + path.sep) || (await lstat(absolute)).isSymbolicLink() || !(await realpath(absolute)).startsWith(root + path.sep))
-            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: artifact escaped run");
+            throw invalidScope("artifact escaped run");
         const text = await readFile(absolute, "utf8");
         const sha256 = hash(text);
         if (expected && sha256 !== expected)
@@ -30,45 +35,62 @@ export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
         throw error;
     }
     const index = JSON.parse(indexArtifact.text);
+    if (!isRecord(index) || !isArtifactReference(index.contract) || !Array.isArray(index.sections))
+        throw invalidScope("malformed contract index");
     const canonicalArtifact = await read(index.contract.path, index.contract.sha256);
     const canonical = JSON.parse(canonicalArtifact.text);
+    if (!isRecord(canonical))
+        throw invalidScope("canonical contract must be an object");
     const covered = new Map();
     const sections = [];
     const ids = new Set();
     for (const entry of index.sections) {
+        if (!isRecord(entry) || !isArtifactReference(entry) || !Array.isArray(entry.slices))
+            throw invalidScope("malformed section index entry");
         if (ids.has(entry.path))
-            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: duplicate section identity");
+            throw invalidScope("duplicate section identity");
         ids.add(entry.path);
         const section = await read(entry.path, entry.sha256);
         const payload = JSON.parse(section.text);
+        if (!isRecord(payload) || !Array.isArray(payload.slices) || !isRecord(payload.data))
+            throw invalidScope(`malformed section: ${entry.path}`);
         if (payload.contractSha256 !== canonicalArtifact.sha256 || sha256OfCanonicalJson(payload.slices) !== sha256OfCanonicalJson(entry.slices))
-            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: unbound section");
+            throw invalidScope("unbound section");
         for (const slice of payload.slices) {
+            if (!isRecord(slice) || typeof slice.field !== "string" || !Object.hasOwn(canonical, slice.field) || !Object.hasOwn(payload.data, slice.field))
+                throw invalidScope(`missing or invalid field reference in ${entry.path}: ${String(slice?.field)}`);
             const value = canonical[slice.field];
-            const range = Array.isArray(value) ? value.slice(slice.start, slice.end) : value;
-            if (sha256OfCanonicalJson(range) !== sha256OfCanonicalJson(payload.data[slice.field]))
-                throw Error("FRONTEND_REVIEW_SCOPE_INVALID: section differs from canonical obligation");
             const positions = covered.get(slice.field) ?? new Set();
             if (Array.isArray(value)) {
                 if (!Number.isInteger(slice.start) || !Number.isInteger(slice.end) || slice.start < 0 || slice.end < slice.start || slice.end > value.length || slice.total !== value.length)
-                    throw Error("FRONTEND_REVIEW_SCOPE_INVALID: invalid array coverage");
+                    throw invalidScope("invalid array coverage");
+                if ((value.length === 0 && covered.has(slice.field)) || (value.length > 0 && slice.start === slice.end))
+                    throw invalidScope(`empty or duplicate array coverage: ${slice.field}`);
                 for (let i = slice.start; i < slice.end; i++) {
                     if (positions.has(i))
-                        throw Error("FRONTEND_REVIEW_SCOPE_INVALID: overlapping coverage");
+                        throw invalidScope("overlapping coverage");
                     positions.add(i);
                 }
             }
             else {
+                if (["start", "end", "total"].some(key => Object.hasOwn(slice, key)))
+                    throw invalidScope(`scalar field has array range: ${slice.field}`);
                 if (positions.size)
-                    throw Error("FRONTEND_REVIEW_SCOPE_INVALID: duplicate field");
+                    throw invalidScope("duplicate field");
                 positions.add(0);
             }
+            const range = Array.isArray(value) ? value.slice(slice.start, slice.end) : value;
+            if (sha256OfCanonicalJson(range) !== sha256OfCanonicalJson(payload.data[slice.field]))
+                throw invalidScope(`section differs from canonical obligation: ${slice.field}`);
             covered.set(slice.field, positions);
         }
+        const sectionFields = new Set(payload.slices.map(slice => slice.field));
+        if (Object.keys(payload.data).some(field => !sectionFields.has(field)))
+            throw invalidScope(`unindexed section data: ${entry.path}`);
         sections.push(section);
     }
     if (Object.keys(canonical).some(field => !covered.has(field) || covered.get(field).size !== (Array.isArray(canonical[field]) ? canonical[field].length : 1)))
-        throw Error("FRONTEND_REVIEW_SCOPE_INVALID: canonical field coverage incomplete");
+        throw invalidScope("canonical field coverage incomplete");
     const scopes = Buffer.byteLength(canonicalArtifact.text) <= targetBytes ? [canonicalArtifact] : sections;
     if (phase === "review") {
         const context = await read("contracts/frontend-review-context.json");

package/package.json

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

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

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

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

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DkJ4ZjQS.js";import{_ as i}from"./mermaid.core-DPvHX155.js";import"./chunk-5VM5RSS4-CP9GHmRY.js";import"./chunk-XXDRQBXY-BZ33iX4W.js";import"./chunk-KBJHAD2P-C6KoK9O0.js";import"./chunk-2GRJ4B5K-BKP69b8r.js";import"./index-4wCGsXuU.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-GOC80mhq.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DkJ4ZjQS.js";import{_ as i}from"./mermaid.core-DPvHX155.js";import"./chunk-5VM5RSS4-CP9GHmRY.js";import"./chunk-XXDRQBXY-BZ33iX4W.js";import"./chunk-KBJHAD2P-C6KoK9O0.js";import"./chunk-2GRJ4B5K-BKP69b8r.js";import"./index-4wCGsXuU.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};