@tea-agent/loop-agent 0.15.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/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.",

package/dist/workflows/dag/runner.js

@@ -1,8 +1,10 @@
 import { readdir, readFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import path from "node:path";
+import { isHardBudgetBreached, resolveEffectiveMaxConcurrent, } from "../../application/evaluation/budget.js";
 import { readCandidateRecord } from "../../infrastructure/evaluation/candidate-store.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/runtime.js";
+import { assertFrozenBudget, initRunBudgetLedger, preflightBudgetOrBreach, recordFinishedNodeBudget, writeBudgetLedgerArtifacts, } from "./budget-enforcement.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
 import { moveToCompletedRunDir, moveToPausedRunDir, prepareActiveRunDir, writeRunSpec, writeRunState, } from "./run-store.js";
 import { createDagNodeExecutor } from "./executor-registry.js";
@@ -120,7 +122,7 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
                 : {}),
         };
     }
-    return {
+    const state = {
         version: 1,
         title: spec.title,
         runId,
@@ -147,6 +149,8 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             }
             : {}),
     };
+    initRunBudgetLedger(state, spec.budget);
+    return state;
 }
 export function assertFrozenEvaluationBinding(spec, state) {
     const declared = spec.evaluation;
@@ -183,7 +187,7 @@ export async function runDag(spec, opts) {
         controllerVersion: runningIdentity.packageVersion,
     });
     const { ranks } = topoSortToRanks(spec);
-    const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
+    const { maxConcurrent } = resolveEffectiveMaxConcurrent(Math.max(1, opts.maxConcurrent ?? 4), spec.budget);
     let runId = opts.runId;
     if (runId) {
         for (const warning of validateDagRunIdFormat(runId).warnings) {
@@ -268,6 +272,7 @@ export async function resumeDagRun(opts) {
         throw new Error(`dag run ${opts.runId} is already terminal (status=${state.status})`);
     }
     assertFrozenEvaluationBinding(spec, state);
+    assertFrozenBudget(spec.budget, state.budget, state.runId);
     // Runtime contract + controller identity must be re-verified before executing
     // any remaining node on resume; drift fails closed.
     const runningIdentity = resolveRunningControllerIdentity();
@@ -311,7 +316,7 @@ export async function resumeDagRun(opts) {
     catch (error) {
         throw new Error(`skill snapshot validation failed on resume: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
+    const { maxConcurrent } = resolveEffectiveMaxConcurrent(Math.max(1, opts.maxConcurrent ?? 4), spec.budget);
     state.status = "running";
     const resumedAt = new Date().toISOString();
     state.runner = {
@@ -410,23 +415,43 @@ async function executeDagCheckpoint(input) {
                     tasksById,
                     meta: { runDir, runId: state.runId, spec },
                 }),
-                executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
-                    nodeId,
-                    tasksById,
-                    state,
-                    spec,
-                    cwd,
-                    runDir,
-                    executeNode,
-                    executeDynamicNode,
-                    observer: input.observer,
-                    persistState,
-                    onPause,
-                }),
+                executeScheduledNode: async (nodeId, executeNode, onPause) => {
+                    if (isHardBudgetBreached(state.budgetLedger))
+                        return;
+                    const preBreach = preflightBudgetOrBreach(state);
+                    if (preBreach && isHardBudgetBreached(state.budgetLedger)) {
+                        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
+                        await persistState();
+                        return;
+                    }
+                    await executeDagNode({
+                        nodeId,
+                        tasksById,
+                        state,
+                        spec,
+                        cwd,
+                        runDir,
+                        executeNode,
+                        executeDynamicNode,
+                        observer: input.observer,
+                        persistState,
+                        onPause,
+                    });
+                    const node = state.nodes[nodeId];
+                    if (node &&
+                        (node.status === "FINISHED" || node.status === "ERROR")) {
+                        recordFinishedNodeBudget(state, node);
+                        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
+                        await persistState();
+                    }
+                },
             });
             if (pausedByNodeId) {
                 break;
             }
+            if (isHardBudgetBreached(state.budgetLedger)) {
+                break;
+            }
             const convergenceDecision = await runConvergencePassController({
                 spec,
                 state,
@@ -446,6 +471,7 @@ async function executeDagCheckpoint(input) {
         }
         state.finishedAt = new Date().toISOString();
         const runDirBeforeTransfer = runDir;
+        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
         if (pausedByNodeId) {
             state.status = "paused";
             await persistState();
@@ -466,6 +492,7 @@ async function executeDagCheckpoint(input) {
         if (state.convergence) {
             relocateConvergenceArtifactPaths(state.convergence, runDirBeforeTransfer, runDir);
         }
+        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
         await persistState({ allowCompletedFactsWrite: true });
         return {
             title: spec.title,

package/dist/workflows/dag/skill-snapshot.js

@@ -3,9 +3,9 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { writeTextAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
-import { DEFAULT_SKILL_INSTRUCTION_MAX_CHARS, DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS, resolveDagSkillInstructions, } from "./skill-instructions.js";
-import { resolveDagNodeSkills } from "./skills.js";
+import { resolveDagSkillInstructions, } from "./skill-instructions.js";
 export const SKILL_SNAPSHOT_SCHEMA_VERSION = 1;
 export const SKILL_SNAPSHOT_RESOLVER_VERSION = 1;
 export const SKILL_SNAPSHOT_REL_PATH = ".runtime/skill-snapshot.json";
@@ -117,11 +117,13 @@ function profileId(input) {
 export function buildDagSkillSnapshotProfileRequest(spec, task) {
     if (task.executor !== "pi")
         return undefined;
+    const policy = resolveContextPolicy(spec);
+    const budget = policy.resolveSkillInstructionBudget(task);
     const request = {
-        skills: [...resolveDagNodeSkills(spec, task)],
-        includeLearnedPatterns: task.role === "implementer",
-        perSkillMaxChars: DEFAULT_SKILL_INSTRUCTION_MAX_CHARS,
-        totalMaxChars: DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS,
+        skills: [...policy.resolveSkills(spec, task)],
+        includeLearnedPatterns: budget.includeLearnedPatterns,
+        perSkillMaxChars: budget.perSkillMaxChars,
+        totalMaxChars: budget.totalMaxChars,
     };
     return { id: profileId(request), ...request };
 }
@@ -511,7 +513,8 @@ function stripPromptText(instruction) {
     return metadata;
 }
 export function buildNodePromptFromSnapshot(input) {
-    const skillNames = resolveDagNodeSkills(input.spec, input.task);
+    const policy = resolveContextPolicy(input.spec);
+    const skillNames = policy.resolveSkills(input.spec, input.task);
     const resolvedSkillInstructions = resolveNodeSkillsFromSnapshot(input.snapshot, input.spec, input.task);
     return {
         prompt: buildDagNodePromptEnvelope({
@@ -520,6 +523,7 @@ export function buildNodePromptFromSnapshot(input) {
             upstream: input.upstream,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
+            maxUpstreamChars: policy.resolveMaxUpstreamChars(input.task),
         }),
         resolvedSkills: resolvedSkillInstructions.map(stripPromptText),
     };

package/dist/workflows/dag/types.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { campaignBudgetSchema, } from "../../application/evaluation/budget.js";
 import { assertDagPromptSourceRule } from "./prompt-source.js";
 import { dagRetryPolicySchema } from "./retry-policy.js";
 export const dagComplexitySchema = z.enum(["HIGH", "MED", "LOW"]);
@@ -105,12 +106,18 @@ export const dagWritePolicySchema = z.enum([
     "exclusive",
     "none",
 ]);
+export const contextPolicyIdSchema = z.enum([
+    "baseline-v1",
+    "role-specialized-v1",
+]);
 export const dagDefaultsSchema = z
     .object({
     executor: dagNodeExecutorSchema.optional(),
     model: z.string().optional(),
     piBackend: z.enum(["sdk-first", "cli-only"]).optional(),
     contextProfile: z.string().optional(),
+    /** Eval Lab ContextPolicy seam; default baseline-v1 when omitted. */
+    contextPolicyId: contextPolicyIdSchema.optional(),
     skills: z.array(z.string()).optional(),
     writePolicy: dagWritePolicySchema.optional(),
 })
@@ -300,6 +307,8 @@ export const dagEvaluationBindingSchema = z
     taskRef: z.string().min(1).optional(),
 })
     .strict();
+/** Eval Lab Campaign Budget (W3.4); enforced by runner ledger when mode=hard. */
+export const dagBudgetSchema = campaignBudgetSchema;
 export const dagSourceBindingSchema = z.object({
     schemaVersion: z.literal(1),
     taskId: z.string().min(1),
@@ -320,6 +329,8 @@ export const dagSpecSchema = z
     title: z.string().min(1),
     runtimeContract: dagRuntimeContractSchema.optional(),
     evaluation: dagEvaluationBindingSchema.optional(),
+    /** Optional hard/record-only budget; requires version 3. */
+    budget: dagBudgetSchema.optional(),
     sourceBinding: dagSourceBindingSchema.optional(),
     outputLanguage: dagOutputLanguageSchema.optional(),
     objective: z.string().optional(),
@@ -340,6 +351,13 @@ export const dagSpecSchema = z
             path: ["evaluation"],
         });
     }
+    if (spec.budget && spec.version !== 3) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "budget requires DagSpec version 3",
+            path: ["budget"],
+        });
+    }
     if (spec.runtimeContract && spec.version !== 3) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,