@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

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

@@ -44,6 +44,8 @@ export const frontendCloseoutFactsSchema = z
         status: frontendCoverageStatusSchema,
         evidence: z.enum(["file-exists", "command-execution", "test-file-execution", "unavailable"]).optional(),
         behaviorCoverage: z.enum(["unconfirmed"]).optional(),
+        plannedEvidenceLevel: z.enum(["unit", "mounted", "real-integration", "unknown"]).optional(),
+        boundary: z.string().min(1).optional(),
     })
         .strict()),
     lintStatus: frontendLintStatusSchema,
@@ -145,7 +147,7 @@ function bulletList(items) {
     return items.map((item) => `- ${item}`).join("\n");
 }
 function coverageLines(facts) {
-    const lines = facts.coverageMatrix.map((entry) => `- ${entry.verificationTargetId}: execution=${entry.status}; evidence=${entry.evidence ?? "unspecified"}; behavior-coverage=${entry.behaviorCoverage ?? "unconfirmed"}`);
+    const lines = facts.coverageMatrix.map((entry) => `- ${entry.verificationTargetId}: execution=${entry.status}; evidence=${entry.evidence ?? "unspecified"}; behavior-coverage=${entry.behaviorCoverage ?? "unconfirmed"}; planned-evidence=${entry.plannedEvidenceLevel ?? "unknown"}${entry.boundary ? `; boundary=${entry.boundary}` : ""}`);
     return lines.length > 0 ? lines.join("\n") : "_(none)_";
 }
 function frontendStatus(facts) {

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

@@ -5,7 +5,8 @@ function object(value) {
         ? value
         : undefined;
 }
-/** Join requirement-owned identity with separately committed evidence by id.
+/** Project the latest requirement per id while retaining first-seen order.
+ * The append-only ledger also contains earlier execution metadata revisions.
  * Later evidence declarations replace only the lanes they explicitly name. */
 export function resolveFrontendContractRequirements(facts) {
     const contractFacts = facts.map(object).filter((fact) => fact?.origin === "contract");
@@ -19,13 +20,15 @@ export function resolveFrontendContractRequirements(facts) {
             ...object(fact.evidence),
         });
     }
-    return contractFacts.flatMap((fact) => fact.kind === "requirement" && typeof fact.id === "string"
-        ? [{
-                ...fact,
-                id: fact.id,
-                evidence: { ...object(fact.evidence), ...evidenceById.get(fact.id) },
-            }]
-        : []);
+    const requirements = new Map();
+    for (const fact of contractFacts) {
+        if (fact.kind === "requirement" && typeof fact.id === "string")
+            requirements.set(fact.id, fact);
+    }
+    return [...requirements].map(([id, fact]) => ({
+        ...fact, id,
+        evidence: { ...object(fact.evidence), ...evidenceById.get(id) },
+    }));
 }
 function names(value) {
     return Array.isArray(value)

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

@@ -243,9 +243,9 @@ export function checkComponentChoice(contract, componentSpecCandidatePaths, opti
     });
     return findings;
 }
-/** 5. Every implementation target and every non-static verification target
- * must fall inside the declared writeSet patterns. */
-export function checkTargetPaths(contract, writeSetPatterns) {
+/** 5. Implementation targets require write permission. Existing, safely
+ * resolved verification files may remain read-only outside that writeSet. */
+export function checkTargetPaths(contract, writeSetPatterns, existingVerificationPaths = []) {
     const findings = [];
     // No frozen writeSet patterns (legacy / unconfigured run) → nothing to
     // check; an empty pattern set must not report every file as out of scope.
@@ -275,7 +275,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
     for (const target of contract.verificationTargets) {
         if (target.mode === "static")
             continue;
-        if (!matches(target.file)) {
+        if (!matches(target.file) && !existingVerificationPaths.includes(target.file)) {
             findings.push({
                 code: "target-path-outside-write-set",
                 message: `verification target "${target.id}" file is outside the writeSet patterns: ${target.file}`,
@@ -442,7 +442,7 @@ export function checkRequiredDeliverables(contract) {
         return [];
     const planned = new Set([
         ...contract.targets.files,
-        ...contract.requirements.flatMap((requirement) => requirement.implementationTargets),
+        ...contract.requirements.flatMap((requirement) => [...requirement.implementationTargets, ...(requirement.deliverableTargets ?? [])]),
         ...contract.verificationTargets.map((target) => target.file),
     ]);
     return required
@@ -464,7 +464,7 @@ export function evaluateFrontendDesignPolicy(input) {
         ...checkComponentChoice(input.contract, input.componentSpecCandidatePaths, input.hasFreshPathEvidence
             ? { hasFreshPathEvidence: input.hasFreshPathEvidence }
             : undefined),
-        ...checkTargetPaths(input.contract, input.writeSetPatterns),
+        ...checkTargetPaths(input.contract, input.writeSetPatterns, input.existingVerificationPaths),
         ...checkDependencies(input.contract, input.allowedDependencies),
         ...checkUiStateAttribution(input.contract),
         ...checkUxNameCollisions(input.contract),

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

@@ -1,3 +1,4 @@
+import { frontendPlanSemanticDigest } from "./frontend-plan-progress.js";
 import { mkdir, open, rename, rm } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
@@ -12,7 +13,7 @@ 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 });
+    return counters.reduce((sum, item) => ({ finalizeRejections: sum.finalizeRejections + item.finalizeRejections, failedRecords: sum.failedRecords + item.failedRecords, duplicateRecords: sum.duplicateRecords + item.duplicateRecords, durableSubmissions: sum.durableSubmissions + item.durableSubmissions, durableReplacements: sum.durableReplacements + item.durableReplacements }), { finalizeRejections: 0, failedRecords: 0, duplicateRecords: 0, durableSubmissions: 0, durableReplacements: 0 });
 }
 async function exclusive(key, work) {
     const previous = queues.get(key) ?? Promise.resolve();
@@ -61,7 +62,8 @@ export async function createDurableFrontendTools(input) {
         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 publish = (store) => { input.store.records = store.records; input.store.revision = store.revision; input.setWorkingStore(input.store); if (hasCommittedTerminalEvent(store, input.attemptId))
+        input.planControl?.acceptTerminal(); };
     const validate = async (records) => {
         let revision = 0;
         let terminal = false;
@@ -89,81 +91,99 @@ export async function createDurableFrontendTools(input) {
             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 progress = { finalizeRejections: 0, 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", "finalize_decision"]);
-                const naturalId = params?.id ?? params?.scopeId ?? params?.entry?.id ?? params?.requirementId ?? params?.choice?.purpose ?? params?.entry?.purpose ?? params?.entry?.state ?? params?.entry?.interaction ?? params?.entry?.boundary ?? (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);
-                // A committed finalize terminal carries no domain payload in its params
-                // (r15: the model acknowledged with {replace:false}, the executor's
-                // auto-finalize sends {}) — both are acknowledgements of the same durable
-                // terminal, so any later finalize call replays the receipt instead of
-                // demanding a params match no caller can reproduce. Other singletons
-                // (state registry, data flows, ...) carry domain payloads and keep the
-                // replace:true correction path.
-                if (FINALIZE_TERMINAL_TOOLS.has(tool.name) && previousFact?.receipt)
-                    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", "finalize_decision", "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;
+            const beforeRevision = input.store.revision;
+            const execute = async () => {
+                const stopped = input.planControl?.readStop();
+                if (stopped)
+                    return failure(stopped.code, stopped.error);
+                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 {
-                    // 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));
+                    await restore();
+                    const isReviewFinding = ["record_review_finding", "record_design_finding"].includes(tool.name);
+                    const paramsSha256 = hash(isReviewFinding ? { ...params, replace: undefined } : 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", "finalize_decision"]);
+                    const naturalId = params?.id ?? params?.scopeId ?? params?.entry?.id ?? params?.requirementId ?? params?.choice?.purpose ?? params?.entry?.purpose ?? params?.entry?.state ?? params?.entry?.interaction ?? params?.entry?.boundary ?? (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 (isReviewFinding && !previousFact && params?.replace === true)
+                        return failure("FACT_REPLACEMENT_NOT_FOUND", `${identity}: replacement requires an existing finding; omit replace to create it`);
+                    if (tool.name !== "record_plan_group_coverage" && previousFact?.paramsSha256 === paramsSha256)
+                        return replay(previousFact.receipt);
+                    // A committed finalize terminal carries no domain payload in its params
+                    // (r15: the model acknowledged with {replace:false}, the executor's
+                    // auto-finalize sends {}) — both are acknowledgements of the same durable
+                    // terminal, so any later finalize call replays the receipt instead of
+                    // demanding a params match no caller can reproduce. Other singletons
+                    // (state registry, data flows, ...) carry domain payloads and keep the
+                    // replace:true correction path.
+                    if (FINALIZE_TERMINAL_TOOLS.has(tool.name) && previousFact?.receipt)
+                        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", "finalize_decision", "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;
                 }
-                finally {
+                catch (error) {
                     input.setWorkingStore(input.store);
+                    return failure(typeof error?.code === "string" ? error.code : "FRONTEND_COMMIT_FAILED", error instanceof Error ? error.message : String(error));
                 }
-                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));
+            };
+            const result = await execute();
+            if (result.details?.ok !== true) {
+                progress.failedRecords++;
+                if (FINALIZE_TERMINAL_TOOLS.has(tool.name))
+                    progress.finalizeRejections++;
             }
-        }).then(result => { if (result.details?.ok !== true)
-            progress.failedRecords++; return result; }) }));
+            const note = input.planControl?.observe(tool.name, args[1], result.details, input.store.revision > beforeRevision, input.planControl ? frontendPlanSemanticDigest(input.store.records) : undefined);
+            if (note)
+                return { ...result, content: [...(Array.isArray(result.content) ? result.content : []), { type: "text", text: JSON.stringify(note) }], details: { ...result.details, planProgress: note } };
+            return result;
+        }) }));
     for (const tool of wrapped)
         progressByTool.set(tool, progress);
     return {