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

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/lifecycle.js

@@ -4,7 +4,7 @@ import { hostname as localHostname } from "node:os";
 import { writeJsonAtomic, } from "../../infrastructure/harness/atomic-write.js";
 import { parseDagSpec } from "./types.js";
 import { normalizeDagFailureCategory, } from "./failure-category.js";
-import { routeDagFailure } from "./failure-routing.js";
+import { dagProductLineFailureCategoryValues, routeDagFailure, } from "./failure-routing.js";
 const DAG_LIFECYCLE_SCAN_ORDER = [
     "paused",
     "active",
@@ -663,6 +663,36 @@ function findDoctorFailureNode(state) {
         rawFailureCategory: selected[1].failureCategory,
     };
 }
+async function readRunOwnedBackendTestClassification(runDir) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "classify-backend-test-result-pi.json"), "utf-8"));
+        const text = raw.assistantText ?? raw.stdout;
+        if (typeof text !== "string")
+            return undefined;
+        const trimmed = text.trim();
+        const fenced = trimmed.match(/^```json\s*([\s\S]*?)\s*```$/i);
+        const classification = JSON.parse(fenced?.[1] ?? trimmed);
+        return typeof classification.category === "string" &&
+            dagProductLineFailureCategoryValues.includes(classification.category)
+            ? classification.category
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveDoctorFailureRouting(input) {
+    const classifiedCategory = await readRunOwnedBackendTestClassification(input.runDir);
+    if (classifiedCategory) {
+        return routeDagFailure({
+            rawFailureCategory: classifiedCategory,
+            normalizedFailureCategory: "unknown",
+            nodeId: input.nodeId,
+            productLineFailureCategory: classifiedCategory,
+        });
+    }
+    return routeDagFailure(input);
+}
 async function formatDagDoctorMarkdown(repoRoot, runId) {
     const located = await locateDagRun(repoRoot, runId);
     if (!located) {
@@ -675,7 +705,8 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         (state.status === "paused" ? "human-required" : state.failureCategory);
     const failureStatus = state.status === "paused" ? "paused" : failure.status;
     const normalizedCategory = normalizeDagFailureCategory(rawFailureCategory, failureStatus ?? state.status);
-    const routing = routeDagFailure({
+    const routing = await resolveDoctorFailureRouting({
+        runDir: located.runDir,
         rawFailureCategory,
         normalizedFailureCategory: normalizedCategory,
         nodeId: failure.nodeId,

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/reconcile-run.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { assessDagRunLiveness, assessDagRunRecoveryEligibility, assertDagRunTransferTargetAvailable, getDagRunDir, locateDagRun, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
+export function parseDagReconcileRunArgs(args) {
+    let runId;
+    let action;
+    let reason;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--run-id")
+            runId = args[++index];
+        else if (arg.startsWith("--run-id="))
+            runId = arg.slice("--run-id=".length);
+        else if (arg === "--action")
+            action = parseAction(args[++index]);
+        else if (arg.startsWith("--action="))
+            action = parseAction(arg.slice("--action=".length));
+        else if (arg === "--reason")
+            reason = args[++index];
+        else if (arg.startsWith("--reason="))
+            reason = arg.slice("--reason=".length);
+        else if (arg.startsWith("-"))
+            throw new Error(`unknown dag reconcile-run flag: ${arg}`);
+        else
+            throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId)
+        throw new Error("dag reconcile-run requires --run-id <id>");
+    if (action && !reason?.trim()) {
+        throw new Error("dag reconcile-run mutation requires --reason <text>");
+    }
+    return { runId, action, ...(reason?.trim() ? { reason: reason.trim() } : {}) };
+}
+function parseAction(value) {
+    if (value === "supersede" || value === "abandon")
+        return value;
+    throw new Error("dag reconcile-run --action must be supersede or abandon");
+}
+/**
+ * DAG-kernel reconcile for a single run. Lives in workflows so Worker outer-loop
+ * recovery can call it without importing the CLI/commands layer.
+ */
+export async function executeDagReconcileRun(repoRoot, rawArgs) {
+    const parsed = parseDagReconcileRunArgs(rawArgs);
+    const located = await locateDagRun(repoRoot, parsed.runId);
+    if (!located)
+        throw new Error(`dag run not found: ${parsed.runId}`);
+    const state = await readDagRunState(located.runDir);
+    const liveness = assessDagRunLiveness({ state });
+    const eligibility = assessDagRunRecoveryEligibility({
+        lifecycle: located.lifecycle,
+        state,
+        liveness: liveness.status,
+    });
+    if (!parsed.action) {
+        return {
+            action: "inspect",
+            runId: state.runId,
+            lifecycle: located.lifecycle,
+            status: state.status,
+            liveness: liveness.status,
+            eligibility,
+            nextRecommendedAction: eligibility.canReconcile
+                ? "Re-run with --action supersede|abandon and --reason <text>."
+                : "Do not reconcile this run; inspect runner and lifecycle evidence first.",
+        };
+    }
+    if (!eligibility.canReconcile || !eligibility.allowedActions.includes(parsed.action)) {
+        throw new Error(`dag run ${state.runId} is not eligible for reconciliation: ${eligibility.reasons.join(", ") || "unknown reason"}`);
+    }
+    const reconciledAt = new Date().toISOString();
+    const completedRunDir = getDagRunDir(repoRoot, "completed", state.runId);
+    if (located.lifecycle !== "completed") {
+        await assertDagRunTransferTargetAvailable(completedRunDir);
+    }
+    const artifactRelativePath = path.join(".harness", "dag-runs", "completed", state.runId, "reconciliation.json").replace(/\\/g, "/");
+    await writeJsonAtomic(path.join(located.runDir, "reconciliation.json"), {
+        schemaVersion: 1,
+        runId: state.runId,
+        action: parsed.action,
+        reason: parsed.reason,
+        reconciledAt,
+        previousLifecycle: located.lifecycle,
+        previousStatus: state.status,
+        liveness: liveness.status,
+        originalState: state,
+    });
+    const previousStatus = state.status;
+    for (const node of Object.values(state.nodes)) {
+        if (node.status !== "RUNNING")
+            continue;
+        node.status = "ERROR";
+        node.finishedAt = reconciledAt;
+        node.failureCategory = `operator-${parsed.action}`;
+    }
+    state.status = parsed.action === "supersede" ? "superseded" : "abandoned";
+    state.finishedAt = reconciledAt;
+    state.failureCategory = `operator-${parsed.action}`;
+    state.reconciliation = {
+        action: parsed.action,
+        reason: parsed.reason,
+        reconciledAt,
+        previousStatus,
+        previousLifecycle: located.lifecycle,
+        liveness: liveness.status,
+        artifactPath: artifactRelativePath,
+    };
+    await writeDagRunState(located.runDir, state);
+    const runDir = located.lifecycle === "completed"
+        ? located.runDir
+        : await transferDagRunDir(located.runDir, completedRunDir);
+    return {
+        action: parsed.action,
+        runId: state.runId,
+        status: state.status,
+        lifecycle: "completed",
+        reason: parsed.reason,
+        reconciliationArtifactPath: artifactRelativePath,
+        runDir,
+    };
+}

package/dist/workflows/dag/report.js

@@ -148,6 +148,9 @@ const dagNodeReportRowSchema = z
     finishedAt: z.string().optional(),
     decisionEnvelope: dagNodeDecisionEnvelopeSchema.optional(),
     artifacts: dagNodeArtifactsReportSchema,
+    structuredArtifactPath: z.string().min(1).optional(),
+    structuredArtifactSha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    structuredArtifactSchemaId: z.string().min(1).optional(),
 })
     .strict();
 const dagRunReportEntrySchema = z
@@ -460,6 +463,15 @@ export async function buildDagRunReportEntry(input) {
                 finishedAt: node.finishedAt,
                 decisionEnvelope: node.decisionEnvelope,
                 artifacts: await buildNodeArtifactsReport(input.runDir, nodeId),
+                ...(node.structuredArtifactPath
+                    ? { structuredArtifactPath: node.structuredArtifactPath }
+                    : {}),
+                ...(node.structuredArtifactSha256
+                    ? { structuredArtifactSha256: node.structuredArtifactSha256 }
+                    : {}),
+                ...(node.structuredArtifactSchemaId
+                    ? { structuredArtifactSchemaId: node.structuredArtifactSchemaId }
+                    : {}),
             });
         }
     }

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/scheduler.js

@@ -1,14 +1,58 @@
 import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
+import { evaluateConditionExpression } from "./dynamic-runtime/condition.js";
 export function isConditionSkippedReason(reason) {
     return Boolean(reason?.startsWith("condition "));
 }
-function shouldSkipNode(node, task, nodes) {
-    if (!node || node.status !== "PENDING")
-        return false;
-    return task.depends_on.some((depId) => {
+/**
+ * Dependency readiness for PENDING nodes.
+ *
+ * Default (`dependsPolicy: all`): any ERROR/SKIPPED dependency → skip (cascades
+ * exclusive condition branches). Unsettled → wait. All FINISHED → run.
+ *
+ * `all-or-condition-skip`: exclusive-branch tips that were condition-SKIPPED are
+ * soft; the node runs when every dep is FINISHED or soft condition-skip and at
+ * least one is FINISHED (OR-join after condition). Opt-in only — never default.
+ */
+function dependencyReadiness(task, nodes) {
+    if (task.depends_on.length === 0)
+        return "run";
+    const softConditionJoin = task.dependsPolicy === "all-or-condition-skip";
+    let hasFinished = false;
+    let hasPendingUpstream = false;
+    let hasHardBlock = false;
+    for (const depId of task.depends_on) {
         const dep = nodes[depId];
-        return !dep || dep.status === "ERROR" || dep.status === "SKIPPED";
-    });
+        if (!dep) {
+            hasHardBlock = true;
+            continue;
+        }
+        if (dep.status === "FINISHED") {
+            hasFinished = true;
+            continue;
+        }
+        if (dep.status === "PENDING" || dep.status === "RUNNING") {
+            hasPendingUpstream = true;
+            continue;
+        }
+        if (dep.status === "ERROR") {
+            hasHardBlock = true;
+            continue;
+        }
+        if (dep.status === "SKIPPED") {
+            if (softConditionJoin &&
+                isConditionSkippedReason(dep.skippedReason)) {
+                continue;
+            }
+            hasHardBlock = true;
+        }
+    }
+    if (hasPendingUpstream)
+        return "wait";
+    if (hasHardBlock)
+        return "skip";
+    if (hasFinished)
+        return "run";
+    return "skip";
 }
 function conditionSkippedByAncestor(task, nodes) {
     return task.depends_on.some((depId) => isConditionSkippedReason(nodes[depId]?.skippedReason));
@@ -27,18 +71,44 @@ async function mapConcurrent(items, limit, fn) {
 export async function executeDagRanksOnce(input) {
     let pausedByNodeId;
     for (const rank of input.ranks) {
-        const runnable = rank.filter((id) => {
+        const pending = rank.filter((id) => {
             const node = input.state.nodes[id];
+            return node?.status === "PENDING";
+        });
+        const runnable = pending.filter((id) => {
             const task = input.tasksById.get(id);
-            if (!node || node.status !== "PENDING")
-                return false;
-            return !shouldSkipNode(node, task, input.state.nodes);
+            return dependencyReadiness(task, input.state.nodes) === "run";
         });
-        const blocked = rank.filter((id) => {
-            const node = input.state.nodes[id];
+        const conditionSettled = [];
+        for (const id of runnable) {
+            const task = input.tasksById.get(id);
+            if (!task.runIf)
+                continue;
+            try {
+                if (!evaluateConditionExpression(task.runIf, input.state)) {
+                    const node = input.state.nodes[id];
+                    node.status = "SKIPPED";
+                    node.skippedReason = `condition runIf did not match: ${task.runIf}`;
+                    node.finishedAt = new Date().toISOString();
+                    conditionSettled.push(id);
+                }
+            }
+            catch (error) {
+                const node = input.state.nodes[id];
+                node.status = "ERROR";
+                node.failureCategory = "invalid-output";
+                node.stderr = error instanceof Error ? error.message : String(error);
+                node.finishedAt = new Date().toISOString();
+                conditionSettled.push(id);
+            }
+        }
+        if (conditionSettled.length > 0)
+            await input.persistState();
+        const conditionSkippedSet = new Set(conditionSettled);
+        const actuallyRunnable = runnable.filter((id) => !conditionSkippedSet.has(id));
+        const blocked = pending.filter((id) => {
             const task = input.tasksById.get(id);
-            return (node?.status === "PENDING" &&
-                shouldSkipNode(node, task, input.state.nodes));
+            return dependencyReadiness(task, input.state.nodes) === "skip";
         });
         for (const id of blocked) {
             const node = input.state.nodes[id];
@@ -50,12 +120,12 @@ export async function executeDagRanksOnce(input) {
         if (blocked.length > 0) {
             await input.persistState();
         }
-        const pauseGateRunnable = runnable.filter((id) => {
+        const pauseGateRunnable = actuallyRunnable.filter((id) => {
             const task = input.tasksById.get(id);
             return isPauseOnHumanDecisionGate(task);
         });
-        const regularRunnable = runnable.filter((id) => !pauseGateRunnable.includes(id));
-        const rankWriterNodeIds = runnable.filter((id) => {
+        const regularRunnable = actuallyRunnable.filter((id) => !pauseGateRunnable.includes(id));
+        const rankWriterNodeIds = actuallyRunnable.filter((id) => {
             const task = input.tasksById.get(id);
             return (task?.executor === "pi" &&
                 task.toolProfile === "write" &&

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),
     };