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

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/frontend-implementation-contract.js

@@ -1,9 +1,86 @@
 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,6 +21,7 @@ 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";
@@ -1338,10 +1339,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."
@@ -1732,6 +1734,46 @@ 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,
@@ -1740,7 +1782,7 @@ function buildFrontendHybridDagFromTask(sources) {
         .join("\n\n");
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
-    const requirementIds = buildDagSourceBinding(sources).requirementIds;
+    const requirementIds = frontendSourceBinding.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.`
         : "";
@@ -1899,6 +1941,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     fixedVerificationContext,
                     sourceContext,
                     mockContextBlock,
+                    frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
             {
@@ -1975,6 +2018,7 @@ 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

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.",