@tea-agent/loop-agent 0.16.0 → 0.16.1-beta.0

package/dist/commands/init.js

@@ -859,9 +859,6 @@ export function buildManagedGitignoreBlock() {
         ".harness/*.log",
         ".harness/init-surface.json",
         "",
-        "# Eval Lab runtime (candidates, campaigns, scorecards, dogfood scratch)",
-        ".harness/evaluation/",
-        "",
         "# worker task pool",
         ".harness/task-pool/*",
         ".task-pool/",
@@ -2092,7 +2089,7 @@ export function buildInitInstructions(input) {
         "- Enrich the root `README.md`: keep the deterministic project title and the loop-agent managed block intact, and fill the human-authored sections (项目概览, 技术栈与目录结构, 开发与验证) from the target project's actual files. The root README must serve both as a human-first project entry and as an agent work entry; replace the initialization-model supplement comments when the project files provide the information.",
         `- Populate \`${governanceRoot}/verification-matrix.md\` with the target project's actual quick, standard, and full verification commands derived from its real language and toolchain, keeping the governance rows intact.`,
         "- Project repo-local skills live in `.agents/skills/`. Do not create a root `skills/` directory in the target project; the package's bundled `skills/` remains the built-in fallback.",
-        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, evaluation, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
+        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
         "- Do not copy examples by default; examples stay bundled in the tool and are available through `loop-agent examples`.",
         "- Add or update a loop-agent managed block in AGENTS.md.",
         "- The generated AGENTS.md must include documentation convergence and structured DAG write-boundary rules so target projects keep the same working discipline as this repository.",

package/dist/executors/dag-pi-executor.js

@@ -272,7 +272,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         persona,
         step,
     });
-    const mapped = mapPiResultToDagNodeResult(result);
+    const mapped = mapPiResultToDagNodeResult(result, input.task.firstProtocolLine);
     if (!isWriteTask) {
         return mapped;
     }
@@ -313,17 +313,57 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
-export function mapPiResultToDagNodeResult(result) {
+export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
+    const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
     return {
         ok: result.ok,
-        stdout: result.assistantText || result.stdout,
+        stdout: assistantText || result.stdout,
         stderr: result.stderr,
         failureCategory: result.failureCategory,
         durationMs: result.durationMs,
-        assistantText: result.assistantText,
+        assistantText,
         backend: result.backend,
         sdkAttempted: result.sdkAttempted,
         tokensUsed: result.tokensUsed,
         parsedEvents: result.parsedEvents,
     };
 }
+function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
+    if (!assistantText || !firstProtocolLine)
+        return assistantText;
+    const lines = assistantText.split(/\r?\n/);
+    let protocolIndex = -1;
+    let protocolLine = "";
+    for (const [index, line] of lines.entries()) {
+        const normalized = normalizeProtocolLine(line);
+        if (normalized.startsWith(firstProtocolLine)) {
+            protocolIndex = index;
+            protocolLine = normalized;
+            break;
+        }
+    }
+    if (protocolIndex < 0)
+        return assistantText;
+    if (protocolIndex === 0) {
+        return [protocolLine, ...lines.slice(1)].join("\n");
+    }
+    const before = lines.slice(0, protocolIndex);
+    const after = lines.slice(protocolIndex + 1);
+    while (before.at(-1)?.trim() === "" &&
+        after.at(0)?.trim() === "") {
+        after.shift();
+    }
+    const bodyLines = [...before, ...after];
+    while (bodyLines.at(0)?.trim() === "")
+        bodyLines.shift();
+    while (bodyLines.at(-1)?.trim() === "")
+        bodyLines.pop();
+    return bodyLines.length > 0
+        ? `${protocolLine}\n\n${bodyLines.join("\n")}`
+        : protocolLine;
+}
+function normalizeProtocolLine(line) {
+    const trimmed = line.trim();
+    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
+    return (emphasized?.[2] ?? trimmed).trim();
+}

package/dist/worker/delivery/verification-bundle.js

@@ -3,7 +3,6 @@ import { mkdir, readFile, realpath, rename, unlink, writeFile } from "node:fs/pr
 import path from "node:path";
 import { z } from "zod";
 import { controllerIdentitiesMatch } from "../loop-agent/loop-agent-client.js";
-import { artifactMatchesEvidenceToken, isShellVerificationToken, } from "../outcomes/evidence-tokens.js";
 import { readVerifiedOutcome } from "../outcomes/store.js";
 import { getTaskPoolRoot, readFeatureTaskPoolStates } from "../pool/run-store.js";
 import { workflowSchema } from "../task-spec/workflow-routing.js";
@@ -31,12 +30,7 @@ const bundleOutcomeSchema = z
     outcomePath: z.string().min(1),
     outcomeSha256: z.string().regex(/^[a-f0-9]{64}$/),
     acceptanceCoverage: z.array(z.string().min(1)),
-    artifacts: z.array(z.object({
-        path: z.string().min(1),
-        sha256: z.string().regex(/^[a-f0-9]{64}$/),
-        kind: z.string().min(1).optional(),
-        schemaId: z.string().min(1).optional(),
-    }).strict()),
+    artifacts: z.array(z.object({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/), kind: z.string().min(1).optional() }).strict()),
     integrationStatus: z.object({ mock: z.boolean(), real: z.boolean() }).strict(),
     outcomeStatus: z.enum(["succeeded", "failed"]),
     controllerIdentity: z
@@ -249,12 +243,7 @@ function projectBundleAcceptance(item, backendTests, frontendTests, implementati
     return { acId: item.id, status: "covered", priority: item.priority };
 }
 function evidenceKindPresent(entry, kind) {
-    if (isShellVerificationToken(kind)) {
-        // Bundle outcomes do not embed shellVerification; shell evidence is
-        // already implied by outcomeStatus === "succeeded" for typed tests.
-        return entry.outcomeStatus === "succeeded";
-    }
-    return entry.artifacts.some((artifact) => artifactMatchesEvidenceToken(artifact, kind));
+    return entry.artifacts.some((artifact) => artifact.kind === kind);
 }
 function isTypedVerificationWorkflow(workflow) {
     return TYPED_VERIFICATION_WORKFLOWS.includes(workflow);

package/dist/worker/feature/review.js

@@ -4,7 +4,6 @@ import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
 import { getRunsJsonlPath, getTaskPoolRoot, readFeatureTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
-import { artifactMatchesEvidenceToken, isShellVerificationToken, } from "../outcomes/evidence-tokens.js";
 import { readVerifiedOutcome } from "../outcomes/store.js";
 import { acceptanceSpecSchema } from "../task-graph/acceptance-schema.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
@@ -592,9 +591,9 @@ export function projectDualCoverage(item, states, outcomes, failed, done, expect
         return "awaiting-verification";
     }
     const requiredEvidence = item.verification.required_evidence ?? [];
-    if (requiredEvidence.some((token) => !verEnvelopes.some(({ envelope }) => isShellVerificationToken(token)
+    if (requiredEvidence.some((kind) => !verEnvelopes.some(({ envelope }) => kind === "shell-verification"
         ? envelope.shellVerification?.exitZero === true
-        : envelope.artifacts?.some((artifact) => artifactMatchesEvidenceToken(artifact, token))))) {
+        : envelope.artifacts?.some((artifact) => artifact.kind === kind)))) {
         return "awaiting-verification";
     }
     // 3. integration policy: real-required demands real evidence on every

package/dist/worker/outcomes/adapters.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { splitStructuredArtifactIdentity } from "./evidence-tokens.js";
 /**
  * Shared artifact extraction. Every successful worker run produces a canonical
  * `run_record` (the worker-run-record.json) and a `dag` (the generated DAG
@@ -44,12 +43,10 @@ function structuredArtifactsFromReport(run) {
         if (node.structuredArtifactPath &&
             node.structuredArtifactSha256 &&
             node.structuredArtifactSchemaId) {
-            const identity = splitStructuredArtifactIdentity(node.structuredArtifactSchemaId);
             artifacts.push({
                 path: node.structuredArtifactPath,
                 sha256: node.structuredArtifactSha256,
-                kind: identity.kind,
-                schemaId: identity.schemaId,
+                kind: node.structuredArtifactSchemaId,
             });
         }
     }

package/dist/worker/outcomes/gate.js

@@ -1,16 +1,18 @@
-import { isShellVerificationToken, } from "./evidence-tokens.js";
-export { artifactMatchesEvidenceToken, isShellVerificationToken, } from "./evidence-tokens.js";
 /**
  * Deterministic required-output gate.
  *
  * The gate runs *after* a successful DAG report. It performs a **literal
- * string match** of each known `outputs.required` token against produced
- * artifact kinds (and the shell-verification exit-zero fact).
+ * string match** of each `outputs.required` token against the `kind` of every
+ * artifact the adapter produced (and the run-record/dag canonical kinds). A
+ * required token with no matching produced artifact fails closed — the run is
+ * downgraded from `succeeded` to `failed` with `ContractMismatch`.
  *
- * Known tokens (`run_record`, `dag_json`, `shell_verification` / legacy
- * `shell-verification`) fail closed when absent. Unknown legacy tokens are
- * intentionally ignored for compatibility — they never invent a mapping and
- * never block promotion. An empty `required` list always passes.
+ * - No regex / substring matching: a token matches only when an artifact
+ *   `kind` equals it exactly.
+ * - Unknown tokens (no adapter mapping) are simply unmatched → missing. The
+ *   gate never invents a mapping and never passes a run missing a known
+ *   required output.
+ * - An empty `required` list always passes (nothing to enforce).
  *
  * This gate is the success-criteria guardrail: "DAG report succeeded but a
  * known required output is missing ⇒ the Task must not be marked Done."
@@ -24,7 +26,7 @@ export function checkRequiredOutputs(envelope, requiredOutputs) {
         .filter((value) => Boolean(value)));
     const missing = [];
     for (const token of requiredOutputs) {
-        if (isShellVerificationToken(token)) {
+        if (token === "shell_verification") {
             if (!envelope.shellVerification?.exitZero)
                 missing.push(token);
             continue;
@@ -32,7 +34,6 @@ export function checkRequiredOutputs(envelope, requiredOutputs) {
         if (KNOWN_ARTIFACT_OUTPUTS.has(token) && !producedKinds.has(token)) {
             missing.push(token);
         }
-        // Unknown tokens: intentionally ignored (legacy compatibility).
     }
     return { passed: missing.length === 0, missing };
 }

package/dist/worker/outcomes/projector.js

@@ -97,7 +97,6 @@ export async function projectOutcome(input) {
             path: artifact.path,
             sha256: recomputed,
             ...(artifact.kind ? { kind: artifact.kind } : {}),
-            ...(artifact.schemaId ? { schemaId: artifact.schemaId } : {}),
         });
     }
     // 5. Shell verification from report decision (exit-zero = report succeeded).
@@ -114,13 +113,6 @@ export async function projectOutcome(input) {
         }
         : undefined;
     const sourceBinding = input.sourceBinding ?? deriveSourceBinding(input);
-    const outcomeStatus = input.reportDecision.succeeded ? "succeeded" : "failed";
-    const outcomeFailure = outcomeStatus === "failed"
-        ? {
-            category: "EnvFailure",
-            reason: input.reportDecision.reason || "DAG report did not succeed",
-        }
-        : undefined;
     const envelope = {
         schemaVersion: 1,
         identity: {
@@ -139,8 +131,7 @@ export async function projectOutcome(input) {
         integrationStatus: adapterProjection.integrationStatus,
         ...(controllerIdentity ? { controllerIdentity } : {}),
         createdAt: input.now.toISOString(),
-        outcomeStatus,
-        ...(outcomeFailure ? { outcomeFailure } : {}),
+        outcomeStatus: input.reportDecision.succeeded ? "succeeded" : "failed",
     };
     // 6. Strict schema parse.
     const parsed = taskOutcomeEnvelopeV1Schema.safeParse(envelope);

package/dist/worker/outcomes/types.js

@@ -30,10 +30,7 @@ export const OUTCOME_WORKFLOWS = [
 export const outcomeArtifactSchema = z.object({
     path: z.string().min(1),
     sha256: z.string().regex(/^[a-f0-9]{64}$/, "sha256 must be lowercase hex"),
-    /** Stable artifact family (e.g. `backend-test-result`). */
     kind: z.string().min(1).optional(),
-    /** Versioned schema id (e.g. `backend-test-result-v1`); orthogonal to kind. */
-    schemaId: z.string().min(1).optional(),
 });
 export const shellVerificationSchema = z.object({
     exitZero: z.boolean(),

package/dist/worker/run-task/run-task.js

@@ -211,34 +211,15 @@ export async function runTaskSpec(options) {
         progress.step(`outcome projection failed: ${projection.category} (${projection.reason})`);
     }
     else {
-        let envelope = projection.envelope;
-        const gate = checkRequiredOutputs(envelope, options.taskSpec.outputs.required);
+        const gate = checkRequiredOutputs(projection.envelope, options.taskSpec.outputs.required);
         if (reportDecision.succeeded && !gate.passed) {
             status = "failed";
-            outcomeFailure = {
-                category: "ContractMismatch",
-                reason: `missing required outputs: ${gate.missing.join(", ")}`,
-            };
-            envelope = {
-                ...envelope,
-                outcomeStatus: "failed",
-                outcomeFailure: {
-                    category: "ContractMismatch",
-                    reason: `missing required outputs: ${gate.missing.join(", ")}`,
-                    missingOutputs: [...gate.missing],
-                },
-            };
+            outcomeFailure = { category: "ContractMismatch", reason: `missing required outputs: ${gate.missing.join(", ")}` };
             progress.step(`required output gate failed: ${gate.missing.join(", ")}`);
         }
-        else if (envelope.outcomeFailure) {
-            outcomeFailure = {
-                category: envelope.outcomeFailure.category,
-                reason: envelope.outcomeFailure.reason,
-            };
+        else {
+            outcome = await writeOutcome(options.repoRoot, projection.envelope);
         }
-        // Persist succeeded and failed envelopes so read models can inspect
-        // outcomeFailure without re-parsing run-record / report decision.
-        outcome = await writeOutcome(options.repoRoot, envelope);
     }
     if (status === "succeeded" && !options.skipSuccessFinalization) {
         await runObservedStep(eventCtx, "promote-run", async () => {

package/dist/worker/task-graph/ready-planner.js

@@ -155,15 +155,12 @@ export function planReadyTasks(input) {
  * Evaluate artifact-gate eligibility for a node whose dependencies are all
  * `Done`. Returns the first blocking projection, or `undefined` when eligible.
  *
- * Envelope-level binding only: Feature / producer task / kind / optional
- * schemaId / optional sourceBinding must match the injected Outcome. The
- * planner is pure and synchronous — it does **not** re-read artifact files or
- * recompute sha256. Callers must inject envelopes via `readVerifiedOutcome`
- * (path/hash of the outcome JSON). File-level artifact sha256 is enforced at
- * `projectOutcome` and again at Feature Verification Bundle / verify-final /
- * Delivery / Closeout (`verifyArtifactRefs`).
- *
- * When `outcomes` is omitted, this gate is skipped (legacy callers unchanged).
+ * Fail-closed: any unverified producer path/hash/schema/feature/producer/source
+ * binding blocks the consumer as `required-artifact-missing` and never becomes
+ * Ready. When `outcomes` is not provided, eligibility is skipped (M3 keeps
+ * callers that have not wired disk injection unchanged). Hash byte-level
+ * verification is the caller's responsibility before injecting an envelope;
+ * the planner trusts `envelope.artifacts[].sha256` as a literal.
  */
 function evaluateArtifactGate(consumes, featureId, states, outcomes, producerKinds) {
     if (!outcomes || !consumes || consumes.length === 0)
@@ -233,11 +230,8 @@ function evaluateArtifactRef(ref, featureId, states, outcomes) {
     if (!artifact) {
         return projection("artifact-kind-absent", `no artifact with kind ${ref.kind}`);
     }
-    if (ref.schemaId !== undefined) {
-        const artifactSchemaId = artifact.schemaId ?? artifact.kind;
-        if (artifactSchemaId !== ref.schemaId) {
-            return projection("schema-mismatch", `artifact schemaId ${String(artifactSchemaId)} != ${ref.schemaId}`);
-        }
+    if (ref.schemaId !== undefined && artifact.kind !== ref.schemaId) {
+        return projection("schema-mismatch", `artifact kind ${String(artifact.kind)} != schemaId ${ref.schemaId}`);
     }
     if (ref.sourceBinding) {
         const envBinding = envelope.sourceBinding;

package/dist/worker/task-graph/task-graph-schema.js

@@ -9,11 +9,9 @@ export const artifactDeclSchema = z
 })
     .strict();
 /**
- * Consumer-side artifact reference. Ready Planner validates envelope-level
- * Feature / producer / kind / optional schemaId / optional sourceBinding.
- * File-level path+sha256 of artifact bytes is enforced at Outcome projection
- * and Feature Verification Bundle / Delivery / Closeout — not inside the
- * synchronous Ready Planner.
+ * Consumer-side artifact reference. A node may only trust an upstream Task
+ * Outcome artifact after deterministic path, hash, schema, feature,
+ * producer-task and source-binding validation (see ready-planner gate).
  */
 export const artifactRefSchema = z
     .object({

package/dist/workflows/dag/init-hybrid.js

@@ -1338,10 +1338,11 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
         allowedPaths: readOnlyPaths,
         forbiddenPaths,
         skills: FRONTEND_IMPLEMENTATION_SKILLS,
-        outputContract: "Plain Markdown whose first non-empty line is MOCK_STRATEGY: native|browser-intercept|request-adapter|not-needed|blocked, followed by Mock Decision, API Contract Evidence, Specification Evidence, Service Evidence, Backend Readiness, Selection Evidence, Endpoint / Fixture Matrix, Activation, Target Files, Production Safety, Verification Plan, Real Integration Gap, and Blocking Issues. No file writes.",
+        firstProtocolLine: "MOCK_STRATEGY:",
+        outputContract: "Plain Markdown whose first line is MOCK_STRATEGY: native|browser-intercept|request-adapter|not-needed|blocked, followed by Mock Decision, API Contract Evidence, Specification Evidence, Service Evidence, Backend Readiness, Selection Evidence, Endpoint / Fixture Matrix, Activation, Target Files, Production Safety, Verification Plan, Real Integration Gap, and Blocking Issues. No file writes.",
         subtask_prompt: [
             "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.",
+            "The first 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. Do not emit blank lines, headings, or explanatory preamble before it.",
             "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.",
             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."

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

@@ -103,7 +103,6 @@ export async function curateKnowledgePatterns(input) {
             ok: true,
             patternsPath,
             patternCount: 0,
-            patterns: [],
             safetyFindings: [],
             message: "no patterns.jsonl found; no proposal generated",
         };
@@ -140,7 +139,6 @@ export async function curateKnowledgePatterns(input) {
             patternsPath,
             outputPath,
             patternCount: patterns.length,
-            patterns,
             proposalMarkdown,
             safetyFindings,
             message: "proposal failed skill safety audit",
@@ -155,7 +153,6 @@ 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,35 +3,29 @@ 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: policy.resolveSkills(spec, task),
-        maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
+        resolvedSkills: resolveDagNodeSkills(spec, task),
     });
 }
 export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd) {
-    const policy = resolveContextPolicy(spec);
-    const skillNames = policy.resolveSkills(spec, task);
-    const budget = policy.resolveSkillInstructionBudget(task);
+    const skillNames = resolveDagNodeSkills(spec, task);
     const resolvedSkillInstructions = task.executor === "pi"
         ? await resolveDagSkillInstructions(skillNames, {
             cwd,
-            includeLearnedPatterns: budget.includeLearnedPatterns,
-            perSkillMaxChars: budget.perSkillMaxChars,
-            totalMaxChars: budget.totalMaxChars,
+            includeLearnedPatterns: task.role === "implementer",
         })
         : [];
     return {
@@ -41,7 +35,6 @@ 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.",
-    "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.",
+    "Cursor remains a first-class executor for scouts and exclusive implementers when it fits the task.",
     "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,10 +1,8 @@
 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";
@@ -122,7 +120,7 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
                 : {}),
         };
     }
-    const state = {
+    return {
         version: 1,
         title: spec.title,
         runId,
@@ -149,8 +147,6 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             }
             : {}),
     };
-    initRunBudgetLedger(state, spec.budget);
-    return state;
 }
 export function assertFrozenEvaluationBinding(spec, state) {
     const declared = spec.evaluation;
@@ -187,7 +183,7 @@ export async function runDag(spec, opts) {
         controllerVersion: runningIdentity.packageVersion,
     });
     const { ranks } = topoSortToRanks(spec);
-    const { maxConcurrent } = resolveEffectiveMaxConcurrent(Math.max(1, opts.maxConcurrent ?? 4), spec.budget);
+    const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
     let runId = opts.runId;
     if (runId) {
         for (const warning of validateDagRunIdFormat(runId).warnings) {
@@ -272,7 +268,6 @@ 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();
@@ -316,7 +311,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 } = resolveEffectiveMaxConcurrent(Math.max(1, opts.maxConcurrent ?? 4), spec.budget);
+    const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
     state.status = "running";
     const resumedAt = new Date().toISOString();
     state.runner = {
@@ -415,43 +410,23 @@ async function executeDagCheckpoint(input) {
                     tasksById,
                     meta: { runDir, runId: state.runId, spec },
                 }),
-                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();
-                    }
-                },
+                executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
+                    nodeId,
+                    tasksById,
+                    state,
+                    spec,
+                    cwd,
+                    runDir,
+                    executeNode,
+                    executeDynamicNode,
+                    observer: input.observer,
+                    persistState,
+                    onPause,
+                }),
             });
             if (pausedByNodeId) {
                 break;
             }
-            if (isHardBudgetBreached(state.budgetLedger)) {
-                break;
-            }
             const convergenceDecision = await runConvergencePassController({
                 spec,
                 state,
@@ -471,7 +446,6 @@ async function executeDagCheckpoint(input) {
         }
         state.finishedAt = new Date().toISOString();
         const runDirBeforeTransfer = runDir;
-        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
         if (pausedByNodeId) {
             state.status = "paused";
             await persistState();
@@ -492,7 +466,6 @@ 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 { resolveDagSkillInstructions, } from "./skill-instructions.js";
+import { DEFAULT_SKILL_INSTRUCTION_MAX_CHARS, DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS, resolveDagSkillInstructions, } from "./skill-instructions.js";
+import { resolveDagNodeSkills } from "./skills.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,13 +117,11 @@ 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: [...policy.resolveSkills(spec, task)],
-        includeLearnedPatterns: budget.includeLearnedPatterns,
-        perSkillMaxChars: budget.perSkillMaxChars,
-        totalMaxChars: budget.totalMaxChars,
+        skills: [...resolveDagNodeSkills(spec, task)],
+        includeLearnedPatterns: task.role === "implementer",
+        perSkillMaxChars: DEFAULT_SKILL_INSTRUCTION_MAX_CHARS,
+        totalMaxChars: DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS,
     };
     return { id: profileId(request), ...request };
 }
@@ -513,8 +511,7 @@ function stripPromptText(instruction) {
     return metadata;
 }
 export function buildNodePromptFromSnapshot(input) {
-    const policy = resolveContextPolicy(input.spec);
-    const skillNames = policy.resolveSkills(input.spec, input.task);
+    const skillNames = resolveDagNodeSkills(input.spec, input.task);
     const resolvedSkillInstructions = resolveNodeSkillsFromSnapshot(input.snapshot, input.spec, input.task);
     return {
         prompt: buildDagNodePromptEnvelope({
@@ -523,7 +520,6 @@ export function buildNodePromptFromSnapshot(input) {
             upstream: input.upstream,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
-            maxUpstreamChars: policy.resolveMaxUpstreamChars(input.task),
         }),
         resolvedSkills: resolvedSkillInstructions.map(stripPromptText),
     };