@tea-agent/loop-agent 0.16.1-beta.1 → 0.16.1

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/failure-routing.js

@@ -46,6 +46,13 @@ function routeToProductLine(input) {
         case "skipped":
             return "DependencyFailure";
         case "shell-command":
+            if (/\b(ENOENT|PATH|command not found|No such file|not found in PATH|bash: .*: No such file)\b/i.test(raw)) {
+                return "EnvFailure";
+            }
+            if (/\b(missing VERDICT line|verdict gate blocked|VERDICT)\b/i.test(raw) &&
+                /\b(missing|malformed|unexpected|blocked)\b/i.test(raw)) {
+                return "ContractMismatch";
+            }
             if (raw.includes("flaky"))
                 return "FlakyTest";
             if (nodeId.includes("test") || raw.includes("test-bug")) {

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -1,86 +1,9 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
-import { findPackageRoot } from "../../shared/package-metadata.js";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
-/**
- * Load the canonical frontend-implementation-contract-v1 JSON Schema from the
- * installed loop-agent package docs/templates/ path. Package-root discovery
- * works from both the source module and the compiled dist module without
- * relying on CommonJS globals in the ESM runtime.
- *
- * Validation is fail-closed: missing file, malformed JSON, mismatched $id,
- * missing additionalProperties: false, or incomplete top-level required keys
- * all throw before any DAG prompt is assembled.
- */
-export function loadFrontendImplementationContractJsonSchema(startDir = path.dirname(fileURLToPath(import.meta.url))) {
-    const packageRoot = findPackageRoot(startDir);
-    if (!packageRoot) {
-        throw new Error(`cannot locate loop-agent package root from ${path.resolve(startDir)}`);
-    }
-    const schemaPath = path.join(packageRoot, "docs", "templates", "frontend-implementation-contract.schema.json");
-    let content;
-    try {
-        content = readFileSync(schemaPath, "utf-8");
-    }
-    catch (error) {
-        throw new Error(`cannot load frontend-implementation-contract.schema.json from current loop-agent package at ${schemaPath}: ${error.code ?? String(error)}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`frontend-implementation-contract.schema.json is not valid JSON: ${error.message}`);
-    }
-    if (parsed === null || typeof parsed !== "object") {
-        throw new Error("frontend-implementation-contract.schema.json root is not a JSON object");
-    }
-    const schema = parsed;
-    if (schema.$id !== FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID) {
-        throw new Error(`schema $id mismatch: expected ${FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID}, got ${String(schema.$id)}`);
-    }
-    if (schema.additionalProperties !== false) {
-        throw new Error("schema must have additionalProperties: false at top level");
-    }
-    const expectedRequired = [
-        "schemaVersion",
-        "sourceBinding",
-        "riskLevel",
-        "targets",
-        "requirements",
-        "uiStates",
-        "interactions",
-        "mockApi",
-        "designEvidence",
-        "verificationTargets",
-        "evidenceGaps",
-    ];
-    const actualRequired = Array.isArray(schema.required) ? schema.required : [];
-    const missing = expectedRequired.filter((key) => !actualRequired.includes(key));
-    if (missing.length > 0) {
-        throw new Error(`schema required fields missing: ${missing.join(", ")}`);
-    }
-    const properties = schema.properties && typeof schema.properties === "object"
-        ? schema.properties
-        : {};
-    const missingProperties = expectedRequired.filter((key) => !Object.hasOwn(properties, key));
-    if (missingProperties.length > 0) {
-        throw new Error(`schema properties missing: ${missingProperties.join(", ")}`);
-    }
-    const schemaVersion = properties.schemaVersion;
-    const mockApi = properties.mockApi;
-    const mockApiProperties = mockApi?.properties;
-    const productionDefaultOff = mockApiProperties?.productionDefaultOff;
-    if (schemaVersion?.const !== 1 || productionDefaultOff?.const !== true) {
-        throw new Error("schema fixed values are incomplete: schemaVersion.const must be 1 and mockApi.productionDefaultOff.const must be true");
-    }
-    return JSON.stringify(parsed);
-}
 const id = z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/);
 const safePath = z
     .string()

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

@@ -21,7 +21,6 @@ import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPref
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
-import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -1339,11 +1338,10 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
         allowedPaths: readOnlyPaths,
         forbiddenPaths,
         skills: FRONTEND_IMPLEMENTATION_SKILLS,
-        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.",
+        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.",
         subtask_prompt: [
             "Perform read-only Mock assessment and select one safe frontend data strategy.",
-            "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.",
+            "The first non-empty line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked.",
             "Prefer an existing native Mock facility. Use browser-intercept only with an existing browser/e2e harness. When no Mock exists but the API layer is writable, use request-adapter by adding a minimal reversible adapter/DI seam within the approved writeSet; the real adapter must remain the production default.",
             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."
@@ -1734,46 +1732,6 @@ function buildFrontendHybridDagFromTask(sources) {
             allowedPaths: taskConfig.allowedPaths,
             complexity: taskConfig.complexity,
         });
-    const frontendSourceBinding = buildDagSourceBinding(sources);
-    const frontendContractSchemaBlock = (() => {
-        const schema = loadFrontendImplementationContractJsonSchema();
-        const requirement = frontendSourceBinding.sources.find((source) => source.kind === "requirement");
-        if (!requirement) {
-            throw new Error("frontend implementation contract context requires a bound requirement source");
-        }
-        const referencePaths = frontendSourceBinding.sources
-            .filter((s) => s.kind === "reference")
-            .map((s) => s.path);
-        const fixedFields = {
-            schemaVersion: 1,
-            sourceBinding: {
-                taskId: frontendSourceBinding.taskId,
-                requirementPath: requirement.path,
-                requirementSha256: requirement.sha256,
-                referencePaths,
-                requirementIds: frontendSourceBinding.requirementIds,
-            },
-            riskLevel: frontendRisk.selectedRisk,
-            targets: { files: implementPaths.writeSet },
-        };
-        return [
-            `## ${FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID} JSON Schema (authoritative; do not guess fields)`,
-            schema,
-            "",
-            "## Fixed contract fields (deterministic; copy exactly and do not modify)",
-            JSON.stringify(fixedFields),
-            "",
-            "## Forbidden fields (these are NOT in the schema; do not emit)",
-            "- schemaId",
-            "- targetFiles",
-            "- requirementCoverage",
-            "",
-            "## Critical rules",
-            "- verificationTargets is a TOP-LEVEL required array",
-            "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
-            "- mockApi.productionDefaultOff must always be true (including strategy: not-needed)",
-        ].join("\n");
-    })();
     const sourceContext = [
         buildSourceContextBlock(sources),
         capabilityContextBlock,
@@ -1782,7 +1740,7 @@ function buildFrontendHybridDagFromTask(sources) {
         .join("\n\n");
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
-    const requirementIds = frontendSourceBinding.requirementIds;
+    const requirementIds = buildDagSourceBinding(sources).requirementIds;
     const requirementCoverageInstruction = requirementIds.length > 0
         ? `Include a Requirement Coverage section that lists every exact source identifier: ${requirementIds.join(", ")}. Preserve each identifier verbatim and map it to concrete implementation and verification steps.`
         : "";
@@ -1941,7 +1899,6 @@ function buildFrontendHybridDagFromTask(sources) {
                     fixedVerificationContext,
                     sourceContext,
                     mockContextBlock,
-                    frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
             {
@@ -2018,7 +1975,6 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
                     "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
                     sourceContext,
-                    frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
             ...(requirementIds.length > 0
@@ -4356,22 +4312,45 @@ function buildReviewNode(sources) {
         ].join("\n\n"),
     };
 }
+function buildReviewVerdictRecoveryNode(sources) {
+    return {
+        id: "review-verdict-recovery-pi",
+        depends_on: ["review-pi"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is exactly VERDICT: pass or VERDICT: request-revision, followed by the original review findings without substantive changes. No file writes.",
+        subtask_prompt: [
+            "Normalize the output format of review-pi; this is the single read-only format-recovery attempt for the review verdict protocol.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "If review-pi already contains a valid VERDICT line, preserve that verdict exactly and keep the original findings.",
+            "If it omitted or malformed the VERDICT line but states an unambiguous request-revision conclusion, emit VERDICT: request-revision and preserve the findings.",
+            "Do not invent VERDICT: pass from natural-language phrases such as 通过、PASS、✅, or general approval prose.",
+            "If the upstream conclusion is ambiguous or cannot be preserved safely, emit VERDICT: request-revision and report the format ambiguity.",
+            "Do not re-review code, expand task allowedPaths, or edit files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
 function buildReviewGateNode(sources) {
     return {
         id: "review-gate-shell",
-        depends_on: ["review-pi"],
+        depends_on: ["review-verdict-recovery-pi"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Deterministic review verdict gate: exit 0 only when review-pi first non-empty assistant output line is pass.",
-        subtask_prompt: "Deterministic gate: block downstream closeout unless review-pi emitted VERDICT: pass.",
+        outputContract: "Deterministic review verdict gate: exit 0 only when review-verdict-recovery-pi first VERDICT line is pass.",
+        subtask_prompt: "Deterministic gate: block downstream closeout unless review-verdict-recovery-pi emitted VERDICT: pass.",
         shell: {
             commands: [],
             verdictGate: {
-                fromNodeId: "review-pi",
+                fromNodeId: "review-verdict-recovery-pi",
                 accept: ["VERDICT: pass"],
                 label: "review",
                 lineMode: "first-verdict-line",
@@ -4388,13 +4367,13 @@ function buildReviewGatedHybridDag(standard, sources) {
         objective: `${standard.objective ?? ""}\n\nRoute: review-gated DAG selected by workflowPolicy/governanceProfile.`.trim(),
         globalConstraints: [
             ...(standard.globalConstraints ?? []),
-            "Review-gated DAGs must block closeout unless review-pi emits first-line VERDICT: pass.",
+            "Review-gated DAGs must block closeout unless review-verdict-recovery-pi emits first-line VERDICT: pass.",
         ],
         tasks: standard.tasks.map((task) => ({ ...task })),
     };
     const closeout = getTaskOrThrow(spec, "closeout-pi");
     replaceTask(spec, cloneTask(closeout, { depends_on: ["review-gate-shell"] }));
-    spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewGateNode(sources));
+    spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewVerdictRecoveryNode(sources), buildReviewGateNode(sources));
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
@@ -4778,6 +4757,7 @@ function buildSupervisedHybridDag(standard, sources) {
             cloneTask(buildReviewNode(sources), {
                 depends_on: reviewDependsOn,
             }),
+            buildReviewVerdictRecoveryNode(sources),
             buildReviewGateNode(sources),
             buildDecisionNode(sources),
             cloneTask(closeout, { depends_on: ["decision-pi"] }),

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/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 }
+                    : {}),
             });
         }
     }