@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/dist/workflows/dag/frontend-design-policy.js

@@ -1,11 +1,12 @@
 import { deterministicSha256, } from "./frontend-implementation-contract.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { FRONTEND_MAX_IMPLEMENTATION_FILES } from "./frontend-capacity.js";
 const SHA256_HEX = /^[a-f0-9]{64}$/;
 const NPM_PACKAGE_NAME = /^(?:@[a-zA-Z0-9_.-]+\/)?[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
 /** Max concrete implementation files a single writeSet may carry before the
  * plan is asked to split. Kept at 15: beyond this, a single implement node's
  * read/edit loop inflates provider context toward overflow. */
-const MAX_WRITE_SET_FILES = 15;
+const MAX_WRITE_SET_FILES = FRONTEND_MAX_IMPLEMENTATION_FILES;
 function normalizeRelativePath(value) {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -28,31 +29,37 @@ function sortFindings(findings) {
  * visual UI-state dimension (it cannot cover behavioural interactions). */
 export function checkUiDesignCoverage(contract) {
     const findings = [];
-    const purposes = new Set((contract.uiComponentChoices ?? []).map((choice) => choice.purpose));
-    const hasStyling = Boolean(contract.stylingStrategy?.trim());
-    // Reuse of an existing component/pattern covers behavioural interactions
-    // without forcing one uiComponentChoices row per interaction: the model
-    // should not enumerate every click/hover on a reused Button. Only
-    // interactions with no reuse and no explicit purpose are flagged.
-    const hasReuseChoice = (contract.uiComponentChoices ?? []).some((choice) => choice.decision === "reuse-existing");
+    // Explicit per-id coverage (dogfood r-plan-quality): one choice covers an
+    // interaction/state when its purpose equals the name OR the choice lists
+    // the name in covers. The old wildcards are gone — a single reuse-existing
+    // row no longer passes every interaction, and a non-empty stylingStrategy
+    // no longer passes every state.
+    const covered = new Set();
+    for (const choice of contract.uiComponentChoices ?? []) {
+        if (choice.purpose.trim())
+            covered.add(choice.purpose);
+        for (const id of choice.covers ?? []) {
+            if (id.trim())
+                covered.add(id);
+        }
+    }
     for (const state of contract.uiStates) {
         if (!state.applicable)
             continue;
-        const covered = purposes.has(state.name) || hasStyling;
-        if (!covered) {
+        if (!covered.has(state.name)) {
             findings.push({
                 code: "ui-design-coverage-missing",
-                message: `applicable UI state "${state.name}" has no matching uiComponentChoices.purpose or stylingStrategy`,
+                message: `applicable UI state "${state.name}" is not covered by any uiComponentChoices purpose or covers entry`,
                 path: state.name,
             });
         }
     }
     for (const interaction of contract.interactions) {
-        if (purposes.has(interaction.name) || hasReuseChoice)
+        if (covered.has(interaction.name))
             continue;
         findings.push({
             code: "ui-design-coverage-missing",
-            message: `interaction "${interaction.name}" has no matching uiComponentChoices.purpose and no reuse-existing choice covering it`,
+            message: `interaction "${interaction.name}" is not covered by any uiComponentChoices purpose or covers entry`,
             path: interaction.name,
         });
     }
@@ -158,7 +165,7 @@ export function checkMockStrategy(contract, allowedMockStrategies) {
  * A component specReference must still not point into clearly non-component
  * spec areas — templates and the ai_workspace governance subtree cannot be the
  * authoritative component definition. */
-export function checkComponentChoice(contract, componentSpecCandidatePaths) {
+export function checkComponentChoice(contract, componentSpecCandidatePaths, options) {
     const findings = [];
     const candidates = new Set(componentSpecCandidatePaths.map(normalizeRelativePath));
     const isNonComponentSpecArea = (path) => {
@@ -200,6 +207,23 @@ export function checkComponentChoice(contract, componentSpecCandidatePaths) {
                 });
             }
         }
+        else if (choice.decision === "reuse-existing") {
+            if (!(choice.evidencePath && choice.evidencePath.trim().length > 0)) {
+                findings.push({
+                    code: "component-reuse-evidence-missing",
+                    message: `reuse-existing component choice #${index} is missing evidencePath naming the existing repo file that proves the reuse; a greenfield path must use decision=new`,
+                    path: choice.purpose,
+                });
+            }
+            else if (options?.hasFreshPathEvidence &&
+                !options.hasFreshPathEvidence(choice.evidencePath)) {
+                findings.push({
+                    code: "component-reuse-path-not-fresh",
+                    message: `reuse-existing component choice #${index} evidencePath "${choice.evidencePath}" has no fresh existence evidence (path not found); reuse requires an existing file — use decision=new for greenfield paths`,
+                    path: choice.evidencePath,
+                });
+            }
+        }
         else if (choice.decision === "new") {
             if (!choice.specReference || !choice.specReference.path) {
                 findings.push({
@@ -236,7 +260,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
     if (contract.targets.files.length > MAX_WRITE_SET_FILES) {
         findings.push({
             code: "write-set-too-large",
-            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task (record_split_proposal) so no single implement node exceeds the bound`,
+            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task at the Contract boundary so no single implement node exceeds the bound; preserve all required files`,
         });
     }
     for (const file of contract.targets.files) {
@@ -249,7 +273,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
         }
     }
     for (const target of contract.verificationTargets) {
-        if (target.type === "static")
+        if (target.mode === "static")
             continue;
         if (!matches(target.file)) {
             findings.push({
@@ -371,6 +395,64 @@ export function checkDesignApproval(designApproval) {
     }
     return [];
 }
+/**
+ * UX vocabulary collisions (item ③, dogfood dag-1788504923861-0f7b17a9):
+ * prioritize-planner-task / prioritizePlannerTask / prioritize-planner-tasks
+ * are one behavior renamed three ways. Case/separator-insensitive duplicates
+ * inside interactions or inside uiStates are blocking.
+ */
+export function checkUxNameCollisions(contract) {
+    const findings = [];
+    const normalize = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const collisions = (names, kind) => {
+        const byNormalized = new Map();
+        const found = [];
+        for (const name of names) {
+            const key = normalize(name);
+            if (!key)
+                continue;
+            const existing = byNormalized.get(key);
+            if (existing !== undefined && existing !== name) {
+                found.push({
+                    code: "ux-name-collision",
+                    message: `"${name}" and "${existing}" are the same ${kind} name up to case/separator — one behavior must keep one stable name`,
+                    path: name,
+                });
+            }
+            else {
+                byNormalized.set(key, name);
+            }
+        }
+        return found;
+    };
+    findings.push(...collisions(contract.interactions.map((interaction) => interaction.name), "interaction"));
+    findings.push(...collisions(contract.uiStates.map((state) => state.name), "UI state"));
+    return findings;
+}
+/**
+ * Deliverable completeness (item ⑦): every file explicitly declared by Contract
+ * from frozen source fragments (projected into targets.requiredDeliverables)
+ * must be planned — bound by some requirement's implementationTargets or a
+ * verification target's file, or listed in targets.files. allowedPaths is a
+ * write boundary and never implies coverage.
+ */
+export function checkRequiredDeliverables(contract) {
+    const required = contract.targets.requiredDeliverables ?? [];
+    if (required.length === 0)
+        return [];
+    const planned = new Set([
+        ...contract.targets.files,
+        ...contract.requirements.flatMap((requirement) => requirement.implementationTargets),
+        ...contract.verificationTargets.map((target) => target.file),
+    ]);
+    return required
+        .filter((path) => !planned.has(path))
+        .map((path) => ({
+        code: "required-deliverable-unplanned",
+        message: `Contract declares required deliverable "${path}" but no requirement implementationTarget, verification target, or targets.files entry plans it`,
+        path,
+    }));
+}
 /** Aggregate the deterministic design-policy checks into a single
  * deterministic result. Any finding blocks; an empty finding list approves. */
 export function evaluateFrontendDesignPolicy(input) {
@@ -379,10 +461,14 @@ export function evaluateFrontendDesignPolicy(input) {
         ...checkUiDesignCoverage(input.contract),
         ...checkSourceFreshness(input.contract, input.sourceFreshness),
         ...checkMockStrategy(input.contract, input.allowedMockStrategies),
-        ...checkComponentChoice(input.contract, input.componentSpecCandidatePaths),
+        ...checkComponentChoice(input.contract, input.componentSpecCandidatePaths, input.hasFreshPathEvidence
+            ? { hasFreshPathEvidence: input.hasFreshPathEvidence }
+            : undefined),
         ...checkTargetPaths(input.contract, input.writeSetPatterns),
         ...checkDependencies(input.contract, input.allowedDependencies),
         ...checkUiStateAttribution(input.contract),
+        ...checkUxNameCollisions(input.contract),
+        ...checkRequiredDeliverables(input.contract),
     ]);
     const classification = findings.length > 0 ? "blocked" : "approved";
     const result = {

package/dist/workflows/dag/frontend-durable-tools.js

@@ -0,0 +1,193 @@
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { Check, Errors } from "typebox/value";
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { assertHarnessWriteAllowed } from "../../infrastructure/harness/completed-facts-guard.js";
+import { readTypedEventStoreFromJsonl, typedEventPayloadSha256, hasCommittedTerminalEvent } from "./frontend-typed-event-store.js";
+const queues = new Map();
+const progressByTool = new WeakMap();
+/** Process-local telemetry only; durable facts remain the authority. */
+export function readFrontendToolProgress(tools) {
+    const counters = [...new Set((tools ?? []).flatMap(tool => tool && typeof tool === "object" && progressByTool.has(tool) ? [progressByTool.get(tool)] : []))];
+    if (!counters.length)
+        return undefined;
+    return counters.reduce((sum, item) => ({ failedRecords: sum.failedRecords + item.failedRecords, duplicateRecords: sum.duplicateRecords + item.duplicateRecords, durableSubmissions: sum.durableSubmissions + item.durableSubmissions, durableReplacements: sum.durableReplacements + item.durableReplacements }), { failedRecords: 0, duplicateRecords: 0, durableSubmissions: 0, durableReplacements: 0 });
+}
+async function exclusive(key, work) {
+    const previous = queues.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => { }).then(work);
+    queues.set(key, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (queues.get(key) === current)
+            queues.delete(key);
+    }
+}
+const hash = (value) => sha256OfCanonicalJson(JSON.parse(JSON.stringify(value, (_key, v) => v instanceof Map ? [...v.entries()].sort(([a], [b]) => String(a).localeCompare(String(b))) : v)));
+const ledgerError = (code, message) => Object.assign(new Error(message), { code });
+const failure = (code, error) => ({ content: [{ type: "text", text: JSON.stringify({ ok: false, code, error }) }], details: { ok: false, code, error } });
+/** A failed rename must never fall back to copying over a live ledger. */
+async function persist(file, records) {
+    assertHarnessWriteAllowed(file);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        const handle = await open(temporary, "wx", 0o600);
+        try {
+            await handle.writeFile(records.map(r => JSON.stringify(r)).join("\n") + (records.length ? "\n" : ""));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true }).catch(() => { });
+    }
+}
+/** One queue covers schema checks, semantic checks, all facts in a tool call,
+ * atomic persistence, and acknowledgement. The model never sees a draft as saved. */
+export async function createDurableFrontendTools(input) {
+    const file = path.resolve(input.file);
+    const tools = input.tools.map(tool => {
+        const schema = tool.parameters;
+        return { ...tool, parameters: { ...schema, properties: { ...schema.properties, replace: { type: "boolean", description: "Explicitly revise the current fact with the same identity. Omit for new facts or identical replay." } } } };
+    });
+    const bindingSha256 = hash({ version: 1, attemptId: input.attemptId, binding: input.binding, schemas: tools.map(t => ({ name: t.name, parameters: t.parameters })) });
+    const publish = (store) => { input.store.records = store.records; input.store.revision = store.revision; input.setWorkingStore(input.store); };
+    const validate = async (records) => {
+        let revision = 0;
+        let terminal = false;
+        const ids = new Set();
+        const requests = new Set();
+        for (const r of records) {
+            if (r.attemptId !== input.attemptId || r.submission?.bindingSha256 !== bindingSha256)
+                throw ledgerError("FRONTEND_LEDGER_BINDING_MISMATCH", "frontend ledger binding/scope mismatch; preserve evidence and restart its owning phase");
+            if (r.phase !== "committed" || r.payloadSha256 !== typedEventPayloadSha256(r.fact) || r.revision <= revision || ids.has(r.eventId) || requests.has(r.requestId) || terminal)
+                throw ledgerError("FRONTEND_LEDGER_INTEGRITY_INVALID", "frontend ledger integrity/revision mismatch");
+            ids.add(r.eventId);
+            requests.add(r.requestId);
+            revision = r.revision;
+            terminal = hasCommittedTerminalEvent({ records: [r], revision }, input.attemptId);
+        }
+        await input.validateRestored?.(records);
+    };
+    const restore = async () => {
+        const records = await readTypedEventStoreFromJsonl(file);
+        if (records.length) {
+            await validate(records);
+            publish({ records, revision: records.at(-1).revision });
+        }
+        else if (input.store.records.some(r => r.submission))
+            throw ledgerError("FRONTEND_LEDGER_MISSING", "frontend durable ledger disappeared or became empty; refusing an unproven acknowledgement");
+    };
+    await exclusive(file, restore);
+    const progress = { failedRecords: 0, duplicateRecords: 0, durableSubmissions: 0, durableReplacements: 0 };
+    const replay = (receipt) => { progress.duplicateRecords++; return receipt; };
+    const wrapped = tools.map(tool => ({ ...tool, execute: (...args) => exclusive(file, async () => {
+            const [callId, params] = args;
+            const valid = Check(tool.parameters, params);
+            if (!valid) {
+                const errors = [...Errors(tool.parameters, params)];
+                return failure("TOOL_SCHEMA_INVALID", `${tool.name}: ${errors.slice(0, 8).map(e => `${e.instancePath || "/"}: ${e.message}`).join("; ")}${errors.length > 8 ? `; ${errors.length - 8} more fields` : ""}`);
+            }
+            try {
+                await restore();
+                const paramsSha256 = hash(params);
+                const singleton = new Set(["record_route_selection", "record_state_registry", "record_mock_api", "record_data_flow", "record_dependency", "record_design_deviation", "record_required_deliverables", "record_target_surface", "finalize_contract", "finalize_plan"]);
+                const naturalId = params?.id ?? params?.scopeId ?? params?.entry?.id ?? params?.requirementId ?? params?.choice?.purpose ?? (tool.name === "record_openspec_selection" ? params?.path : undefined) ?? (params?.endpoint ? `${params.endpoint.method}:${params.endpoint.path}` : undefined) ?? (singleton.has(tool.name) ? "singleton" : undefined);
+                const identity = `${tool.name}:${typeof naturalId === "string" ? naturalId : "incremental"}`;
+                const submissions = input.store.records.flatMap(r => r.submission?.receipt ? [r.submission] : []);
+                const previousCall = submissions.find(s => s.callId === callId);
+                if (previousCall)
+                    return previousCall.tool === tool.name && previousCall.paramsSha256 === paramsSha256 ? replay(previousCall.receipt) : failure("REQUEST_ID_REUSE_CONFLICT", `${tool.name}: call id already acknowledged with different parameters`);
+                const previousFact = submissions.filter(s => s.identity === identity).at(-1);
+                if (tool.name !== "record_plan_group_coverage" && previousFact?.paramsSha256 === paramsSha256)
+                    return replay(previousFact.receipt);
+                if (previousFact && naturalId !== undefined && params?.replace !== true && !["record_evidence_expectation", "record_required_deliverables", "record_data_flow"].includes(tool.name))
+                    return failure("FACT_IDENTITY_CONFLICT", `${identity}: changing a saved fact requires explicit replacement (replace:true)`);
+                if (input.store.records.some(r => ["contract-finalized", "finalize_plan", "approve_review", "request_review_changes", "approve_design", "request_design_changes"].includes(String(r.fact.kind))))
+                    return failure("TERMINAL_CONFLICT", "A successful terminal is already durable; only identical acknowledged submissions may be replayed");
+                const draft = structuredClone(input.store);
+                input.setWorkingStore(draft);
+                let result;
+                try {
+                    // Protocol controls must not be spread into domain facts by permissive callers.
+                    const original = input.tools.find(t => t.name === tool.name);
+                    const domainParams = { ...params };
+                    if (!original.parameters.properties?.replace)
+                        delete domainParams.replace;
+                    result = await tool.execute(args[0], domainParams, ...args.slice(2));
+                }
+                finally {
+                    input.setWorkingStore(input.store);
+                }
+                if (result.details?.ok !== true)
+                    return result;
+                const newRecords = draft.records.filter(r => r.phase === "committed" && r.revision > input.store.revision);
+                if (!newRecords.length)
+                    return replay(result);
+                for (const record of draft.records) {
+                    record.submission ??= { version: 1, bindingSha256, tool: "bootstrap", callId: record.requestId, identity: record.eventId, paramsSha256: record.payloadSha256 };
+                }
+                for (const record of newRecords)
+                    record.submission = { version: 1, bindingSha256, tool: tool.name, callId, identity, paramsSha256 };
+                newRecords.at(-1).submission.receipt = JSON.parse(JSON.stringify(result));
+                const committed = draft.records.filter(r => r.phase === "committed");
+                await validate(committed);
+                await persist(file, committed);
+                publish(draft);
+                progress.durableSubmissions++;
+                if (previousFact)
+                    progress.durableReplacements++;
+                return result;
+            }
+            catch (error) {
+                input.setWorkingStore(input.store);
+                return failure(typeof error?.code === "string" ? error.code : "FRONTEND_COMMIT_FAILED", error instanceof Error ? error.message : String(error));
+            }
+        }).then(result => { if (result.details?.ok !== true)
+            progress.failedRecords++; return result; }) }));
+    for (const tool of wrapped)
+        progressByTool.set(tool, progress);
+    return {
+        customTools: wrapped,
+        commitExternal: (work) => exclusive(file, async () => {
+            await restore();
+            const draft = structuredClone(input.store);
+            input.setWorkingStore(draft);
+            try {
+                await work();
+                const newRecords = draft.records.filter(r => r.phase === "committed" && r.revision > input.store.revision);
+                for (const record of draft.records) {
+                    record.submission ??= {
+                        version: 1,
+                        bindingSha256,
+                        tool: "external-adoption",
+                        callId: record.requestId,
+                        identity: record.eventId,
+                        paramsSha256: record.payloadSha256,
+                    };
+                }
+                const committed = draft.records.filter(r => r.phase === "committed");
+                await validate(committed);
+                await persist(file, committed);
+                publish(draft);
+                progress.durableSubmissions += newRecords.length;
+            }
+            finally {
+                input.setWorkingStore(input.store);
+            }
+        }),
+        flush: () => exclusive(file, async () => {
+            await restore();
+            const committed = input.store.records.filter(r => r.phase === "committed");
+            await validate(committed);
+            await persist(file, committed);
+        }),
+    };
+}

package/dist/workflows/dag/frontend-execution-groups.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/** Model-authored execution ownership; never replaces a source obligation. */
+export const frontendExecutionSchema = z.object({
+    groupId: z.string().trim().min(1),
+    kind: z.enum(["behavior", "constraint", "exclusion"]),
+    summary: z.string().trim().min(1),
+}).strict();
+/** Latest canonical member wins; joining a group requires consistent metadata.
+ * No lexical/semantic similarity heuristic can erase a source ID or condition. */
+export function collectFrontendExecutionGroups(units) {
+    const groups = new Map();
+    for (const unit of new Map(units.map(unit => [unit.id, unit])).values()) {
+        const execution = unit.execution === undefined ? undefined : frontendExecutionSchema.parse(unit.execution);
+        const key = execution ? `group:${execution.groupId}` : `requirement:${unit.id}`;
+        const previous = groups.get(key);
+        if (previous && execution && (previous.kind !== execution.kind || previous.summary !== execution.summary))
+            throw Error(`EXECUTION_GROUP_CONFLICT: ${execution.groupId}; preserve differing permissions, thresholds and error paths as separate obligations/groups`);
+        if (previous)
+            previous.requirementIds.push(unit.id);
+        else
+            groups.set(key, { id: execution?.groupId ?? unit.id, kind: execution?.kind ?? "unclassified", summary: execution?.summary ?? `Independent requirement ${unit.id}`, requirementIds: [unit.id] });
+    }
+    return [...groups.values()];
+}