@tea-agent/loop-agent 0.39.0-beta.10 → 0.39.0-beta.12

package/dist/workflows/dag/node-execution.js

@@ -238,6 +238,163 @@ async function readFrontendPlanCommittedSnapshot(runDir, nodeId) {
     const hasTerminalFact = committed.some((record) => record.fact.kind === "finalize_plan");
     return { digest, hasTerminalFact };
 }
+function planInputRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function planInputText(value, maxChars = 240) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length <= maxChars
+        ? normalized
+        : `${normalized.slice(0, maxChars - 1)}…`;
+}
+function planInputStrings(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+/** Input bound for the planner evidence block; protects the model input budget. */
+const FRONTEND_PLAN_INPUT_MAX_CHARS = 12_000;
+const FRONTEND_PLAN_INPUT_CAP_LADDER = [
+    { text: 240, array: 40 },
+    { text: 120, array: 20 },
+    { text: 60, array: 10 },
+    { text: 24, array: 4 },
+];
+/**
+ * Render the planner's complete-but-bounded evidence handoff from committed
+ * typed facts. It deliberately excludes upstream response prose and artifact
+ * paths: Contract and Scout have already established these facts, so Plan
+ * should decide and commit rather than spend another model turn reading them.
+ *
+ * The block is always valid JSON under the char bound: field texts shrink
+ * through a cap ladder before any fact is dropped, and the last-resort
+ * fallback keeps every requirement id (with `text: "(truncated)"`) while
+ * declaring the degradation, so the planner records targeted evidence gaps
+ * instead of receiving a silently corrupted tail.
+ */
+export function renderFrontendPlanInputContext(input) {
+    const committedFacts = (records) => records.flatMap((record) => record.phase === "committed" && planInputRecord(record.fact)
+        ? [record.fact]
+        : []);
+    const contractFacts = committedFacts(input.contractRecords);
+    const scoutFacts = committedFacts(input.scoutRecords);
+    const requirements = contractFacts
+        .filter((fact) => fact.kind === "requirement" && fact.origin === "contract")
+        .map((fact) => ({
+        id: planInputText(fact.id, 80),
+        text: planInputText(fact.text),
+        sourceFragmentIds: planInputStrings(fact.sourceFragmentIds),
+    }))
+        .filter((fact) => fact.id !== undefined);
+    const targetSurface = scoutFacts
+        .filter((fact) => fact.kind === "target-surface" && fact.origin === "scout")
+        .map((fact) => ({
+        completeness: fact.completeness,
+        entrypoint: fact.entrypoint,
+        routeOrMount: fact.routeOrMount,
+        implementationPaths: fact.implementationPaths,
+        testPaths: fact.testPaths,
+        dataSource: fact.dataSource,
+        allowedPathConflicts: fact.allowedPathConflicts,
+        unresolvedPaths: fact.unresolvedPaths,
+    }));
+    const designEvidence = scoutFacts
+        .filter((fact) => fact.kind === "design-evidence" && fact.origin === "scout")
+        .map((fact) => ({
+        source: fact.source,
+        paths: fact.paths,
+        conflicts: fact.conflicts,
+    }));
+    const serializeAtCap = (cap) => JSON.stringify({
+        requirements: requirements.map((requirement) => ({
+            id: requirement.id,
+            text: planInputText(requirement.text, cap.text),
+            sourceFragmentIds: planInputStrings(requirement.sourceFragmentIds).slice(0, cap.array),
+        })),
+        targetSurface: targetSurface.map((surface) => ({
+            completeness: planInputText(surface.completeness, 32),
+            entrypoint: planInputText(surface.entrypoint, cap.text),
+            routeOrMount: planInputText(surface.routeOrMount, cap.text),
+            implementationPaths: planInputStrings(surface.implementationPaths).slice(0, cap.array),
+            testPaths: planInputStrings(surface.testPaths).slice(0, cap.array),
+            dataSource: planInputText(surface.dataSource, cap.text),
+            allowedPathConflicts: planInputStrings(surface.allowedPathConflicts).slice(0, cap.array),
+            unresolvedPaths: planInputStrings(surface.unresolvedPaths).slice(0, cap.array),
+        })),
+        designEvidence: designEvidence.map((evidence) => ({
+            source: planInputText(evidence.source, cap.text),
+            paths: planInputStrings(evidence.paths).slice(0, cap.array),
+            conflicts: planInputStrings(evidence.conflicts).slice(0, cap.array),
+        })),
+    });
+    let serialized = serializeAtCap(FRONTEND_PLAN_INPUT_CAP_LADDER[0]);
+    for (const cap of FRONTEND_PLAN_INPUT_CAP_LADDER.slice(1)) {
+        if (serialized.length <= FRONTEND_PLAN_INPUT_MAX_CHARS)
+            break;
+        serialized = serializeAtCap(cap);
+    }
+    if (serialized.length > FRONTEND_PLAN_INPUT_MAX_CHARS) {
+        // Last resort: keep every requirement id (ids are short and the plan
+        // prompt separately lists them) but drop their texts, shrink scout facts
+        // to the minimum, and declare the degradation instead of corrupting JSON.
+        let fallback = {
+            degraded: "requirement-texts-truncated",
+            requirements: requirements.map((requirement) => ({
+                id: requirement.id,
+                text: "(truncated)",
+            })),
+            targetSurface: targetSurface.map((surface) => ({
+                completeness: planInputText(surface.completeness, 32),
+                implementationPaths: planInputStrings(surface.implementationPaths).slice(0, FRONTEND_PLAN_INPUT_CAP_LADDER[3].array),
+            })),
+            designEvidence: [],
+        };
+        let bounded = JSON.stringify(fallback);
+        let keep = fallback.requirements.length;
+        while (bounded.length > FRONTEND_PLAN_INPUT_MAX_CHARS &&
+            keep > 0) {
+            keep = Math.max(0, Math.floor(keep / 2));
+            fallback = { ...fallback, requirements: fallback.requirements.slice(0, keep) };
+            bounded = JSON.stringify({
+                ...fallback,
+                requirementIdsTruncated: keep < requirements.length,
+            });
+        }
+        serialized = bounded;
+    }
+    return [
+        "<frontend_plan_input>",
+        "Committed Contract/Scout facts, compiled by the runner. Treat them as the complete planning evidence.",
+        serialized,
+        "Do not read upstream artifacts, task sources, or repository files. If this input cannot support a decision, record a genuine evidence gap.",
+        "</frontend_plan_input>",
+    ].join("\n");
+}
+export async function buildFrontendPlanInputContext(runDir) {
+    const contractFactsPath = path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl");
+    const scoutFactsPath = path.join(runDir, "frontend-scout-pi", "scout-typed-facts.jsonl");
+    let contractRecords;
+    let scoutRecords;
+    try {
+        [contractRecords, scoutRecords] = await Promise.all([
+            readTypedEventStoreFromJsonl(contractFactsPath),
+            readTypedEventStoreFromJsonl(scoutFactsPath),
+        ]);
+    }
+    catch (error) {
+        // A missing/unreadable upstream store is a broken pipeline, not an
+        // evidence gap; fail before spending a model turn on a prompt that
+        // forbids reading anything.
+        throw new Error(`frontend-plan-input-unavailable: cannot read committed typed facts (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const committedCount = [...contractRecords, ...scoutRecords].filter((record) => record.phase === "committed").length;
+    if (committedCount === 0) {
+        throw new Error(`frontend-plan-input-unavailable: no committed Contract/Scout facts in ${contractFactsPath} / ${scoutFactsPath}`);
+    }
+    return renderFrontendPlanInputContext({ contractRecords, scoutRecords });
+}
 export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics, frontendPlanRetryStep) {
     if (attemptNumber <= 1)
         return basePrompt;
@@ -938,6 +1095,17 @@ export async function executeDagNode(input) {
         await failSkillSnapshot(error);
         return;
     }
+    if (isFrontendPlanLadderTask(task)) {
+        let planInputContext;
+        try {
+            planInputContext = await buildFrontendPlanInputContext(runDir);
+        }
+        catch (error) {
+            await failBeforePrompt(error, "frontend-plan-input-unavailable");
+            return;
+        }
+        prompt = `${prompt}\n\n${planInputContext}`;
+    }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);
     let model = resolveModelForTask(task, spec.executorModels);

package/dist/workflows/dag/types.js

@@ -770,6 +770,8 @@ export const dagDynamicExpansionChildTaskSchema = z.object({
     allowedPaths: z.array(z.string()).optional().default([]),
     forbiddenPaths: z.array(z.string()).optional().default([]),
     writeSet: z.array(z.string()).optional(),
+    /** Template-rendered strict repository-relative read allowlist. */
+    readSet: z.array(z.string()).optional(),
     /**
      * Materialized-child pass-through fields for bounded Pi writer children
      * (backend-test md/pytest case sharding). All optional so legacy
@@ -970,6 +972,21 @@ export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/
     commandPolicy: dagCommandPolicySchema.optional(),
     writePolicy: dagWritePolicySchema.optional(),
     writeSet: z.array(z.string()).optional(),
+    /** Strict repository-relative read allowlist for bounded Pi nodes. */
+    readSet: z.array(z.string()).optional(),
+    /**
+     * Online per-attempt Pi context guard. Unlike run/map cost budgets, this
+     * aborts the active SDK session before an oversized conversation reaches
+     * the provider's context rejection boundary.
+     */
+    contextBudget: z
+        .object({
+        maxTurns: z.number().int().positive().optional(),
+        maxTokens: z.number().int().positive().optional(),
+    })
+        .strict()
+        .refine((value) => value.maxTurns !== undefined || value.maxTokens !== undefined, "contextBudget requires maxTurns or maxTokens")
+        .optional(),
     piStep: z.string().optional(),
     shell: dagShellConfigSchema.optional(),
     static: dagStaticConfigSchema.optional(),

package/docs/templates/README.md

@@ -38,6 +38,7 @@
 
 - `frontend-task-requirement.md`、`frontend-task-constraints.md`、`frontend-design-contract.md` — 前端任务输入与设计合同。
 - `frontend-implementation-contract.schema.json` — 前端实现合同 schema（sourceBinding v2 ledger 字段 all-or-none：任一出现则四项齐全，禁止 v1+optional 冒充 v2）。`requirements[].sourceRefs[].items` 使用合法 `$ref: #/$defs/path`（相对路径、无 `..` 逃逸、无反斜杠），模板 JSON 无非法键，运行时加载器可直接编译（AC-003）。
+- `frontend-implementation-dag.json` — 自包含的前端实现 DAG 模板：契约 → 侦察 → 计划 → 设计策略/评审 → writer 准入 → 有界写入 → 验证 → 真实 diff 审查 → closeout。它不依赖 runtime builder 或其他模板；执行前必须将所有 `REPLACE/WITH/...` 路径和确定性命令替换为当前项目的具体值。
 - `frontend-test-dag.json` — frontend-test DAG 模板；其 deterministic checklist 会拒绝 alternative executable instructions，仅允许 allowlisted `playwright-cli` command。Pi generator/reviser 的 runtime writeSet 仅授权下列目标项目生成路径（不是本仓库文档索引目标）：
 
   ~~~text

package/docs/templates/agent-dag.schema.json

@@ -538,6 +538,24 @@
           "type": "array",
           "items": { "type": "string", "minLength": 1 }
         },
+        "readSet": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "description": "Strict repository-relative read allowlist for bounded Pi nodes."
+        },
+        "contextBudget": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "Online per-attempt Pi SDK conversation guard. At least one threshold is required; exhaustion aborts the active session with context-budget-exhausted partial evidence.",
+          "properties": {
+            "maxTurns": { "type": "integer", "minimum": 1 },
+            "maxTokens": { "type": "integer", "minimum": 1 }
+          },
+          "anyOf": [
+            { "required": ["maxTurns"] },
+            { "required": ["maxTokens"] }
+          ]
+        },
         "piStep": {
           "type": "string",
           "minLength": 1