@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/frontend-recovery-controller.js

@@ -1,202 +0,0 @@
-import { isTerminalOperationState, } from "../../worker/console/operation-store.js";
-import { runOperation, } from "../../worker/console/operation-runner.js";
-import { buildFailureCapsule, classifyFailureOwner, projectProtocolFailureReason, } from "./frontend-recovery-capsule.js";
-import { computeNormalizedFailureFingerprint, evaluateNonConvergence, foldOperationBudgets, } from "./frontend-recovery-lineage.js";
-import { projectedInterruptStatus, } from "./interrupt-request.js";
-import { evaluateNodeLiveness, } from "./liveness-policy.js";
-/**
- * Deterministic legacy Console operation-state → canonical frontend
- * operation-state/terminal projection. This is the single adapter-layer
- * projection at the controller boundary; the generic Console operation schema
- * is not changed (AC-001).
- */
-export function projectLegacyOperationState(state) {
-    switch (state) {
-        case "queued":
-        case "starting":
-        case "running":
-        case "restarting":
-            return { operationState: "active" };
-        case "succeeded":
-            return { operationState: "success", operationTerminal: "success" };
-        case "failed":
-        case "timed-out":
-        case "needs-reconcile":
-            return {
-                operationState: "failed-internal",
-                operationTerminal: "failed-internal",
-            };
-    }
-}
-/**
- * Conservative default recovery mode by owner. Non-writer owners restart as a
- * new DAG; environment issues wait for the external dependency; unknown never
- * auto-selects writer recovery (AC-003).
- */
-export function projectDefaultRecoveryMode(owner) {
-    switch (owner) {
-        case "contract":
-        case "scout":
-        case "plan":
-        case "implementation":
-        case "verification-config":
-        case "scope":
-            return "new-dag";
-        case "environment":
-            return "wait-external";
-        case "unknown":
-            return "none";
-    }
-}
-function buildCapsuleOnTerminal(input) {
-    const protocolFailureReason = projectProtocolFailureReason(input.protocolFailureReason);
-    if (input.terminalReason === "non-converging") {
-        return buildFailureCapsule({
-            parentRunId: input.parentRunId,
-            operationState: "non-converging",
-            recoveryMode: "none",
-            protocolFailureReason,
-            failureOwner: input.owner,
-            evidenceRefs: [],
-        });
-    }
-    return buildFailureCapsule({
-        parentRunId: input.parentRunId,
-        operationState: "recoverable",
-        recoveryMode: input.deps.recoveryMode ?? projectDefaultRecoveryMode(input.owner),
-        protocolFailureReason,
-        failureOwner: input.owner,
-        evidenceRefs: [],
-    });
-}
-export async function runRecoveryOperationController(input) {
-    const { operationId, parentRunId, deps } = input;
-    const maxAttempts = Math.max(1, deps.maxAttempts ?? 5);
-    const now = deps.now ?? (() => new Date());
-    const readInterrupt = deps.readInterrupt ?? (async () => undefined);
-    const readLedgers = deps.readLedgers ?? (async () => []);
-    const readChangedFiles = deps.readChangedFiles ?? (async () => []);
-    const fingerprints = [...(deps.previousFingerprints ?? [])];
-    let budgetAggregate;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const operation = await deps.store.get(operationId);
-        if (!operation) {
-            return {
-                terminalReason: "operation-not-found",
-                attempts: attempt,
-                fingerprints,
-                detail: `operation not found: ${operationId}`,
-            };
-        }
-        // Total budget fold + hard stop (resource protection, fail-closed).
-        const ledgers = await readLedgers();
-        if (deps.budget) {
-            budgetAggregate = foldOperationBudgets({
-                ledgers,
-                budget: deps.budget,
-                now,
-            });
-        }
-        if (budgetAggregate?.status === "breached") {
-            return {
-                terminalReason: "budget-exhausted",
-                attempts: attempt,
-                budgetAggregate,
-                fingerprints,
-                detail: "operation total budget breached",
-            };
-        }
-        const owner = deps.failureOwner ??
-            classifyFailureOwner({
-                rawFailureCategory: operation.errorCode,
-                nodeId: operationId,
-            });
-        const protocolFailureReason = deps.protocolFailureReason ??
-            operation.errorMessage ??
-            operation.errorCode ??
-            "unknown failure";
-        if (isTerminalOperationState(operation.state)) {
-            if (operation.state === "succeeded") {
-                return {
-                    terminalReason: "succeeded",
-                    attempts: attempt,
-                    budgetAggregate,
-                    fingerprints,
-                };
-            }
-            // Failed/timed-out: fingerprint the failure and stop if it repeats.
-            fingerprints.push(computeNormalizedFailureFingerprint({
-                failureOwner: owner,
-                protocolFailureReason,
-                invalidatedFactIds: [],
-            }));
-            const nonConvergence = evaluateNonConvergence({
-                fingerprints,
-                changedFiles: await readChangedFiles(),
-                // Budget breach already short-circuited above; fail-closed here.
-                budgetBreached: false,
-            });
-            if (nonConvergence.terminal) {
-                return {
-                    terminalReason: nonConvergence.terminalReason,
-                    attempts: attempt,
-                    budgetAggregate,
-                    fingerprints,
-                    capsule: buildCapsuleOnTerminal({
-                        parentRunId,
-                        deps,
-                        owner,
-                        protocolFailureReason,
-                        terminalReason: "non-converging",
-                    }),
-                    detail: nonConvergence.reason,
-                };
-            }
-            return {
-                terminalReason: "failed",
-                attempts: attempt,
-                budgetAggregate,
-                fingerprints,
-                capsule: buildCapsuleOnTerminal({
-                    parentRunId,
-                    deps,
-                    owner,
-                    protocolFailureReason,
-                    terminalReason: "failed",
-                }),
-            };
-        }
-        // Non-terminal: gate on liveness + interrupt before advancing.
-        const liveness = evaluateNodeLiveness({ node: deps.node ?? {}, now: now() });
-        if (liveness.status === "needs-attention") {
-            return {
-                terminalReason: "needs-attention",
-                attempts: attempt,
-                budgetAggregate,
-                fingerprints,
-                detail: "node liveness requires attention; abort recovery loop",
-            };
-        }
-        const interrupt = await readInterrupt();
-        const projected = projectedInterruptStatus(interrupt);
-        if (projected === "requested" ||
-            projected === "acknowledged" ||
-            projected === "needs-reconcile") {
-            return {
-                terminalReason: "interrupted",
-                attempts: attempt,
-                budgetAggregate,
-                fingerprints,
-                detail: `interrupt projection: ${projected}`,
-            };
-        }
-        await runOperation(operationId, deps.operationRunnerDeps);
-    }
-    return {
-        terminalReason: "max-attempts",
-        attempts: maxAttempts,
-        budgetAggregate,
-        fingerprints,
-        detail: `recovery loop exceeded maxAttempts=${maxAttempts}`,
-    };
-}

package/dist/workflows/dag/frontend-recovery-lineage.js

@@ -1,178 +0,0 @@
-import { z } from "zod";
-import { assembleCumulativeDiffContext, } from "./frontend-review-context.js";
-import { deterministicSha256 } from "./frontend-implementation-contract.js";
-/**
- * M6 candidate lineage + operation budget primitives (pure functions).
- *
- * Self-contained types only: this module never extends `DagRunState`/`DagSpec`
- * and never mutates the legacy operation/budget modules — it only imports them.
- * Candidate lineage distinguishes a committed parent candidate (retained into
- * lineage) from an uncommitted partial write (CAS-rolled back, never retained).
- */
-const hash64 = z.string().regex(/^[a-f0-9]{64}$/);
-/* ------------------------------------------------------------------ *
- * Commit state (AC-002).                                              *
- * ------------------------------------------------------------------ */
-export const commitStateSchema = z.enum([
-    "uncommitted-partial",
-    "committed-candidate",
-]);
-/**
- * Deterministic commit-state classifier. A journal that reached `completed`
- * (or a restore result that did) means the parent candidate was committed and
- * must be retained into lineage. Anything else — `blocked`, an uncommitted
- * half-write, or a rollback that could not be proven — is fail-closed to
- * `uncommitted-partial` and is never retained.
- */
-export function classifyCommitState(input) {
-    if (input.journalState === "completed") {
-        return "committed-candidate";
-    }
-    if (input.restoreResult?.state === "completed") {
-        return "committed-candidate";
-    }
-    return "uncommitted-partial";
-}
-/* ------------------------------------------------------------------ *
- * Candidate lineage (AC-002).                                         *
- * ------------------------------------------------------------------ */
-export const candidateLineageV1Schema = z
-    .object({
-    schemaVersion: z.literal(1),
-    taskBaselineHash: hash64,
-    parentRunId: z.string().min(1),
-    parentCandidateHash: hash64,
-    runBaselineHash: hash64,
-    runDeltaHash: hash64,
-    cumulativeDiffHash: hash64,
-    commitState: commitStateSchema,
-})
-    .strict();
-/**
- * taskBaseline → candidate cumulative diff digest (AC-004). Reuses the
- * deterministic `assembleCumulativeDiffContext` and returns only its
- * `cumulativeDigest`, so the lineage hash is stable regardless of input order.
- */
-export function computeCumulativeDiffHash(input) {
-    return assembleCumulativeDiffContext(input).cumulativeDigest;
-}
-function pushAggregateBreach(aggregate, dimension, consumed, limit, now) {
-    if (limit === undefined || consumed <= limit)
-        return;
-    const duplicate = aggregate.breaches.some((existing) => existing.dimension === dimension && existing.limit === limit);
-    if (!duplicate) {
-        aggregate.breaches.push({
-            dimension,
-            limit,
-            consumed,
-            at: now().toISOString(),
-        });
-    }
-    if (aggregate.mode === "hard") {
-        aggregate.status = "breached";
-    }
-}
-/**
- * Fold parent + all continuation/recovery run ledgers into a single operation
- * budget aggregate and evaluate it against the operation total `CampaignBudget`
- * limits. Missing token samples never count as zero (aligned with the ledger
- * contract): if any ledger lacks a token total, the aggregate token total is
- * `null` and no token breach is derived.
- */
-export function foldOperationBudgets(input) {
-    const now = input.now ?? (() => new Date());
-    const aggregate = {
-        schemaVersion: 1,
-        mode: input.budget.mode,
-        limits: { ...input.budget.limits },
-        consumed: {
-            executorCalls: 0,
-            wallTimeMs: 0,
-            tokens: null,
-            repairPasses: 0,
-            peakContextChars: 0,
-            missingTokenNodeIds: [],
-        },
-        breaches: [],
-        status: input.budget.mode === "record-only" ? "record-only" : "ok",
-    };
-    let anyUnknownTokens = false;
-    let knownTokenSum = 0;
-    const missing = new Set();
-    for (const ledger of input.ledgers) {
-        aggregate.consumed.executorCalls += ledger.consumed.executorCalls;
-        aggregate.consumed.wallTimeMs += ledger.consumed.wallTimeMs;
-        aggregate.consumed.repairPasses += ledger.consumed.repairPasses;
-        aggregate.consumed.peakContextChars = Math.max(aggregate.consumed.peakContextChars, ledger.consumed.peakContextChars);
-        if (ledger.consumed.tokens === null) {
-            anyUnknownTokens = true;
-        }
-        else {
-            knownTokenSum += ledger.consumed.tokens;
-        }
-        for (const nodeId of ledger.consumed.missingTokenNodeIds) {
-            missing.add(nodeId);
-        }
-        aggregate.breaches.push(...ledger.breaches);
-    }
-    aggregate.consumed.tokens = anyUnknownTokens ? null : knownTokenSum;
-    aggregate.consumed.missingTokenNodeIds = [...missing].sort((a, b) => a.localeCompare(b));
-    if (aggregate.mode === "hard") {
-        const limits = aggregate.limits;
-        pushAggregateBreach(aggregate, "executorCalls", aggregate.consumed.executorCalls, limits.maxExecutorCalls, now);
-        pushAggregateBreach(aggregate, "wallTimeMs", aggregate.consumed.wallTimeMs, limits.maxWallTimeMs, now);
-        pushAggregateBreach(aggregate, "repairPasses", aggregate.consumed.repairPasses, limits.maxRepairPasses, now);
-        pushAggregateBreach(aggregate, "contextChars", aggregate.consumed.peakContextChars, limits.maxContextChars, now);
-        if (aggregate.consumed.tokens !== null) {
-            pushAggregateBreach(aggregate, "tokens", aggregate.consumed.tokens, limits.maxTokens, now);
-        }
-    }
-    return aggregate;
-}
-/**
- * Stable, pure failure fingerprint. No wall clock, no random bytes: identical
- * inputs always produce the same digest, so repeated failures across recovery
- * runs can be compared for non-convergence detection.
- */
-export function computeNormalizedFailureFingerprint(input) {
-    const payload = {
-        failureOwner: input.failureOwner ?? "unknown",
-        protocolFailureReason: input.protocolFailureReason ?? "",
-        restartPhase: input.restartPhase ?? "unknown",
-        invalidatedFactIds: [...(input.invalidatedFactIds ?? [])].sort(),
-        commitState: input.commitState ?? "uncommitted-partial",
-    };
-    return deterministicSha256(payload);
-}
-/**
- * Bounded-loop stop decision. A repeated failure fingerprint with an empty
- * change manifest proves no workspace progress → `non-converging`. An exceeded
- * operation total budget → `budget-exhausted`. Otherwise continue (but never
- * unbounded: the controller still caps attempts).
- */
-export function evaluateNonConvergence(input) {
-    if (input.budgetBreached) {
-        return {
-            terminal: true,
-            terminalReason: "budget-exhausted",
-            reason: "operation total budget breached; stop before exhausting resources",
-        };
-    }
-    const counts = new Map();
-    for (const fingerprint of input.fingerprints) {
-        counts.set(fingerprint, (counts.get(fingerprint) ?? 0) + 1);
-    }
-    const repeated = [...counts.values()].some((count) => count >= 2);
-    if (repeated && input.changedFiles.length === 0) {
-        return {
-            terminal: true,
-            terminalReason: "non-converging",
-            reason: "repeated failure fingerprint with an empty change manifest; recovery would loop forever",
-        };
-    }
-    return {
-        terminal: false,
-        terminalReason: "continue",
-        reason: "progress observable or fingerprint changed; continue bounded recovery",
-    };
-}

package/dist/workflows/dag/frontend-review-findings.js

@@ -1,270 +0,0 @@
-import path from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { readTypedEventStoreFromJsonl, } from "./frontend-typed-event-store.js";
-/**
- * Frontend review findings → downstream work (direction A).
- *
- * When `frontend-review-pi` commits `request_review_changes`, the implementation
- * must not silently finish: the run becomes "not passed" (partial_failed +
- * terminalReason=review-request-changes), and the committed findings are
- * rendered into a downstream-task PRD draft that a later DAG round can consume
- * instead of repeating the previous flow. Rendering is deterministic (pure);
- * only the JSONL read and PRD write are IO.
- *
- * The design-review analog (`request_design_changes`) reuses the same PRD
- * rendering and typed-fact channel: a design rejection is a definite finding
- * (not a protocol/environment error), so it auto-re-enters the next plan round
- * with the committed design findings instead of terminating the run.
- */
-export const FRONTEND_REVIEW_FINDINGS_PRD_REL = "contracts/frontend-review-findings-prd.md";
-/** Review node id whose committed typed facts drive the findings PRD. */
-export const FRONTEND_REVIEW_NODE_ID = "frontend-review-pi";
-/** Design review node id whose committed typed facts drive the findings PRD. */
-export const FRONTEND_DESIGN_REVIEW_NODE_ID = "frontend-design-review-pi";
-/** Deterministic issueCategory → failure owner mapping (A+B AC-009 §4.10). */
-export function classifyReviewIssueCategoryFailureOwner(issueCategory) {
-    switch (issueCategory) {
-        case "implementation-mismatch":
-            return "implementation";
-        case "approved-design-defect":
-            return "plan";
-        case "target-surface-defect":
-            return "scout";
-        case "contract-requirement-gap":
-            return "contract";
-        case "unknown":
-        default:
-            return "unknown";
-    }
-}
-const API_SIGNAL_RE = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i;
-/** Negations for the API signal. CJK "无 API/无接口" has no \b boundary, so
- * it is matched separately from the ASCII no api/not-needed forms. */
-const API_NEGATION_RE = /(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])|无\s*api|无\s*接口/i;
-const SMALL_SIGNAL_WORDS = [
-    "单文件局部修复",
-    "局部样式",
-    "文案调整",
-    "无远程接口",
-];
-function topLevelDir(p) {
-    const normalized = p.replace(/\\/g, "/");
-    const first = normalized.split("/").filter(Boolean)[0] ?? "";
-    return first;
-}
-/** Collect unique non-empty finding `file` values (sorted, de-duplicated). */
-function findingTargetFiles(fact) {
-    const files = new Set();
-    for (const finding of fact.findings) {
-        if (typeof finding.file === "string" && finding.file.trim()) {
-            files.add(finding.file.trim());
-        }
-    }
-    return [...files].sort();
-}
-/**
- * Deterministically derive the fix scope for the downstream task. Same fact
- * always yields the same scope. The shape mirrors `resolveFrontendTaskShape`
- * signals (concentrated paths, no remote API → micro/small) so that when the
- * PRD draft is used as the next task's requirement, the frontend DAG generator
- * routes a small fix to micro/small instead of the full 11-node standard
- * topology.
- */
-export function deriveFrontendReviewFixScope(fact) {
-    const targetFiles = findingTargetFiles(fact);
-    const blob = fact.findings
-        .map((f) => `${f.issue} ${f.requiredChange ?? ""} ${f.file ?? ""}`)
-        .join("\n");
-    const hasApiSignal = API_SIGNAL_RE.test(blob) && !API_NEGATION_RE.test(blob);
-    const topDirs = new Set(targetFiles.map(topLevelDir));
-    const concentrated = targetFiles.length > 0 && topDirs.size <= 1 && targetFiles.length <= 4;
-    let shape;
-    let complexity;
-    let reason;
-    if (targetFiles.length === 0) {
-        shape = "standard";
-        complexity = "medium";
-        reason =
-            "findings carry no file references; scope unknown, keep standard topology";
-    }
-    else if (hasApiSignal) {
-        shape = "standard";
-        complexity = "medium";
-        reason = `findings reference a remote API signal; standard topology required (files=${targetFiles.length})`;
-    }
-    else if (concentrated && targetFiles.length <= 1) {
-        shape = "micro";
-        complexity = "trivial";
-        reason = "single-file concentrated fix without remote API";
-    }
-    else if (concentrated) {
-        shape = "small";
-        complexity = "low";
-        reason = `concentrated fix across ${targetFiles.length} file(s) in one top-level directory`;
-    }
-    else {
-        shape = "standard";
-        complexity = "medium";
-        reason = `fix spans ${targetFiles.length} file(s) across ${topDirs.size} top-level directories; standard topology`;
-    }
-    const allowedPaths = [
-        ...new Set([
-            ...targetFiles,
-            ...targetFiles.map((f) => `${topLevelDir(f)}/**`),
-        ]),
-    ].sort();
-    return {
-        shape,
-        complexity,
-        targetFiles,
-        allowedPaths,
-        smallSignals: [...SMALL_SIGNAL_WORDS],
-        hasApiSignal,
-        reason,
-    };
-}
-/**
- * Read the committed `request_review_changes` fact from the review node's typed
- * event store. Returns undefined when no committed request fact exists (e.g.
- * approve_review, missing store, or an unreadable store).
- */
-export async function readCommittedReviewRequestFact(input) {
-    const { runDir: reviewRunDir } = input;
-    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
-    return readCommittedRequestFactByKind({
-        runDir: reviewRunDir,
-        nodeId: reviewNodeId,
-        factsFile: "review-typed-facts.jsonl",
-        kind: "request_review_changes",
-    });
-}
-/**
- * Read the committed `request_design_changes` fact from the design review
- * node's typed event store. Returns undefined when no committed request fact
- * exists (e.g. approve_design, missing store, or an unreadable store).
- */
-export async function readCommittedDesignRequestFact(input) {
-    const { runDir: designRunDir } = input;
-    const designNodeId = input.designNodeId ?? FRONTEND_DESIGN_REVIEW_NODE_ID;
-    return readCommittedRequestFactByKind({
-        runDir: designRunDir,
-        nodeId: designNodeId,
-        factsFile: "design-typed-facts.jsonl",
-        kind: "request_design_changes",
-    });
-}
-async function readCommittedRequestFactByKind(input) {
-    let records;
-    try {
-        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
-    }
-    catch {
-        return undefined;
-    }
-    const committed = records.filter((record) => record.phase === "committed");
-    if (committed.length === 0)
-        return undefined;
-    const request = committed.find((record) => record.fact.kind === input.kind);
-    if (!request)
-        return undefined;
-    const fact = request.fact;
-    if (typeof fact !== "object" || fact === null)
-        return undefined;
-    return fact;
-}
-function bulletList(items) {
-    if (!items || items.length === 0)
-        return "_(none)_";
-    return items.map((item) => `- ${item}`).join("\n");
-}
-function findingLines(findings) {
-    if (findings.length === 0)
-        return "_(none)_";
-    return findings
-        .map((finding) => {
-        const location = [finding.file, finding.line]
-            .filter((value) => value !== undefined)
-            .join(":");
-        const prefix = location ? `[${location}] ` : "";
-        const requiredChange = finding.requiredChange
-            ? `\n  - requiredChange: ${finding.requiredChange}`
-            : "";
-        return `- ${prefix}${finding.severity}: ${finding.issue}${requiredChange}`;
-    })
-        .join("\n");
-}
-/**
- * Deterministically render a downstream-task PRD draft from a committed
- * `request_review_changes` / `request_design_changes` fact. Same fact always
- * renders byte-identical output; the parent run id and review node id are the
- * only context.
- */
-export function renderFrontendReviewFindingsPrd(input) {
-    const { parentRunId, fact } = input;
-    const isDesign = fact.kind === "request_design_changes";
-    const reviewNodeId = input.reviewNodeId ??
-        (isDesign ? FRONTEND_DESIGN_REVIEW_NODE_ID : FRONTEND_REVIEW_NODE_ID);
-    const restartPhase = classifyReviewIssueCategoryFailureOwner(fact.issueCategory);
-    const scope = deriveFrontendReviewFixScope(fact);
-    const targetSummary = scope.targetFiles.length > 0
-        ? scope.targetFiles.join(", ")
-        : fact.issueCategory;
-    return [
-        `# 修复 ${isDesign ? "设计" : "review"} 发现（${scope.shape}）：${targetSummary}`,
-        "",
-        "## 背景",
-        "",
-        `- parentRunId: \`${parentRunId}\``,
-        `- reviewNodeId: \`${reviewNodeId}\``,
-        `- typedVerdict: \`${fact.kind}\``,
-        `- issueCategory: \`${fact.issueCategory}\``,
-        `- restartPhase/failureOwner: \`${restartPhase}\``,
-        "",
-        "## 修复范围（供下一轮任务生成路由）",
-        "",
-        `- 建议 shape：\`${scope.shape}\`（micro=7 / small=10 / standard=11 节点）`,
-        `- 建议 complexity：\`${scope.complexity}\``,
-        `- 推导依据：${scope.reason}`,
-        ...(scope.hasApiSignal ? ["- ⚠️ findings 含远程 API/接口信号，走 standard 拓扑"] : []),
-        scope.targetFiles.length > 0
-            ? [`- 目标文件：${scope.targetFiles.map((f) => `\`${f}\``).join(", ")}`]
-            : ["- 目标文件：_(findings 未提供 file 引用，需人工补全)_"],
-        scope.allowedPaths.length > 0
-            ? [`- 建议 allowedPaths：${scope.allowedPaths.map((p) => `\`${p}\``).join(", ")}`]
-            : [],
-        scope.shape === "micro" || scope.shape === "small"
-            ? [`- 范围信号：${scope.smallSignals.join("、")}（供 shape 分类器识别，避免退化为全节点流程）`]
-            : [],
-        "",
-        "## 问题清单",
-        "",
-        findingLines(fact.findings),
-        "",
-        "## 证据引用",
-        "",
-        bulletList(fact.evidenceRefs),
-        "",
-        "## 修复目标",
-        "",
-        `- 按 issueCategory 映射的重启阶段（${restartPhase}）定点修复，不复用上一轮未通过的实现。`,
-        "- 逐条关闭上面「问题清单」中的 findings，并保留上一轮已通过的验证目标继续有效。",
-        `- 完成修复后重新走 frontend DAG 的 ${isDesign ? "plan → design" : "implement → verify → review"} 链，直到${isDesign ? " design-review 提交 approve_design" : " review 提交 approve_review"}。`,
-        "",
-    ].join("\n");
-}
-/** Write the findings PRD draft under the run dir (run-owned artifact). */
-export async function writeFrontendReviewFindingsPrd(input) {
-    const markdown = renderFrontendReviewFindingsPrd(input);
-    const abs = path.join(input.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL);
-    await mkdir(path.dirname(abs), { recursive: true });
-    await writeFile(abs, markdown, "utf8");
-    return FRONTEND_REVIEW_FINDINGS_PRD_REL;
-}
-export async function readFrontendReviewFindingsPrd(runDir) {
-    try {
-        return await readFile(path.join(runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL), "utf8");
-    }
-    catch {
-        return undefined;
-    }
-}