@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

package/dist/workflows/dag/interrupt-request.js

@@ -454,6 +454,8 @@ export function parseDagRequestInterruptArgs(args) {
     for (let i = 0; i < args.length; i += 1) {
         const cursor = { value: i };
         const arg = args[i];
+        if (arg === undefined)
+            break;
         const runIdValue = readFlag(args, cursor, "run-id");
         if (runIdValue !== undefined) {
             runId = runIdValue;

package/dist/workflows/dag/lifecycle.js

@@ -684,6 +684,8 @@ export function parseDagStatusArgs(args) {
     let runId;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id") {
             runId = args[++i];
             continue;
@@ -710,8 +712,11 @@ export async function runDagStatus(repoRoot, rawArgs) {
 export function parseDagDoctorArgs(args) {
     let runId;
     let markdown = false;
+    let json = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id") {
             runId = args[++i];
             if (!runId || runId.startsWith("-")) {
@@ -725,6 +730,10 @@ export function parseDagDoctorArgs(args) {
                 throw new Error("dag doctor --run-id requires a value");
             continue;
         }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
         if (arg === "--markdown") {
             markdown = true;
             continue;
@@ -734,7 +743,7 @@ export function parseDagDoctorArgs(args) {
         }
         throw new Error(`unexpected positional argument: ${arg}`);
     }
-    return { runId, markdown };
+    return { runId, markdown, json };
 }
 function findDoctorFailureNode(state) {
     if (state.pausedByNodeId) {
@@ -843,7 +852,7 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
 export async function runDagDoctor(repoRoot, rawArgs) {
     const parsed = parseDagDoctorArgs(rawArgs);
     if (parsed.runId) {
-        if (parsed.markdown) {
+        if (parsed.markdown && !parsed.json) {
             console.log(await formatDagDoctorMarkdown(repoRoot, parsed.runId));
             return;
         }

package/dist/workflows/dag/node-execution.js

@@ -15,7 +15,7 @@ import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./p
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
 import { materializeDeclaredArtifactFacts } from "./artifact-bindings.js";
 import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry, } from "./backend-test-writer-completeness.js";
-import { computeBackoffDelayMs, isCanonicalFinalVerifyShellRetryCandidate, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, OUTPUT_LIMIT_RETRY_CATEGORY, projectFrontendNodeProtocolFailureReason, resolveFrontendPlanBackupRoute, resolveFrontendPlanRetryStep, VERIFY_SHELL_RETRY_POLICY, } from "./retry-policy.js";
+import { computeBackoffDelayMs, isCanonicalFinalVerifyShellRetryCandidate, isProviderAvailabilityFailureCategory, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, OUTPUT_LIMIT_RETRY_CATEGORY, projectFrontendNodeProtocolFailureReason, resolveFrontendPlanBackupRoute, resolveFrontendPlanRetryStep, VERIFY_SHELL_RETRY_POLICY, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
 import { getStructuredContractValidator } from "./contract-output-registry.js";
@@ -568,7 +568,7 @@ export function renderFrontendPlanInputContext(input) {
         "Do not read upstream artifacts, task sources, or repository files. If this input cannot support a decision, record a genuine evidence gap.",
         "</frontend_plan_input>",
         "<plan_review_checklist>",
-        "The design reviewer re-runs these exact checks on the committed facts; satisfy every line before finalize_plan:",
+        "Satisfy these checks in the committed facts before the runtime compiles and finalizes the Plan:",
         ...checklistLines,
         "</plan_review_checklist>",
     ].join("\n");
@@ -614,6 +614,10 @@ export async function buildFrontendPlanInputContext(runDir, componentSourceCitat
 export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics, frontendPlanRetryStep) {
     if (attemptNumber <= 1)
         return basePrompt;
+    // Match the executor segmented Plan identity; custom nodes retain their terminal.
+    const planCompletion = task.id === FRONTEND_PLAN_NODE_ID
+        ? "Stop after committing the required facts. The runtime compiles and finalizes the committed ledger automatically; only repair facts reported by its validation."
+        : "Then call finalize_plan exactly once.";
     // Context overflow is a transport/session failure, not a plan-protocol
     // failure. It must take precedence over the plan retry ladder so every
     // retry, including a repeated plan overflow, starts from the compact
@@ -656,8 +660,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
         previousProtocolReason) {
         // The frontend plan node's compile authority is the committed typed
         // ledger, not a fenced JSON text artifact: its retry guidance must
-        // direct the model to re-commit corrected record_* facts and
-        // finalize_plan. The legacy full-contract JSON guidance below applies
+        // direct the model to re-commit corrected record_* facts and respect
+        // terminal ownership. The full-contract JSON guidance below applies
         // only to nodes whose authority is still a text contract artifact.
         if (task.structuredContractOutput.schemaId ===
             "frontend-implementation-contract-plan-patch-v1") {
@@ -673,7 +677,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
                 "<retry_instruction>",
                 "Previous plan ledger facts failed canonical contract validation:",
                 previousProtocolReason,
-                "Fix the reported violations by re-committing corrected record_* facts and calling finalize_plan exactly once. The committed typed ledger is the only compile authority.",
+                "Fix the reported violations by re-committing corrected record_* facts. The committed typed ledger is the only compile authority.",
+                planCompletion,
                 "Do not emit a fenced JSON contract, protected skeleton fields, or an openspec-citations block; narrative JSON is not validated and wastes the output budget.",
                 ...frontendPlanValidationRetryGuidance(previousProtocolReason),
                 ...splitGuidance,
@@ -711,7 +716,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
                 "",
                 "<retry_instruction>",
                 "Previous attempt was truncated by the provider (stopReason=length) before the plan facts were fully committed.",
-                "Re-commit the missing record_* facts and call finalize_plan exactly once; the committed typed ledger is the only compile authority. Do NOT re-read contract/scout outputs or source files — use the facts already in context. Commit record_* facts one tool call per message, then finalize_plan immediately.",
+                "Re-commit the missing record_* facts; the committed typed ledger is the only compile authority. Do NOT re-read contract/scout outputs or source files — use the facts already in context. Commit record_* facts one tool call per message.",
+                planCompletion,
                 "Do not emit a fenced JSON contract, protected skeleton fields, or an openspec-citations block; narrative JSON is not validated and wastes the output budget.",
                 "</retry_instruction>",
             ].join("\n");
@@ -732,7 +738,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
             "",
             "<retry_instruction>",
             "Frontend plan retry ladder step: compact-terminal-first.",
-            "Do NOT rewrite the narrative. Only adopt already staged/quarantined fresh facts, fill the missing required facts, then call finalize_plan exactly once.",
+            "Do NOT rewrite the narrative. Only adopt already staged/quarantined fresh facts and fill the missing required facts.",
+            planCompletion,
             "Keep the existing committed ledger intact; do not re-derive already committed facts.",
             "</retry_instruction>",
         ].join("\n");
@@ -743,7 +750,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
             "",
             "<retry_instruction>",
             "Frontend plan retry ladder step: bounded-tool-only.",
-            "Reduce reasoning and wall-clock time. Use only read / fact / terminal tools and only for the necessary missing facts, then call finalize_plan exactly once.",
+            "Reduce reasoning and wall-clock time. Use only the tools exposed for this session and only for the necessary missing facts.",
+            planCompletion,
             "Do not expand scope or re-derive already committed facts.",
             "</retry_instruction>",
         ].join("\n");
@@ -754,7 +762,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
             "",
             "<retry_instruction>",
             "Frontend plan retry ladder step: backup-model.",
-            "A backup provider/model route was selected after repeated non-converging failures. Re-derive only the missing committed facts, then call finalize_plan exactly once; do not repeat the failed strategy.",
+            "A backup provider/model route was selected after repeated non-converging failures. Re-derive only the missing committed facts; do not repeat the failed strategy.",
+            planCompletion,
             "</retry_instruction>",
         ].join("\n");
     }
@@ -793,7 +802,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
             "",
             "<retry_instruction>",
             "Previous plan attempt issued too many read-only tool calls (read/grep/ls/find) and blew up the context window. Trust the upstream frontend-contract-pi typed requirement facts and frontend-scout-pi target surface already provided — do NOT re-read contract/scout stdout, PRD/source files, or component sources you already inspected.",
-            "Minimize discovery reads: only read what you genuinely need, once. Commit record_plan_requirement / record_plan_verification_target / record_* facts directly from the facts already in context (one tool call per message), then call finalize_plan exactly once.",
+            "Minimize discovery reads: only read what you genuinely need, once. Commit the required record_* facts directly from the facts already in context (one tool call per message).",
+            planCompletion,
             "</retry_instruction>",
         ].join("\n");
     }
@@ -917,7 +927,8 @@ export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFail
                     "",
                     "<retry_instruction>",
                     "Previous attempt exceeded the structured output size limit.",
-                    "Re-commit corrected record_* facts and call finalize_plan exactly once; the committed typed ledger is the only compile authority.",
+                    "Re-commit corrected record_* facts; the committed typed ledger is the only compile authority.",
+                    planCompletion,
                     "Do not emit a fenced JSON contract, protected skeleton fields, or an openspec-citations block; narrative JSON is not validated and wastes the output budget.",
                     "</retry_instruction>",
                 ].join("\n");
@@ -1075,6 +1086,8 @@ function validateRepairArtifactGateBeforeShell(input) {
     if (!gate)
         return;
     const upstream = input.state.nodes[gate.fromNodeId];
+    if (!upstream)
+        return;
     const parsed = parseSupervisorRepairArtifact(upstream);
     if (!parsed.ok) {
         throw new Error(`repair artifact gate failed: ${parsed.reason}`);
@@ -1711,6 +1724,20 @@ export async function executeDagNode(input) {
                     ? result.stderr.slice(markerIndex, markerIndex + 4_000).trim()
                     : `backend-test Markdown plan attempt failed with ${result.failureCategory}`;
         }
+        // Decision-path Plan bridge failures surface from the executor as
+        // invalid-output (the derived relationship patch failed pre-validation),
+        // NOT through the R1 structured self-check (which only runs when
+        // result.ok). Capture the bridge diagnostics into previousProtocolReason
+        // so the next attempt prompt tells the model exactly which decision facts
+        // to repair instead of replaying the identical under-declared session.
+        if (task.id === FRONTEND_PLAN_NODE_ID &&
+            !result.ok &&
+            result.failureCategory === "invalid-output" &&
+            /frontend decision → relationship patch failed|frontend decision finalize failed/.test(result.stderr ?? "")) {
+            previousProtocolReason = (result.stderr ?? "")
+                .slice(-4_000)
+                .trim();
+        }
         if (isFrontendStructuredRepairSchemaId(task.structuredContractOutput?.schemaId)) {
             const rawText = canonicalNodeOutput(result);
             if (rawText.trim().length > 0) {
@@ -1903,13 +1930,23 @@ export async function executeDagNode(input) {
             frontendPriorFingerprints.push(fingerprint);
             frontendPlanRetryStep = nextStep;
             if (nextStep === "unsupported-provider-capability") {
+                // Reachability first: when the failed attempts never reached model
+                // reasoning (gateway 5xx / rate limit / quota / network), the
+                // ladder's fail-closed category would read as a capability mismatch
+                // and send the diagnosis the wrong way. Keep the outage visible in
+                // the node's category and explain why.
+                const providerOutage = isProviderAvailabilityFailureCategory(result.failureCategory);
                 result = {
                     ...result,
                     ok: false,
-                    failureCategory: "unsupported-provider-capability",
+                    failureCategory: providerOutage
+                        ? "upstream-unavailable"
+                        : "unsupported-provider-capability",
                     stderr: [
                         result.stderr,
-                        "frontend plan retry ladder: no compatible provider capability route for the protocol failure reason",
+                        providerOutage
+                            ? "frontend plan retry ladder: attempts failed on provider reachability (5xx / rate limit / quota / network), so this is an upstream outage, not a provider capability mismatch"
+                            : "frontend plan retry ladder: no compatible provider capability route for the protocol failure reason",
                     ]
                         .filter(Boolean)
                         .join("\n"),

package/dist/workflows/dag/reconcile-run.js

@@ -7,6 +7,8 @@ export function parseDagReconcileRunArgs(args) {
     let reason;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id")
             runId = args[++index];
         else if (arg.startsWith("--run-id="))

package/dist/workflows/dag/repair-artifact.js

@@ -330,7 +330,9 @@ export function resolveRepairTaskForGate(input) {
     }
     const candidates = directDownstream.filter(isGovernedRepairWriter);
     if (candidates.length === 1) {
-        return { ok: true, repairTask: candidates[0] };
+        const [onlyCandidate] = candidates;
+        if (onlyCandidate)
+            return { ok: true, repairTask: onlyCandidate };
     }
     const candidateIds = directDownstream.map((task) => task.id).join(", ") || "none";
     if (candidates.length === 0) {

package/dist/workflows/dag/report.js

@@ -449,6 +449,8 @@ export async function buildDagRunReportEntry(input) {
         const rankNodes = input.state.ranks[rank] ?? [];
         for (let order = 0; order < rankNodes.length; order += 1) {
             const nodeId = rankNodes[order];
+            if (nodeId === undefined)
+                continue;
             const node = input.state.nodes[nodeId];
             if (!node)
                 continue;

package/dist/workflows/dag/rerun-plan.js

@@ -1,3 +1,4 @@
+import { isCanonicalFrontendShapeDag } from "./frontend-shape-facts.js";
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
@@ -1348,6 +1349,15 @@ export async function evaluateDagRerunPlan(input) {
         }
     }
     const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, {
+        // The canonical frontend template tails into read-only artifact shells
+        // (review-context, closeout) that carry no commands. Without artifact
+        // continuation admission every from-node restart of that template was
+        // blocked as `restart-subgraph-contains-unsafe-shell`, so a frontend run
+        // could only ever be re-verified by repeating the whole chain (smoke
+        // r27-r36: ~30 min per iteration instead of ~6).
+        ...(isCanonicalFrontendShapeDag(new Map(input.parentSpec.tasks.map((task) => [task.id, task])))
+            ? { artifactContinuation: true }
+            : {}),
         ...(transportWriterRestart && effectiveFromNodeId
             ? { allowedTransportWriterNodeId: effectiveFromNodeId }
             : {}),

package/dist/workflows/dag/rerun-task.js

@@ -1,4 +1,4 @@
-import { access, readFile } from "node:fs/promises";
+import { access, mkdir, readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.js";
@@ -8,6 +8,7 @@ import { stageRecoveryChild } from "./frontend-recovery-run.js";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { DAG_RUNS_DIR, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
 import { deriveDagRerunFeedback } from "./rerun-feedback.js";
+import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 import { acquireDagRecoveryLease, bindDagRecoveryLeaseExecution, } from "./recovery-lease.js";
 import { parseDagSpec, } from "./types.js";
 export const RERUN_TASK_LINEAGE_REL_PATH = ".runtime/rerun-task-lineage.json";
@@ -26,6 +27,8 @@ export function parseDagRerunTaskArgs(args) {
     let recoveryOperationId;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id")
             parentRunId = args[++index];
         else if (arg.startsWith("--run-id="))
@@ -396,6 +399,81 @@ async function executeFrontendRecoveryContinuation(input) {
     if (!locatedChild || locatedChild.runDir !== staged.childRunDir) {
         throw new Error(`frontend recovery child lifecycle drift: ${staged.childRunId}`);
     }
+    // D (local design repair): publish a read-only snapshot of the parent's
+    // committed decision facts into the child run. The child plan node replays
+    // these through its own durable tools (normal commit entry, child binding)
+    // and the model only corrects the rows the design review flagged; the
+    // parent ledger is never rewritten and the finalize terminal is not
+    // inherited. Best-effort: a parent without plan facts plans fresh.
+    try {
+        const parentPlanLedger = path.join(located.runDir, "frontend-plan-pi", "plan-decision-facts.jsonl");
+        const parentRaw = await readFile(parentPlanLedger, "utf8");
+        const parentRecords = await readTypedEventStoreFromJsonl(parentPlanLedger);
+        // Collapse superseded records first: the parent ledger is append-only
+        // (replace:true appends a corrected row), and replaying both the original
+        // and its correction would trip FACT_IDENTITY_CONFLICT in the child.
+        const { collapseDecisionEntriesByKind } = await import("./frontend-plan-decision-contract.js");
+        const byKind = new Map();
+        for (const record of parentRecords) {
+            const kind = String(record.fact.kind);
+            if (record.phase !== "committed" || kind === "finalize_decision")
+                continue;
+            const entry = record.fact.entry;
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                continue;
+            const bucket = byKind.get(kind) ?? [];
+            bucket.push(entry);
+            byKind.set(kind, bucket);
+        }
+        let parentCanonicalSha256;
+        try {
+            const parentCanonical = await readFile(path.join(located.runDir, "contracts", "frontend-implementation-contract.json"), "utf8");
+            parentCanonicalSha256 = createHash("sha256").update(parentCanonical).digest("hex");
+        }
+        catch {
+            // Parent canonical unavailable → the identical-plan guard is skipped.
+        }
+        // Carry the design findings that blocked the parent run: the child's
+        // finalize runs a per-finding closure check against them.
+        let designFindings = [];
+        try {
+            const designFacts = await readTypedEventStoreFromJsonl(path.join(located.runDir, "frontend-design-review-pi", "design-typed-facts.jsonl"));
+            for (const record of designFacts) {
+                const fact = record.fact;
+                if (record.phase !== "committed" || fact.kind !== "design-finding")
+                    continue;
+                const finding = (fact.finding ?? {});
+                designFindings.push({
+                    severity: typeof finding.severity === "string" ? finding.severity : "Important",
+                    issue: typeof finding.issue === "string" ? finding.issue : "",
+                    requiredChange: typeof finding.requiredChange === "string" ? finding.requiredChange : "",
+                });
+            }
+        }
+        catch {
+            // No readable design findings → the closure check has no assertions.
+        }
+        const snapshot = {
+            schemaVersion: 1,
+            schemaId: "frontend-plan-parent-decision-snapshot-v1",
+            parentRunId: input.parentRunId,
+            parentLedgerSha256: createHash("sha256").update(parentRaw).digest("hex"),
+            ...(parentCanonicalSha256 ? { parentCanonicalSha256 } : {}),
+            designFindings,
+            facts: [...byKind.entries()].flatMap(([kind, entries]) => collapseDecisionEntriesByKind(kind, entries).map((entry) => ({
+                kind,
+                entry,
+            }))),
+        };
+        await mkdir(path.join(locatedChild.runDir, "frontend-plan-pi"), {
+            recursive: true,
+        });
+        await writeJsonAtomic(path.join(locatedChild.runDir, "frontend-plan-pi", "parent-decision-snapshot.json"), snapshot);
+    }
+    catch {
+        // No parent plan ledger (or unreadable) → the child plans fresh,
+        // exactly like a run without recovery lineage.
+    }
     const childSpec = await readDagRunSpec(locatedChild.runDir);
     const childState = await readDagRunState(locatedChild.runDir);
     let runSummary;

package/dist/workflows/dag/retry-policy.js

@@ -364,6 +364,24 @@ export function computeBackoffDelayMs(attemptNumber, policy) {
     const raw = policy.initialDelayMs * 2 ** exponent;
     return Math.min(raw, policy.maxDelayMs);
 }
+/**
+ * Provider-reachability failure categories: the attempt never reached model
+ * reasoning, so no capability conclusion may be drawn from it. Used to keep the
+ * plan retry ladder from relabelling an upstream outage as
+ * `unsupported-provider-capability` (2026-09-11: the gateway returned 503 while
+ * r18/r19 reported the vague capability category).
+ */
+export const PROVIDER_AVAILABILITY_FAILURE_CATEGORIES = [
+    "unavailable",
+    "upstream-unavailable",
+    "network",
+    "rate-limit",
+    "quota",
+];
+export function isProviderAvailabilityFailureCategory(category) {
+    return (category !== undefined &&
+        PROVIDER_AVAILABILITY_FAILURE_CATEGORIES.includes(category));
+}
 /**
  * A+B (AC-001/AC-005): project raw executor signals to the canonical 7-value
  * protocol failure reason. Specific signals win first, then the existing

package/dist/workflows/dag/scheduler.js

@@ -115,7 +115,7 @@ export const FRONTEND_WRITER_NODE_IDS = [
 ];
 /**
  * Run-relative artifact location read by the frontend writer admission gate.
- * M8 re-pointed the legacy prewrite-result source at the new
+ * M8 points the admission source at the canonical
  * frontend-writer-admission-result.json artifact (written by the
  * frontend-writer-admission-shell); the exported name is retained because
  * runner.ts / node-execution.ts reference it as the admission evidence source.
@@ -125,9 +125,7 @@ export { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT };
 /**
  * Read and validate the writer admission result artifact.
  * Fail-closed: a missing file or invalid payload returns ok:false and never
- * throws. This is the M8 write authorization source (replaces the legacy
- * frontend-prewrite-result-v1 for dispatch; the legacy artifact remains
- * produced only by the shadow `runFrontendPrewriteGate` library export).
+ * throws. This is the M8 write authorization source for dispatch.
  */
 export async function readFrontendPrewriteResult(runDir) {
     const artifactPath = path.join(runDir, FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT);

package/dist/workflows/dag/types.js

@@ -192,6 +192,25 @@ export const dagJsonArtifactGateSchema = z.object({
 const dagFrontendNodeIdSchema = z
     .string()
     .regex(/^[a-z][a-z0-9-]*$/, "frontend node id must be kebab-case");
+/**
+ * Requirement id accepted in a generated DAG's `requiredRequirementIds`.
+ *
+ * These ids are lifted verbatim from the task requirement ledger, which mirrors
+ * whatever the PRD wrote. A PRD that writes `AC1` (no hyphen) therefore yields an
+ * id this schema rejects, and `dagSpecSchema.parse` surfaces zod's raw issue array
+ * - so the operator saw only `"message": "Invalid"` plus a JSON pointer and had no
+ * way to learn the constraint. The message below carries it into that error.
+ *
+ * This is deliberately a fail-closed check, not a normalizer: `AC1` is
+ * canonicalized to `AC-1` upstream by `normalizeAcceptanceId` in the semantic
+ * intake, so every workflow reads the same ids. What remains here is the guard
+ * for genuinely malformed input - and because `dagSpecSchema.parse` surfaces
+ * zod's raw issue array, the message below is what makes that guard
+ * self-explanatory instead of `"message": "Invalid"` plus a JSON pointer.
+ */
+const dagRequirementIdSchema = z
+    .string()
+    .regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/, 'requirement id must be "<REQ|BR|AC>-<SEGMENT>" with a hyphen after the prefix (e.g. AC-1, AC-FE-001, REQ-SRC-ABC123); ids come verbatim from the task requirement ledger, so a PRD writing "AC1" must write "AC-1"');
 const openspecCandidatePathSchema = z
     .string()
     .refine((candidate) => !candidate.includes("\\") &&
@@ -210,9 +229,7 @@ export const dagFrontendPrewriteGateSchema = z.object({
     planFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
     reviewFromNodeId: dagFrontendNodeIdSchema,
     reviewFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
-    requiredRequirementIds: z
-        .array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/))
-        .default([]),
+    requiredRequirementIds: z.array(dagRequirementIdSchema).default([]),
     allowedMockStrategies: z
         .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
         .min(1),
@@ -422,9 +439,7 @@ export const dagFrontendDesignPolicySchema = z
     .object({
     schemaVersion: z.literal(1),
     planFromNodeId: dagFrontendNodeIdSchema,
-    requiredRequirementIds: z
-        .array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/))
-        .default([]),
+    requiredRequirementIds: z.array(dagRequirementIdSchema).default([]),
     allowedMockStrategies: z
         .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
         .min(1),
@@ -434,6 +449,29 @@ export const dagFrontendDesignPolicySchema = z
     outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
     requireSourceFreshness: z.literal(true),
     implementationWriteSet: z.array(z.string().min(1)).min(1).optional(),
+    /** Generation-frozen requirement→file ownership. Violations are
+     * machine-rejected at plan finalize (smoke r35: prose-only ownership
+     * rules were ignored by the planner and re-violated by recovery). */
+    requirementOwnership: z
+        .array(z
+        .object({
+        requirementIds: z.array(z.string().min(1)).min(1),
+        implementationFiles: z.array(z.string().min(1)).optional(),
+        verificationFiles: z.array(z.string().min(1)).optional(),
+    })
+        .strict())
+        .optional(),
+    /** Generation-frozen test capability boundary composed into the
+     * canonical dependencyPolicy by the runtime. */
+    capabilityBoundary: z
+        .object({
+        allowed: z.array(z.string().min(1)).optional(),
+        forbidden: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .optional(),
+    /** Generation-frozen interaction id vocabulary (plan finalize check). */
+    interactionIds: z.array(z.string().min(1)).optional(),
     /** Generation-frozen roots that bound custom normative directories. */
     openspecSpecRoots: z
         .array(z.string().refine((root) => isValidFrontendSpecRoot(root), "openspec spec root must be a normalized repo-relative directory"))

package/dist/workflows/dag/validate.js

@@ -222,6 +222,8 @@ function validateRepairArtifactGateConfig(task, spec, issues) {
         return;
     }
     const hardVerify = hardVerifyCandidates[0];
+    if (!hardVerify)
+        return;
     const descendantIds = new Set();
     const queue = [hardVerify.id];
     while (queue.length > 0) {
@@ -411,6 +413,8 @@ function validateSameRankWriteSetConflicts(spec, ranks, issues) {
             for (let j = i + 1; j < exclusiveWriters.length; j += 1) {
                 const left = exclusiveWriters[i];
                 const right = exclusiveWriters[j];
+                if (!left || !right)
+                    continue;
                 const leftSet = left.writeSet ?? [];
                 const rightSet = right.writeSet ?? [];
                 for (const leftEntry of leftSet) {

package/docs/README.md

@@ -80,5 +80,6 @@
 | `reports/` | 验证、dogfood、merge、init evolution 与历史 handoff 证据 |
 | `skills/` | repo-local skill registry |
 | `templates/` | 可复用任务、报告、DAG 和 init 模板 |
+| `fixtures/` | 文档与前端 DAG 验收使用的固定输入 |
 
 站上使用者文档在 `../website/docs/`；源仓治理事实以本目录、`AGENTS.md`、`harness.json`、`CHANGELOG.md` 和检查脚本为准。

package/docs/governance/README.md

@@ -10,6 +10,7 @@
 - [`harness-methodology-tdd.md`](harness-methodology-tdd.md)：测试先行的方法与边界。
 - [`harness-methodology-verification.md`](harness-methodology-verification.md)：如何用新鲜命令结果支持完成声明。
 - [`harness-methodology-debugging.md`](harness-methodology-debugging.md)：系统化定位故障，不用猜测代替证据。
+- [`defect-ledger.md`](defect-ledger.md)：真实缺陷台账与优先级规则——治理目标先从真故障选，再看代理指标排名。
 - [`document-review-policy.md`](document-review-policy.md)：文档 freshness、`reviewTier` 与 `lastReviewed` 更新边界。
 - [`lightweight-github-collaboration.md`](lightweight-github-collaboration.md)：短分支、简短 PR、CI 与 Squash Merge 的轻量协作规则。
 - [`研发模式.md`](研发模式.md)：Feature 团队推进、交付和知识回写方法论。

package/docs/init-surface.manifest.json

@@ -364,6 +364,7 @@
         "description": "Documentation and user-facing guidance changes that should be considered but should not slow normal iteration.",
         "patterns": [
           "CHANGELOG.md",
+          "CHANGELOG/**",
           "website/docs/**",
           "docs/*.md",
           "docs/architecture/**"

package/docs/operations/README.md

@@ -4,6 +4,8 @@
 
 ## 入口
 
+- [`scheduled-goal-host.md`](scheduled-goal-host.md)：Console Chat 预约宿主、服务环境、状态判读与清理。
+
 - [`local-development-environment.md`](local-development-environment.md)：本地环境、Windows 差异和常见排障。
 - [`branch-merge-guideline.md`](branch-merge-guideline.md)：按风险选择合并模式并留下 source-SHA 证据。
 - [`github-collaboration.md`](github-collaboration.md)：仓库内 GitHub 协作约定及发布通道。

package/docs/templates/README.md

@@ -30,7 +30,7 @@
 
 ## Backend-test
 
-- `backend-test-dag.json` — backend-test DAG 模板；其中 `generate-backend-md-cases-pi` 是唯一允许 `writer-empty-diff` 重试的 writer（总共两次，仅限 post-write-guard attribution 确认的空 diff）；N2/N5 合同限定 Scenario Partition 必须有源有限域。
+- `backend-test-dag.json` — backend-test DAG 模板；由 runtime builder 生成，Module Index 的 8 列、separator、单一 resolved Markdown Path 和 Split Reason 集合以 `backend-test-plan-protocol.ts` 为真源并由 drift test 校验；其中 `generate-backend-md-cases-pi` 是唯一允许 `writer-empty-diff` 重试的 writer（总共两次，仅限 post-write-guard attribution 确认的空 diff）；N2/N5 合同限定 Scenario Partition 必须有源有限域。
 - `backend-test-dag.classify.prompt.md`、`backend-test-dag.generate-pytest.prompt.md`、`backend-test-dag.review-cases.prompt.md`、`backend-test-dag.retrospect.prompt.md` — 分类、生成、审查和复盘提示。
 - `backend-test-analysis.schema.json`、`backend-test-execution.schema.json`、`backend-test-result.schema.json`、`backend-test-case-manifest.schema.json` — 分析、执行、结果与用例清单 schema。
 

package/docs/templates/agent-dag.schema.json

@@ -466,9 +466,9 @@
         "retryCategories": {
           "type": "array",
           "items": {
-            "enum": ["timeout", "network", "rate-limit", "unavailable", "empty-output", "output-limit", "output-too-large", "protocol-invalid", "invalid-output", "writer-empty-diff", "incomplete-write-set", "writer-clean-timeout", "read-burst", "context-overflow"]
+            "enum": ["timeout", "network", "rate-limit", "unavailable", "upstream-unavailable", "empty-output", "output-limit", "output-too-large", "protocol-invalid", "invalid-output", "writer-empty-diff", "incomplete-write-set", "writer-clean-timeout", "read-burst", "context-overflow"]
           },
-          "default": ["timeout", "network", "rate-limit", "unavailable", "empty-output", "output-limit"],
+          "default": ["timeout", "network", "rate-limit", "unavailable", "upstream-unavailable", "empty-output", "output-limit"],
           "description": "Failure categories eligible for retry. quota/auth/write-guard are never eligible. invalid-output is allowed only on explicit structured/protocol policies; writer-empty-diff and incomplete-write-set are reserved for requireChangedFiles generation/completeness writers; writer-clean-timeout is reserved for standard bounded writers after explicit zero-write-tool-call and empty-diff evidence."
         }
       }