@tea-agent/loop-agent 0.14.0 → 0.16.0

package/dist/worker/task-spec/workflow-routing.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+/**
+ * Explicit runtime workflow that routes a TaskSpec to a controller DAG.
+ *
+ * The workflow is orthogonal to the business {@link TaskSpec.type} and the
+ * governance `loop_agent` profile. It is the only field the materializer uses
+ * to derive {@link TaskKind} (written to `task.json.taskKind`) which the
+ * published controller turns into a concrete DAG.
+ */
+export const workflowSchema = z.enum([
+    "agent-dag",
+    "frontend-implementation",
+    "backend-test",
+    "frontend-test",
+]);
+/**
+ * Deterministic workflow → taskKind mapping.
+ *
+ * - `agent-dag` → `standard` (the default agent DAG).
+ * - The three remaining workflows map 1:1 to their same-named taskKind.
+ */
+export const WORKFLOW_TASK_KIND = {
+    "agent-dag": "standard",
+    "frontend-implementation": "frontend-implementation",
+    "backend-test": "backend-test",
+    "frontend-test": "frontend-test",
+};
+/**
+ * Legacy QA business types that have no deterministic backend/frontend split.
+ * Without an explicit {@link Workflow} they MUST surface migration guidance
+ * rather than silently guessing `backend-test` or `frontend-test`.
+ */
+export const LEGACY_QA_TYPES = new Set([
+    "qa-casegen",
+    "qa-testcode",
+    "qa-execute",
+]);
+/**
+ * Legacy business types that deterministically route to `frontend-implementation`.
+ */
+const FRONTEND_FEATURE_TYPES = new Set(["frontend-feature"]);
+/**
+ * Legacy business types that deterministically route to the `agent-dag`/`standard`
+ * DAG. Anything that is not a QA type and not a frontend-feature lands here.
+ */
+export function legacyDefaultWorkflow(type) {
+    return FRONTEND_FEATURE_TYPES.has(type) ? "frontend-implementation" : "agent-dag";
+}
+/** Migration guidance surfaced whenever a legacy QA type lacks an explicit workflow. */
+export const LEGACY_QA_MIGRATION_GUIDANCE = "Legacy qa-casegen/qa-testcode/qa-execute tasks no longer auto-select a backend or frontend workflow. " +
+    "Add `execution.workflow` with one of: agent-dag, frontend-implementation, backend-test, frontend-test. " +
+    "Use backend-test for backend-only test generation/execution, frontend-test for browser/UI tests, " +
+    "or agent-dag when the QA task is a generic agent study.";
+export class WorkflowRoutingError extends Error {
+    code;
+    migrationGuidance;
+    constructor(code, message, migrationGuidance) {
+        super(message);
+        this.name = "WorkflowRoutingError";
+        this.code = code;
+        this.migrationGuidance = migrationGuidance;
+    }
+}
+/**
+ * Resolve the runtime {@link Workflow} and {@link TaskKind} for a TaskSpec.
+ *
+ * Resolution order:
+ * 1. Explicit `taskSpec.execution?.workflow` (source: `explicit`).
+ * 2. Legacy `frontend-feature` → `frontend-implementation`.
+ * 3. Legacy `backend-feature` (and any non-QA legacy type) → `agent-dag`.
+ * 4. Legacy QA types ({@link LEGACY_QA_TYPES}) without an explicit workflow →
+ *    preserve their historic default `standard` execution as `agent-dag` and
+ *    emit migration guidance during validation. We never guess backend vs frontend.
+ *
+ * Compatibility between an explicit workflow and the business `type` must be
+ * validated first via {@link validateWorkflowCompatibility}; this function
+ * assumes the combination is already known-valid.
+ */
+export function resolveWorkflow(taskSpec) {
+    const explicit = taskSpec.execution?.workflow;
+    if (explicit) {
+        return {
+            workflow: explicit,
+            taskKind: WORKFLOW_TASK_KIND[explicit],
+            source: "explicit",
+        };
+    }
+    if (LEGACY_QA_TYPES.has(taskSpec.type)) {
+        return {
+            workflow: "agent-dag",
+            taskKind: WORKFLOW_TASK_KIND["agent-dag"],
+            source: "legacy-warning",
+        };
+    }
+    const workflow = legacyDefaultWorkflow(taskSpec.type);
+    return {
+        workflow,
+        taskKind: WORKFLOW_TASK_KIND[workflow],
+        source: "legacy-deterministic",
+    };
+}
+/**
+ * Deterministic compatibility validation between an explicit workflow and the
+ * business {@link TaskSpec.type}. Legacy QA types without an explicit workflow
+ * surface a single migration-guidance issue instead of a routing decision.
+ *
+ * Incompatible combinations (e.g. `frontend-feature` + `backend-test`,
+ * `backend-feature` + `frontend-implementation`, or a `qa-*` type paired with
+ * an implementation/test workflow from the wrong surface) are reported so the
+ * validator can fail fast rather than silently materializing a wrong DAG.
+ */
+export function validateWorkflowCompatibility(taskSpec) {
+    const explicit = taskSpec.execution?.workflow;
+    if (!explicit) {
+        if (LEGACY_QA_TYPES.has(taskSpec.type)) {
+            return { issues: [], migrationGuidance: LEGACY_QA_MIGRATION_GUIDANCE };
+        }
+        // Legacy backend/frontend feature and other non-QA types route deterministically.
+        return { issues: [] };
+    }
+    const issues = [];
+    const type = taskSpec.type;
+    if (type === "backend-feature" && explicit !== "agent-dag" && explicit !== "backend-test") {
+        issues.push({
+            code: "workflow-type-incompatible",
+            message: `backend-feature is incompatible with workflow "${explicit}" (expected agent-dag or backend-test)`,
+            path: "execution.workflow",
+        });
+    }
+    if (type === "frontend-feature" && explicit !== "frontend-implementation" && explicit !== "frontend-test") {
+        issues.push({
+            code: "workflow-type-incompatible",
+            message: `frontend-feature is incompatible with workflow "${explicit}" (expected frontend-implementation or frontend-test)`,
+            path: "execution.workflow",
+        });
+    }
+    if (LEGACY_QA_TYPES.has(type)) {
+        // qa-* types are allowed to opt into a concrete test/implementation workflow
+        // but never into a feature implementation surface that does not match QA intent.
+        if (explicit === "frontend-implementation") {
+            issues.push({
+                code: "workflow-type-incompatible",
+                message: `${type} is a QA type and cannot route to frontend-implementation; use frontend-test, backend-test, or agent-dag`,
+                path: "execution.workflow",
+            });
+        }
+    }
+    return { issues };
+}

package/dist/workflows/dag/budget-enforcement.js

@@ -0,0 +1,67 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { checkBudgetPreNode, createBudgetLedger, formatBudgetReportMarkdown, isHardBudgetBreached, recordNodeBudgetSample, skipPendingNodesForBudgetBreach, } from "../../application/evaluation/budget.js";
+export function initRunBudgetLedger(state, budget) {
+    if (!budget)
+        return;
+    state.budget = structuredClone(budget);
+    state.budgetLedger = createBudgetLedger(budget);
+}
+function wallTimeMs(state, now = Date.now()) {
+    return Math.max(0, now - new Date(state.startedAt).getTime());
+}
+function repairPasses(state) {
+    return state.convergence?.currentPass ?? 0;
+}
+export function applyHardBudgetBreach(state, breach) {
+    if (!state.budgetLedger || state.budgetLedger.mode !== "hard")
+        return;
+    skipPendingNodesForBudgetBreach(state.nodes, breach);
+    state.failureCategory = "budget_breach";
+}
+export function preflightBudgetOrBreach(state) {
+    const ledger = state.budgetLedger;
+    if (!ledger)
+        return undefined;
+    const breach = checkBudgetPreNode(ledger, {
+        wallTimeMs: wallTimeMs(state),
+        repairPasses: repairPasses(state),
+    });
+    if (breach && isHardBudgetBreached(ledger)) {
+        applyHardBudgetBreach(state, breach);
+    }
+    return breach;
+}
+export function recordFinishedNodeBudget(state, node, contextChars) {
+    const ledger = state.budgetLedger;
+    if (!ledger)
+        return undefined;
+    const breach = recordNodeBudgetSample(ledger, {
+        nodeId: node.id,
+        tokensUsed: node.tokensUsed,
+        contextChars,
+        wallTimeMs: wallTimeMs(state),
+        repairPasses: repairPasses(state),
+    });
+    if (breach && isHardBudgetBreached(ledger)) {
+        applyHardBudgetBreach(state, breach);
+    }
+    return breach;
+}
+export async function writeBudgetLedgerArtifacts(runDir, ledger) {
+    if (!ledger)
+        return;
+    const jsonPath = path.join(runDir, "budget-ledger.json");
+    const mdPath = path.join(runDir, "budget-report.md");
+    await writeFile(jsonPath, `${JSON.stringify(ledger, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, formatBudgetReportMarkdown(ledger), "utf8");
+}
+export function assertFrozenBudget(specBudget, stateBudget, runId) {
+    if (!specBudget && !stateBudget)
+        return;
+    if (!specBudget ||
+        !stateBudget ||
+        JSON.stringify(specBudget) !== JSON.stringify(stateBudget)) {
+        throw new Error(`dag run ${runId} budget drifted between run.json and state.json; refuse to continue`);
+    }
+}

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/init-hybrid.js

@@ -555,7 +555,7 @@ export function hasApiDependency(sources) {
  * |---|---|---|---|
  * | 无 | 任意 | auto | not-required |
  * | 有 | present | auto | required |
- * | 有 | present/absent/ambiguous | auto | required (strategy chooses a safe mechanism) |
+ * | 有 | absent/ambiguous | auto | not-required (skip Mock, preserve integration gap) |
  * | 任意 | present | required | required |
  * | 任意 | absent/ambiguous | required | blocked |
  * | 任意 | 任意 | disabled | not-required (if spec allows) else blocked |
@@ -587,12 +587,12 @@ export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
     if (!hasApiDep) {
         return "not-required";
     }
-    // In auto mode, capability discovery is evidence for the strategy node, not
-    // a final mechanism decision. Projects without a native Mock service may use
-    // an existing browser interception harness or a reversible request adapter.
-    // The deterministic strategy gate blocks before the writer when none can be
-    // verified by the DAG's frozen static/behavior entrypoints.
-    return "required";
+    // In auto mode, frontend Mock is optional. Only require Mock-backed strategy
+    // assessment when a native project Mock capability is actually present.
+    // Projects without confirmed Mock support continue through the normal
+    // frontend writer and must preserve the real integration gap instead of
+    // inventing a temporary Mock framework or blocking solely for missing Mock.
+    return capability.status === "present" ? "required" : "not-required";
 }
 function mapTaskComplexity(complexity) {
     if (complexity === "small")
@@ -1322,6 +1322,12 @@ export function buildStandardHybridDagFromTask(sources) {
     return spec;
 }
 function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, fixedVerificationContext, readOnlyPaths, forbiddenPaths) {
+    const configuredPolicy = sources.taskConfig.frontendMock?.policy ?? "auto";
+    const mockMode = sources.frontendMockMode ?? "not-required";
+    const capabilityStatus = sources.frontendMockCapability?.status;
+    const autoMaySkipMissingMock = configuredPolicy === "auto" &&
+        mockMode === "not-required" &&
+        (capabilityStatus === "absent" || capabilityStatus === "ambiguous");
     return {
         id: "frontend-mock-assess-pi",
         depends_on: ["frontend-contract-pi", "frontend-scout-pi"],
@@ -1337,7 +1343,9 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
             "Perform read-only Mock assessment and select one safe frontend data strategy.",
             "The first non-empty line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked.",
             "Prefer an existing native Mock facility. Use browser-intercept only with an existing browser/e2e harness. When no Mock exists but the API layer is writable, use request-adapter by adding a minimal reversible adapter/DI seam within the approved writeSet; the real adapter must remain the production default.",
-            "Select not-needed only with positive evidence that no remote API is involved, a stable real backend will be exercised, or existing fixtures already cover the contract without changes. not-needed still requires the fixed behavior entrypoint to exercise applicable real or no-remote behavior verification. When configured policy is required, not-needed is forbidden.",
+            autoMaySkipMissingMock
+                ? "Auto mode may skip Mock when no project Mock capability is confirmed. Select not-needed with positive evidence from contract/scout that no project Mock capability is confirmed, continue without adding Mock files or dependencies, run the fixed verification entrypoints, and record any unproved real API behavior in Real Integration Gap. Do not block solely because no project Mock capability, browser interception harness, or request adapter exists."
+                : "Select not-needed only with positive evidence that no remote API is involved, a stable real backend will be exercised, or existing fixtures already cover the contract without changes. not-needed still requires the fixed behavior entrypoint to exercise applicable real or no-remote behavior verification. When configured policy is required, not-needed is forbidden.",
             "Configured policy disabled requests no Mock but cannot override project specifications; if an actually-read project rule requires Mock, select blocked.",
             "",
             "## Required Output Sections:",
@@ -1356,6 +1364,9 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
             "- Read project Mock/API/schema specifications before making any judgment.",
             "- Do not infer Mock service from lockfile-only or transitive dependency evidence.",
             "- Output MOCK_STRATEGY: blocked if capability evidence conflicts, contract fields are missing/conflicting, paths or dependencies are unauthorized, specs were not actually read, sources conflict, production-default-off cannot be proven, the API layer is not writable for a new adapter, or the frozen entrypoints cannot verify the selected strategy.",
+            ...(autoMaySkipMissingMock
+                ? ["- In auto mode with no confirmed project Mock capability, do not block solely because Mock is unavailable or Mock-specific verification is absent; choose not-needed and make the Real Integration Gap explicit unless project specs require Mock or another safety rule is violated."]
+                : []),
             "- Never comment out or replace the real request with inline data, hard-code Mock enablement, import test mocks from a production entrypoint, invent API fields, or place secrets/real user data in fixtures.",
             "- Mock-backed behavior evidence proves the documented frontend contract only; it never proves real API integration.",
             "",
@@ -1564,7 +1575,11 @@ function resolveFrontendMockContextBlock(sources) {
         parts.push("Mock-backed frontend verification is required. Prefer the detected native service; otherwise the assessment may select an existing browser interception harness or reversible request adapter. Any handler, fixture, adapter, and UI changes stay in the single frontend-implement-pi writeSet.");
     }
     if (mode === "not-required") {
-        parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed only positively, or select a safe Mock strategy if an API dependency is confirmed.");
+        parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
+        if ((sources.taskConfig.frontendMock?.policy ?? "auto") === "auto" &&
+            (capability.status === "absent" || capability.status === "ambiguous")) {
+            parts.push("Auto mode may skip Mock when no project Mock capability is confirmed. Do not block solely for missing Mock; keep the real request path as default and record any unproved backend behavior as Real Integration Gap.");
+        }
     }
     if (mode === "blocked") {
         parts.push("Mock contract is blocked. The DAG must stop before any write node executes.");
@@ -1900,7 +1915,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 subtask_prompt: [
                     "Audit the frontend plan before implementation.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence; not-needed requires applicable real or no-remote behavior evidence.",
+                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
@@ -2330,7 +2345,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Read the validated frontend-implementation-contract, frontend-verification-trace evidence, static/behavior shell facts, and actual diff. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
                     "Use the direct contract, original plan, revision/no-op result, and final design review to reconstruct the approved plan and design verdict; do not infer them from the implementation summary.",
-                    "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence; not-needed requires applicable real or no-remote behavior evidence. Verify that the real request remains the default when Mock activation is absent.",
+                    "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
                     "Inspect the production/default-real-path static evidence directly and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
@@ -2391,6 +2406,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
                     "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use frontend-verification-trace facts; do not invent Browser evidence from component tests.",
                     `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
+                    `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
                     sourceContext,
                     mockContextBlock,

package/dist/workflows/dag/knowledge-curator.js

@@ -103,6 +103,7 @@ export async function curateKnowledgePatterns(input) {
             ok: true,
             patternsPath,
             patternCount: 0,
+            patterns: [],
             safetyFindings: [],
             message: "no patterns.jsonl found; no proposal generated",
         };
@@ -139,6 +140,7 @@ export async function curateKnowledgePatterns(input) {
             patternsPath,
             outputPath,
             patternCount: patterns.length,
+            patterns,
             proposalMarkdown,
             safetyFindings,
             message: "proposal failed skill safety audit",
@@ -153,6 +155,7 @@ export async function curateKnowledgePatterns(input) {
         patternsPath,
         outputPath,
         patternCount: patterns.length,
+        patterns,
         proposalMarkdown,
         safetyFindings,
         message: patterns.length === 0

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

@@ -3,29 +3,35 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
+import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
 import { resolveDagSkillInstructions, skillInstructionMetadata, } from "./skill-instructions.js";
-import { resolveDagNodeSkills } from "./skills.js";
 import { parseRepairArtifactFromText, resolveRepairTaskForGate, validateRepairArtifactScope, } from "./repair-artifact.js";
 import { resolveModelForTask, } from "./types.js";
 export function buildNodePrompt(spec, task, upstream) {
+    const policy = resolveContextPolicy(spec);
     return buildDagNodePromptEnvelope({
         spec,
         task,
         upstream,
-        resolvedSkills: resolveDagNodeSkills(spec, task),
+        resolvedSkills: policy.resolveSkills(spec, task),
+        maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
     });
 }
 export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd) {
-    const skillNames = resolveDagNodeSkills(spec, task);
+    const policy = resolveContextPolicy(spec);
+    const skillNames = policy.resolveSkills(spec, task);
+    const budget = policy.resolveSkillInstructionBudget(task);
     const resolvedSkillInstructions = task.executor === "pi"
         ? await resolveDagSkillInstructions(skillNames, {
             cwd,
-            includeLearnedPatterns: task.role === "implementer",
+            includeLearnedPatterns: budget.includeLearnedPatterns,
+            perSkillMaxChars: budget.perSkillMaxChars,
+            totalMaxChars: budget.totalMaxChars,
         })
         : [];
     return {
@@ -35,6 +41,7 @@ export async function buildNodePromptWithResolvedSkillInstructions(spec, task, u
             upstream,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
+            maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
         }),
         resolvedSkills: skillInstructionMetadata(resolvedSkillInstructions),
     };

package/dist/workflows/dag/prompt.js

@@ -6,7 +6,7 @@ export const DAG_AUTHORING_GUIDANCE = [
     "Prefer same-rank parallel read-only scouts over unnecessary serial depends_on chains.",
     "Add depends_on only when a child truly needs upstream output; default to independent ranks.",
     "Every task must explicitly declare executor; defaults.executor is schema-only, not a runtime fallback.",
-    "Cursor remains a first-class executor for scouts and exclusive implementers when it fits the task.",
+    "Pi is the only governed Agent DAG writer; cursor-prompt is an explicit manual one-shot sidecar and must not enter Loop auto-execute or Delegate writers.",
     "exclusive nodes require narrow, concrete, disjoint writeSet paths; never use ** or repo root.",
     "Read-only nodes must not write repository files, including root artifacts/**; return findings in node output only.",
     "If the DAG is a single linear chain, challenge whether read-only work can run in parallel ranks.",