@tea-agent/loop-agent 0.16.1-beta.2 → 0.16.2

package/dist/workflows/dag/context-policy.js

@@ -0,0 +1,137 @@
+import { DEFAULT_SKILL_INSTRUCTION_MAX_CHARS, DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS, } from "./skill-instructions.js";
+import { MAX_UPSTREAM_CHARS } from "./prompt.js";
+import { resolveDagNodeSkills } from "./skills.js";
+export const CONTEXT_POLICY_IDS = [
+    "baseline-v1",
+    "role-specialized-v1",
+];
+export const DEFAULT_CONTEXT_POLICY_ID = "baseline-v1";
+function roleOrUndefined(task) {
+    return task.role;
+}
+function pickByRole(table, role) {
+    if (role && table[role] !== undefined)
+        return table[role];
+    return table.default;
+}
+class BaselineContextPolicy {
+    id = "baseline-v1";
+    description = "Current DAG context assembly: shared upstream char budget, role skill defaults, learned patterns only for implementer.";
+    resolveSkills(spec, task) {
+        return resolveDagNodeSkills(spec, task);
+    }
+    resolveSkillInstructionBudget(task) {
+        return {
+            includeLearnedPatterns: task.role === "implementer",
+            perSkillMaxChars: DEFAULT_SKILL_INSTRUCTION_MAX_CHARS,
+            totalMaxChars: DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS,
+        };
+    }
+    resolveMaxUpstreamChars(_task) {
+        return MAX_UPSTREAM_CHARS;
+    }
+    toManifest() {
+        return {
+            schemaVersion: 1,
+            policyId: this.id,
+            description: this.description,
+            knobs: {
+                maxUpstreamCharsByRole: { default: MAX_UPSTREAM_CHARS },
+                includeLearnedPatternsRoles: ["implementer"],
+                perSkillMaxCharsByRole: {
+                    default: DEFAULT_SKILL_INSTRUCTION_MAX_CHARS,
+                },
+                totalMaxCharsByRole: {
+                    default: DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS,
+                },
+            },
+        };
+    }
+}
+/**
+ * First A/B challenger: keep skill name resolution identical to baseline, but
+ * specialize upstream / skill-instruction budgets by role so scouts see less
+ * noise and implementers retain more upstream + learned patterns surface.
+ */
+class RoleSpecializedContextPolicy {
+    id = "role-specialized-v1";
+    description = "Role-specialized upstream and skill-instruction budgets; skill names still resolve via baseline merge order.";
+    maxUpstreamCharsByRole = {
+        default: MAX_UPSTREAM_CHARS,
+        scout: 1_200,
+        reviewer: 1_200,
+        implementer: 3_000,
+        verifier: 1_600,
+        closeout: 1_600,
+        planner: MAX_UPSTREAM_CHARS,
+        supervisor: MAX_UPSTREAM_CHARS,
+    };
+    perSkillMaxCharsByRole = {
+        default: DEFAULT_SKILL_INSTRUCTION_MAX_CHARS,
+        scout: 2_500,
+        implementer: 3_500,
+    };
+    totalMaxCharsByRole = {
+        default: DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS,
+        scout: 10_000,
+        implementer: 14_000,
+    };
+    learnedPatternRoles = new Set([
+        "implementer",
+        "closeout",
+    ]);
+    resolveSkills(spec, task) {
+        return resolveDagNodeSkills(spec, task);
+    }
+    resolveSkillInstructionBudget(task) {
+        const role = roleOrUndefined(task);
+        return {
+            includeLearnedPatterns: role
+                ? this.learnedPatternRoles.has(role)
+                : false,
+            perSkillMaxChars: pickByRole(this.perSkillMaxCharsByRole, role),
+            totalMaxChars: pickByRole(this.totalMaxCharsByRole, role),
+        };
+    }
+    resolveMaxUpstreamChars(task) {
+        return pickByRole(this.maxUpstreamCharsByRole, roleOrUndefined(task));
+    }
+    toManifest() {
+        return {
+            schemaVersion: 1,
+            policyId: this.id,
+            description: this.description,
+            knobs: {
+                maxUpstreamCharsByRole: this.maxUpstreamCharsByRole,
+                includeLearnedPatternsRoles: [...this.learnedPatternRoles],
+                perSkillMaxCharsByRole: this.perSkillMaxCharsByRole,
+                totalMaxCharsByRole: this.totalMaxCharsByRole,
+            },
+        };
+    }
+}
+const POLICIES = {
+    "baseline-v1": new BaselineContextPolicy(),
+    "role-specialized-v1": new RoleSpecializedContextPolicy(),
+};
+export function isContextPolicyId(value) {
+    return CONTEXT_POLICY_IDS.includes(value);
+}
+export function getContextPolicy(policyId) {
+    return POLICIES[policyId];
+}
+export function listContextPolicies() {
+    return CONTEXT_POLICY_IDS.map((id) => POLICIES[id]);
+}
+export function resolveContextPolicyId(spec) {
+    const raw = spec.defaults?.contextPolicyId;
+    if (!raw)
+        return DEFAULT_CONTEXT_POLICY_ID;
+    if (!isContextPolicyId(raw)) {
+        throw new Error(`unknown contextPolicyId "${raw}"; expected one of ${CONTEXT_POLICY_IDS.join(", ")}`);
+    }
+    return raw;
+}
+export function resolveContextPolicy(spec) {
+    return getContextPolicy(resolveContextPolicyId(spec));
+}

package/dist/workflows/dag/dynamic-runtime/condition.js

@@ -1,5 +1,5 @@
 import { parseConditionLiteral, resolveOutputSelector } from "./shared.js";
-function evaluateConditionExpression(expression, state) {
+export function evaluateConditionExpression(expression, state) {
     const equality = expression.match(/^\s*(\$\..+?)\s*==\s*(.+?)\s*$/);
     if (!equality?.[1]) {
         throw new Error(`unsupported condition expression: ${expression}`);

package/dist/workflows/dag/dynamic-runtime/shared.js

@@ -28,7 +28,49 @@ export function getNodeOutputAsJson(state, nodeId) {
         throw new Error(`itemsFrom upstream node "${nodeId}" output is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/** Normalize a line the same way verdict gates do (strip whole-line Markdown emphasis). */
+export function normalizeVerdictCandidateLine(value) {
+    const trimmed = String(value).trim();
+    const emphasized = trimmed.match(/^\*{1,3}\s*(VERDICT:[^*]+?)\s*\*{1,3}$/);
+    return (emphasized ? emphasized[1] : trimmed).trim();
+}
+/** First line matching /^VERDICT:/ from node assistantText/stdout (markdown emphasis OK). */
+export function extractFirstVerdictLineFromNodeText(text) {
+    for (const line of String(text).split(/\r?\n/)) {
+        const normalized = normalizeVerdictCandidateLine(line);
+        if (/^VERDICT:/.test(normalized))
+            return normalized;
+    }
+    return "";
+}
+function getNodeRawText(state, nodeId) {
+    const record = state.nodes[nodeId];
+    if (!record || record.status !== "FINISHED") {
+        throw new Error(`selector upstream node "${nodeId}" is not finished`);
+    }
+    return record.assistantText?.trim() || record.stdout?.trim() || "";
+}
 export function resolveOutputSelector(selector, state) {
+    const firstVerdictMatch = selector.match(/^\$\.nodes\[['"]([^'"]+)['"]\]\.firstVerdictLine\s*$/);
+    if (firstVerdictMatch?.[1]) {
+        const nodeId = firstVerdictMatch[1];
+        return extractFirstVerdictLineFromNodeText(getNodeRawText(state, nodeId));
+    }
+    const jsonFieldMatch = selector.match(/^\$\.nodes\[['"]([^'"]+)['"]\]\.json\.([A-Za-z0-9_.-]+)\s*$/);
+    if (jsonFieldMatch?.[1] && jsonFieldMatch[2]) {
+        let current = parseJsonFromText(getNodeRawText(state, jsonFieldMatch[1]));
+        if (current === undefined) {
+            throw new Error(`selector upstream node "${jsonFieldMatch[1]}" output is not valid JSON`);
+        }
+        for (const segment of jsonFieldMatch[2].split(".")) {
+            if (current && typeof current === "object" && segment in current) {
+                current = current[segment];
+                continue;
+            }
+            throw new Error(`output selector path not found: ${selector} (missing "${segment}")`);
+        }
+        return current;
+    }
     const match = selector.match(/^\$\.nodes\[['"]([^'"]+)['"]\]\.output(?:\.(.+))?$/);
     if (!match?.[1]) {
         throw new Error(`unsupported itemsFrom selector: ${selector}`);

package/dist/workflows/dag/failure-routing.js

@@ -46,6 +46,13 @@ function routeToProductLine(input) {
         case "skipped":
             return "DependencyFailure";
         case "shell-command":
+            if (/\b(ENOENT|PATH|command not found|No such file|not found in PATH|bash: .*: No such file)\b/i.test(raw)) {
+                return "EnvFailure";
+            }
+            if (/\b(missing VERDICT line|verdict gate blocked|VERDICT)\b/i.test(raw) &&
+                /\b(missing|malformed|unexpected|blocked)\b/i.test(raw)) {
+                return "ContractMismatch";
+            }
             if (raw.includes("flaky"))
                 return "FlakyTest";
             if (nodeId.includes("test") || raw.includes("test-bug")) {
@@ -79,7 +86,7 @@ function routeToProductLine(input) {
     }
 }
 export function routeDagFailure(input) {
-    const productLineFailureCategory = routeToProductLine(input);
+    const productLineFailureCategory = input.productLineFailureCategory ?? routeToProductLine(input);
     if (!productLineFailureCategory)
         return {};
     const recommendedFollowUp = productLineFailureCategory === "ContractMismatch" &&

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

@@ -1,86 +1,9 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
-import { findPackageRoot } from "../../shared/package-metadata.js";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
-/**
- * Load the canonical frontend-implementation-contract-v1 JSON Schema from the
- * installed loop-agent package docs/templates/ path. Package-root discovery
- * works from both the source module and the compiled dist module without
- * relying on CommonJS globals in the ESM runtime.
- *
- * Validation is fail-closed: missing file, malformed JSON, mismatched $id,
- * missing additionalProperties: false, or incomplete top-level required keys
- * all throw before any DAG prompt is assembled.
- */
-export function loadFrontendImplementationContractJsonSchema(startDir = path.dirname(fileURLToPath(import.meta.url))) {
-    const packageRoot = findPackageRoot(startDir);
-    if (!packageRoot) {
-        throw new Error(`cannot locate loop-agent package root from ${path.resolve(startDir)}`);
-    }
-    const schemaPath = path.join(packageRoot, "docs", "templates", "frontend-implementation-contract.schema.json");
-    let content;
-    try {
-        content = readFileSync(schemaPath, "utf-8");
-    }
-    catch (error) {
-        throw new Error(`cannot load frontend-implementation-contract.schema.json from current loop-agent package at ${schemaPath}: ${error.code ?? String(error)}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`frontend-implementation-contract.schema.json is not valid JSON: ${error.message}`);
-    }
-    if (parsed === null || typeof parsed !== "object") {
-        throw new Error("frontend-implementation-contract.schema.json root is not a JSON object");
-    }
-    const schema = parsed;
-    if (schema.$id !== FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID) {
-        throw new Error(`schema $id mismatch: expected ${FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID}, got ${String(schema.$id)}`);
-    }
-    if (schema.additionalProperties !== false) {
-        throw new Error("schema must have additionalProperties: false at top level");
-    }
-    const expectedRequired = [
-        "schemaVersion",
-        "sourceBinding",
-        "riskLevel",
-        "targets",
-        "requirements",
-        "uiStates",
-        "interactions",
-        "mockApi",
-        "designEvidence",
-        "verificationTargets",
-        "evidenceGaps",
-    ];
-    const actualRequired = Array.isArray(schema.required) ? schema.required : [];
-    const missing = expectedRequired.filter((key) => !actualRequired.includes(key));
-    if (missing.length > 0) {
-        throw new Error(`schema required fields missing: ${missing.join(", ")}`);
-    }
-    const properties = schema.properties && typeof schema.properties === "object"
-        ? schema.properties
-        : {};
-    const missingProperties = expectedRequired.filter((key) => !Object.hasOwn(properties, key));
-    if (missingProperties.length > 0) {
-        throw new Error(`schema properties missing: ${missingProperties.join(", ")}`);
-    }
-    const schemaVersion = properties.schemaVersion;
-    const mockApi = properties.mockApi;
-    const mockApiProperties = mockApi?.properties;
-    const productionDefaultOff = mockApiProperties?.productionDefaultOff;
-    if (schemaVersion?.const !== 1 || productionDefaultOff?.const !== true) {
-        throw new Error("schema fixed values are incomplete: schemaVersion.const must be 1 and mockApi.productionDefaultOff.const must be true");
-    }
-    return JSON.stringify(parsed);
-}
 const id = z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/);
 const safePath = z
     .string()
@@ -263,6 +186,26 @@ export function extractFrontendImplementationJson(text) {
         throw new Error("output must contain exactly one fenced json object");
     return JSON.parse(blocks[0][1]);
 }
+/**
+ * Build the authoritative frontend-implementation-contract sourceBinding from
+ * the DAG-owned binding. Model JSON must not invent taskId/path/sha256; the
+ * gate overwrites whatever the model emitted so identity cannot drift.
+ */
+export function canonicalFrontendContractSourceBinding(binding) {
+    const requirement = binding.sources.find((source) => source.kind === "requirement");
+    if (!requirement)
+        throw new Error("frontend implementation contract gate requires a requirement source in DAG sourceBinding");
+    return {
+        taskId: binding.taskId,
+        requirementPath: requirement.path,
+        requirementSha256: requirement.sha256,
+        referencePaths: binding.sources
+            .filter((source) => source.kind === "reference")
+            .map((source) => source.path)
+            .sort(),
+        requirementIds: [...binding.requirementIds],
+    };
+}
 export async function materializeFrontendImplementationContract(input) {
     if (!input.sourceBinding)
         throw new Error("frontend implementation contract gate requires DAG sourceBinding");
@@ -277,23 +220,19 @@ export async function materializeFrontendImplementationContract(input) {
     const secrets = secretIssues(parsed);
     if (secrets.length)
         throw new Error(`invalid-output: ${secrets.join("; ")}`);
-    const result = frontendImplementationContractSchema.safeParse(parsed);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("invalid-output: frontend contract must be a JSON object");
+    const canonicalBinding = canonicalFrontendContractSourceBinding(input.sourceBinding);
+    // Always inject DAG-owned identity. Model-provided sourceBinding is advisory
+    // only and must not fail a otherwise-valid contract (common live failure:
+    // wrong requirementPath/sha, extra referencePaths, or omitted binding).
+    const withCanonicalBinding = {
+        ...parsed,
+        sourceBinding: canonicalBinding,
+    };
+    const result = frontendImplementationContractSchema.safeParse(withCanonicalBinding);
     if (!result.success)
         throw new Error(`invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
-    const requirement = input.sourceBinding.sources.find((source) => source.kind === "requirement");
-    const refs = input.sourceBinding.sources
-        .filter((source) => source.kind === "reference")
-        .map((source) => source.path)
-        .sort();
-    const bound = result.data.sourceBinding;
-    if (!requirement ||
-        bound.taskId !== input.sourceBinding.taskId ||
-        bound.requirementPath !== requirement.path ||
-        bound.requirementSha256 !== requirement.sha256 ||
-        JSON.stringify([...bound.referencePaths].sort()) !== JSON.stringify(refs) ||
-        JSON.stringify(bound.requirementIds) !==
-            JSON.stringify(input.sourceBinding.requirementIds))
-        throw new Error("frontend contract source binding does not match DAG source binding");
     const blockingGaps = [
         ...result.data.evidenceGaps,
         ...result.data.requirements.flatMap((item) => item.evidenceGap ? [item.evidenceGap] : []),
@@ -302,7 +241,7 @@ export async function materializeFrontendImplementationContract(input) {
         throw new Error(`frontend contract has blocking evidence gap: ${blockingGaps
             .map((item) => item.requirementId ?? item.description)
             .join(", ")}`);
-    for (const requirementId of bound.requirementIds)
+    for (const requirementId of canonicalBinding.requirementIds)
         if (!result.data.requirements.some((item) => item.id === requirementId) &&
             !result.data.evidenceGaps.some((item) => item.requirementId === requirementId))
             throw new Error(`frontend contract does not cover ${requirementId}`);