@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,1277 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
+import { executePiStep, } from "./pi-executor.js";
+import { buildPiWriterToolPolicyContext, createPiWriterCustomTools, } from "./pi-writer-tool-policy.js";
+import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND_CAPABILITY_REGISTRY, resolveCaseIdFromWriteSet, resolveEvidenceDirFromWriteSet, } from "./pi-playwright-cli-tool.js";
+import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
+import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
+import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
+import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
+import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
+import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
+/**
+ * Writer classification for a length-stopped thinking-only attempt: the model
+ * exhausted its output budget thinking but never issued a write/edit tool call
+ * and produced zero attributed diff. This is a terminal, non-retryable
+ * diagnosis (the same prompt + model will hit the same budget wall); the
+ * recommendation is a model switch plus a fresh run. It must NOT mask a
+ * recoverable partial-write-set (incomplete-write-set) upgrade.
+ */
+export const WRITER_THINKING_EXHAUSTED_CATEGORY = "writer-thinking-exhausted";
+function readWriterThinkingExhaustionEvidence(result) {
+    const wider = result;
+    return {
+        ...(typeof wider.stopReason === "string"
+            ? { stopReason: wider.stopReason }
+            : {}),
+        ...(typeof wider.thinkingObserved === "boolean"
+            ? { thinkingObserved: wider.thinkingObserved }
+            : {}),
+        ...(typeof wider.writeToolCallCount === "number"
+            ? { writeToolCallCount: wider.writeToolCallCount }
+            : {}),
+    };
+}
+/**
+ * Pure classification predicate for writer-thinking-exhausted (AC-002).
+ * Requires ALL of: empty-output base category, stopReason exactly "length",
+ * thinking observed, zero write/edit tool calls, and a confirmed empty
+ * run-attributed diff. Recoverable partial writes stay incomplete-write-set
+ * because the caller only consults this predicate when the completeness gate
+ * did not upgrade the category.
+ */
+export function isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles) {
+    if (mapped.ok)
+        return false;
+    if (mapped.failureCategory !== "empty-output")
+        return false;
+    const evidence = readWriterThinkingExhaustionEvidence(result);
+    if (evidence.stopReason !== "length")
+        return false;
+    if (evidence.thinkingObserved !== true)
+        return false;
+    if ((evidence.writeToolCallCount ?? 0) !== 0)
+        return false;
+    if (changeManifestChangedFiles === undefined)
+        return false;
+    if (changeManifestChangedFiles.length !== 0)
+        return false;
+    return true;
+}
+export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
+/** Bounded writer tools include bash; edit/write remain policy-wrapped via SDK customTools. */
+export const DAG_PI_WRITE_TOOLS = [
+    "read",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+    "bash",
+];
+export const DEFAULT_DAG_PI_PROVIDER = "wizard-local";
+const WRITER_OUTCOME_PROTOCOL_LINE = "IMPLEMENTATION_OUTCOME:";
+export const DAG_PI_MODEL_PROVIDERS = {
+    "gpt-5.3-codex-spark": "wizard-local",
+    "gpt-5.5": "wizard-local",
+    "glm-5.2": "wizard-local",
+    "deepseek-v4-flash": "deepseek",
+    "deepseek-v4-pro": "deepseek",
+};
+const SAFE_PI_STEPS = new Set([
+    "analyze",
+    "plan",
+    "verify",
+    "retrospective",
+    "spec",
+]);
+const PI_WRITE_STEPS = new Set([...SAFE_PI_STEPS, "implement"]);
+const ROLE_TO_PERSONA = {
+    planner: "planner",
+    scout: "scout",
+    implementer: "planner",
+    reviewer: "reviewer",
+    supervisor: "supervisor",
+    verifier: "verifier",
+    closeout: "closeout",
+};
+const PI_STEP_PERSONA_ALIASES = {
+    analyze: "scout",
+    plan: "planner",
+    verify: "verifier",
+    retrospective: "closeout",
+    spec: "planner",
+    generic: "planner",
+    scout: "scout",
+    planner: "planner",
+    reviewer: "reviewer",
+    supervisor: "supervisor",
+    verifier: "verifier",
+    closeout: "closeout",
+};
+const PERSONA_TO_EXECUTOR_STEP = {
+    closeout: "retrospective",
+    planner: "plan",
+    reviewer: "analyze",
+    scout: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+};
+const PI_WRITE_ROLE_TO_STEP = {
+    planner: "plan",
+    scout: "analyze",
+    implementer: "implement",
+    reviewer: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+    closeout: "retrospective",
+};
+const PI_WRITE_STEP_ALIASES = {
+    analyze: "analyze",
+    plan: "plan",
+    verify: "verify",
+    retrospective: "retrospective",
+    spec: "spec",
+    generic: "plan",
+    scout: "analyze",
+    planner: "plan",
+    reviewer: "analyze",
+    supervisor: "analyze",
+    verifier: "verify",
+    closeout: "retrospective",
+    implement: "implement",
+    implementer: "implement",
+};
+/** Map DAG `piStep` / `role` to a DAG persona for read-only Pi nodes. */
+export function resolveDagPiPersona(task) {
+    if (task.piStep) {
+        const mapped = PI_STEP_PERSONA_ALIASES[task.piStep.trim().toLowerCase()];
+        if (mapped)
+            return mapped;
+    }
+    if (task.role) {
+        return ROLE_TO_PERSONA[task.role];
+    }
+    return "planner";
+}
+function resolvePiExecutorStep(persona) {
+    return PERSONA_TO_EXECUTOR_STEP[persona];
+}
+function isDagPiWriteTask(task) {
+    return task.executor === "pi" && task.toolProfile === "write";
+}
+/** Map DAG `piStep` / `role` to a safe workflow step for read-only Pi or bounded write. */
+export function resolveDagPiStepName(task) {
+    if (isDagPiWriteTask(task)) {
+        if (task.piStep) {
+            const mapped = PI_WRITE_STEP_ALIASES[task.piStep.trim().toLowerCase()];
+            if (mapped)
+                return mapped;
+        }
+        if (task.role) {
+            return PI_WRITE_ROLE_TO_STEP[task.role];
+        }
+        return "implement";
+    }
+    return resolvePiExecutorStep(resolveDagPiPersona(task));
+}
+export function resolveDagPiToolNames(task) {
+    if (!isDagPiWriteTask(task))
+        return [...DAG_PI_READONLY_TOOLS];
+    const tools = [...DAG_PI_WRITE_TOOLS];
+    // Pi SDK activates custom tools only when they are in this explicit list.
+    // Command capabilities (playwright_cli) stay capability-gated; read-only nodes never get command tools.
+    if (dagCommandPolicyAllows(task.commandPolicy, "playwright-cli")) {
+        tools.push("playwright_cli");
+    }
+    return tools;
+}
+export function buildDagPiUserMessage(task, persona, step) {
+    const role = task.role ?? "unspecified";
+    const writePolicy = task.writePolicy ?? "read-only (default)";
+    if (isDagPiWriteTask(task)) {
+        const outcomeInstruction = task.writerOutcomePolicy
+            ? [
+                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. The runner measures your diff mechanically from git status snapshots taken before and after this node: code pasted into the response text is NOT an implementation and yields an empty diff. Use changed only after actually calling write/edit tools that persist files to disk; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed. Claiming changed without a persisted diff fails this node as invalid-output.",
+                task.writerOutcomePolicy.requireChangedFiles
+                    ? "This generation node requires a non-empty bounded diff; already-satisfied cannot complete it successfully."
+                    : undefined,
+            ]
+                .filter((value) => Boolean(value))
+                .join(" ")
+            : undefined;
+        return [
+            `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
+            "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+            "Use write tools only for the bounded implementation requested by this node.",
+            "The upstream plan node's output is a BLUEPRINT, not a deliverable: reading it never satisfies this node. You MUST materialize the plan into actual working-tree changes by calling write/edit tools before claiming changed. A detailed plan that names every file, test, or snippet still requires you to write those files yourself.",
+            "Forbidden paths bound the writeSet, not the task: when the task only requires writing inside the writeSet (e.g. adding tests that call existing public APIs), a forbidden src/** does not make the task impossible — do NOT claim blocked merely because some path you never need to write is forbidden. blocked is only for when you genuinely cannot produce the required writeSet changes.",
+            outcomeInstruction,
+            `Allowed paths: ${(task.allowedPaths ?? []).join(", ") || "(none declared)"}.`,
+            `Write set: ${(task.writeSet ?? []).join(", ") || "(none declared)"}.`,
+            `Forbidden paths: ${(task.forbiddenPaths ?? []).join(", ") || "(none declared)"}.`,
+            "Preserve unrelated files. Do not edit outside allowedPaths/writeSet. Never write forbiddenPaths, .harness/dag-runs/**, or undeclared root artifacts/**.",
+            "Return concise Markdown with changed files, verification performed or still required, and residual risks.",
+            "Do not wrap the output in code fences and do not add conversational preamble.",
+        ]
+            .filter((value) => Boolean(value))
+            .join(" ");
+    }
+    // Decision Gate nodes must emit a mandatory DECISION_ENVELOPE_JSON fenced block;
+    // do not inject the global no-fence instruction that would conflict with outputContract.
+    if (task.decisionGate?.enabled === true) {
+        return [
+            `You are executing hybrid DAG node "${task.id}" (role=${role}, piPersona=${persona}, piStep=${step}, writePolicy=${writePolicy}).`,
+            "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+            "Use read-only tools only. Do not edit, write, or commit repository files.",
+            "Return your conclusion as Markdown that includes exactly one ```DECISION_ENVELOPE_JSON fenced block (info string DECISION_ENVELOPE_JSON, not json) matching the Decision Envelope schema, plus a short evidence/risk summary.",
+            "Follow the node outputContract for the mandatory fenced block. Do not add conversational preamble outside the required Markdown structure.",
+        ].join(" ");
+    }
+    return [
+        `You are executing hybrid DAG node "${task.id}" (role=${role}, piPersona=${persona}, piStep=${step}, writePolicy=${writePolicy}).`,
+        "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+        "Use read-only tools only. Do not edit, write, or commit repository files.",
+        "Return your conclusion as plain Markdown text suitable for downstream DAG nodes.",
+        "Do not wrap the output in code fences and do not add conversational preamble.",
+    ].join(" ");
+}
+export function resolveDagPiModelConfig(modelReference, options) {
+    const separatorIndex = modelReference.indexOf("/");
+    const qualified = separatorIndex >= 0;
+    const provider = qualified
+        ? modelReference.slice(0, separatorIndex)
+        : (DAG_PI_MODEL_PROVIDERS[modelReference] ?? DEFAULT_DAG_PI_PROVIDER);
+    const model = qualified
+        ? modelReference.slice(separatorIndex + 1)
+        : modelReference;
+    if (!provider || !model) {
+        throw new Error(`invalid DAG Pi model reference "${modelReference}": expected non-empty provider/model`);
+    }
+    const explicitThinking = options?.thinking?.trim();
+    const thinking = explicitThinking ??
+        (provider === "wizard-local" && model === "gpt-5.5" ? "low" : undefined);
+    return {
+        provider,
+        model,
+        ...(thinking ? { thinking } : {}),
+    };
+}
+const SUMMARY_STDOUT_MAX = 4_000;
+const SUMMARY_STDERR_MAX = 2_000;
+export function buildPiPromptRedactedMarkdown(prompt) {
+    const redacted = redactPromptForLog(prompt);
+    return [
+        "# Pi prompt (redacted)",
+        "",
+        `- ${redacted}`,
+        "",
+        "Full prompt text is not stored. See node `result.summary.md` for execution metadata.",
+        "",
+    ].join("\n");
+}
+export function buildPiResultSummaryMarkdown(input) {
+    const stdout = truncateOutput(input.result.stdout, SUMMARY_STDOUT_MAX);
+    const stderr = truncateOutput(input.result.stderr || "", SUMMARY_STDERR_MAX);
+    const lines = [
+        "# Pi execution summary",
+        "",
+        "## Run metadata",
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| channel | ${input.context.channel} |`,
+        `| dagRunId | ${input.context.dagRunId} |`,
+        `| dagNodeId | ${input.context.dagNodeId} |`,
+        `| cwd | ${input.context.cwd} |`,
+        `| model | ${input.model} |`,
+        `| piPersona | ${input.persona} |`,
+        `| piStep | ${input.step} |`,
+        `| ok | ${input.result.ok} |`,
+        `| failureCategory | ${input.result.failureCategory} |`,
+        `| backend | ${input.result.backend ?? "(unknown)"} |`,
+        `| sdkAttempted | ${input.result.sdkAttempted ?? false} |`,
+        `| durationMs | ${input.result.durationMs} |`,
+        `| tokensUsed | ${input.result.tokensUsed} |`,
+        `| parsedEvents | ${input.result.parsedEvents} |`,
+        "",
+        "## Prompt reference",
+        "",
+        `- ${redactPromptForLog(input.prompt)}`,
+        "",
+        "## Assistant output",
+        "",
+    ];
+    if (input.result.assistantText.trim()) {
+        lines.push("```markdown", input.result.assistantText, "```", "");
+    }
+    if (stdout.text.trim()) {
+        lines.push("### raw stdout", "", "```text", stdout.text, "```", "");
+        if (stdout.truncated)
+            lines.push("_(stdout truncated)_", "");
+    }
+    if (stderr.text.trim()) {
+        lines.push("### stderr", "", "```text", stderr.text, "```", "");
+        if (stderr.truncated)
+            lines.push("_(stderr truncated)_", "");
+    }
+    return lines.join("\n");
+}
+export async function writePiExecutorArtifacts(artifactsDir, input) {
+    const promptPath = path.join(artifactsDir, "prompt.redacted.md");
+    const summaryPath = path.join(artifactsDir, "result.summary.md");
+    await writeTextArtifactFile(promptPath, buildPiPromptRedactedMarkdown(input.prompt));
+    await writeTextArtifactFile(summaryPath, buildPiResultSummaryMarkdown(input));
+    return { promptPath, summaryPath };
+}
+async function resolveValidatedFrontendBaseUrlFromContext(workspaceRoot, runDir) {
+    try {
+        const capability = JSON.parse(await readFile(path.join(runDir, "preflight-frontend-browser-tool-shell", "frontend-browser-capability.json"), "utf8"));
+        if (capability.status !== "ready" ||
+            capability.structuredToolName !== "playwright_cli") {
+            throw new Error("invalid capability artifact");
+        }
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: missing or invalid frontend browser capability artifact");
+    }
+    const contextPath = path.join(workspaceRoot, "testcase", "frontend", "rag", "context.md");
+    let markdown;
+    try {
+        markdown = await readFile(contextPath, "utf8");
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: missing frontend context.md after environment preflight");
+    }
+    const patterns = [
+        /baseUrl\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /base[-_ ]url\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /playwright-cli open --browser=chrome\s+((?:https?):\/\/[^\s"'`<>]+)/i,
+    ];
+    let rawBaseUrl;
+    for (const pattern of patterns) {
+        const match = markdown.match(pattern);
+        if (match?.[1]) {
+            rawBaseUrl = match[1].replace(/[)\]},.;]+$/, "");
+            break;
+        }
+    }
+    if (!rawBaseUrl || !/environmentProbe\s*[:=]\s*reachable/i.test(markdown)) {
+        throw new Error("browser-command-capability-unavailable: frontend context URL is missing or not environment-validated");
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawBaseUrl);
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: invalid frontend context origin");
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash ||
+        /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(parsed.hostname)) {
+        throw new Error("browser-command-capability-unavailable: unsafe frontend context origin");
+    }
+    return parsed.toString();
+}
+const DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES = {
+    readGitStatusPorcelain,
+    recoverRootNulArtifact,
+};
+export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
+    const started = Date.now();
+    const persona = resolveDagPiPersona(input.task);
+    const step = resolveDagPiStepName(input.task);
+    const isWriteTask = isDagPiWriteTask(input.task);
+    if (isWriteTask && input.task.finalWriteSetApproval) {
+        const binding = input.task.finalWriteSetApproval;
+        const resolved = input.task.resolvedFinalWriteSetApproval;
+        if (!resolved ||
+            resolved.approvalSourceNodeId !== binding.approvalSourceNodeId ||
+            !/^[a-f0-9]{64}$/.test(resolved.approvalDigest)) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: "final-write-set-approval-invalid: writer authorization was not resolved before Pi execution",
+                failureCategory: "final-write-set-approval-invalid",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    const allowedSteps = isWriteTask ? PI_WRITE_STEPS : SAFE_PI_STEPS;
+    if (!allowedSteps.has(step)) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: `unsafe pi step mapping: ${step}`,
+            failureCategory: "invalid-output",
+            durationMs: 0,
+        };
+    }
+    let beforeStatus;
+    let beforePathFingerprints;
+    /** tools-only: keep SDK path sandbox; skip git baseline + post-diff write-guard hard fail. */
+    const skipGitWriteGuard = isWriteTask && input.task.writeGuardPolicy === "tools-only";
+    if (isWriteTask && !skipGitWriteGuard) {
+        try {
+            beforeStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-before" });
+            const beforeSnapshot = snapshotGitStatusPorcelain(beforeStatus);
+            beforePathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, beforeSnapshot);
+            await persistWriterGitBaseline({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                beforeStatus,
+                beforeSnapshot,
+                beforePathFingerprints,
+            });
+        }
+        catch (error) {
+            await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `writer Git baseline unavailable before Pi execution: ${error instanceof Error ? error.message : String(error)}`,
+                failureCategory: "write-guard",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    const reportActivity = input.reportActivity;
+    const attempt = input.attempt ?? 1;
+    const bridgeActivity = reportActivity
+        ? (kind, at) => {
+            reportActivity({
+                attempt,
+                kind,
+                at: at ?? new Date().toISOString(),
+            });
+        }
+        : undefined;
+    let writerToolPolicy;
+    const commandPolicy = resolveDagCommandPolicy(input.task.commandPolicy);
+    const allowsPlaywrightCli = dagCommandPolicyAllows(input.task.commandPolicy, "playwright-cli");
+    let playwrightToolContext;
+    if (allowsPlaywrightCli && !isWriteTask) {
+        return {
+            ok: false, stdout: "", stderr: "pi command capability requires an explicit bounded write tool profile", failureCategory: "tool-policy", durationMs: Date.now() - started,
+        };
+    }
+    if (isWriteTask || allowsPlaywrightCli) {
+        try {
+            const customTools = [];
+            if (isWriteTask) {
+                const policyContext = buildPiWriterToolPolicyContext({
+                    repoRoot: input.cwd,
+                    allowedPaths: input.task.allowedPaths,
+                    writeSet: input.task.writeSet,
+                    forbiddenPaths: input.task.forbiddenPaths,
+                    writePolicy: input.task.writePolicy,
+                });
+                customTools.push(...(await createPiWriterCustomTools(policyContext)));
+            }
+            if (commandPolicy.mode === "capability-allowlist") {
+                for (const capability of commandPolicy.capabilities) {
+                    const factory = PI_COMMAND_CAPABILITY_REGISTRY[capability];
+                    if (!factory) {
+                        throw new Error(`unknown command capability: ${capability}`);
+                    }
+                    if (capability === "playwright-cli") {
+                        const caseId = resolveCaseIdFromWriteSet(input.task.writeSet) ??
+                            input.task.id;
+                        const evidenceDir = resolveEvidenceDirFromWriteSet(input.task.writeSet) ??
+                            `testcase/frontend/evidence/${caseId}`;
+                        playwrightToolContext = {
+                            repoRoot: input.cwd,
+                            runDir: meta.runDir,
+                            nodeId: input.task.id,
+                            caseId,
+                            evidenceDir,
+                            baseUrl: await resolveValidatedFrontendBaseUrlFromContext(input.cwd, meta.runDir),
+                            inputRoot: "testcase/frontend/fixtures",
+                        };
+                        // Cleanup must be confirmed before a new case; otherwise default-session
+                        // isolation is unknown and no Pi invocation is permitted.
+                        const preCleanup = await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "pre-start");
+                        if (!preCleanup.ok) {
+                            throw new Error(`browser-command-capability-unavailable: pre-start cleanup failed (${preCleanup.errorClass ?? "unknown"})`);
+                        }
+                        customTools.push(await createPlaywrightCliTool(playwrightToolContext));
+                    }
+                    else {
+                        customTools.push(await factory(playwrightToolContext));
+                    }
+                }
+            }
+            if (customTools.length > 0) {
+                writerToolPolicy = { requireSdk: true, customTools };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `pi writer/command tool policy unavailable before Pi execution: ${error instanceof Error ? error.message : String(error)}`,
+                failureCategory: "tool-policy",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    let result;
+    try {
+        // Phase 5 (P1-9): capture the writeSet baseline BEFORE the writer provider
+        // call so a transient partial write can be rolled back and recovered via a
+        // staged child. Only frontend-implementation writers; a failed capture is a
+        // hard fail (no baseline → no rollback → no recovery). Dynamic import avoids
+        // an executor ↔ scheduler static cycle.
+        if (isWriteTask &&
+            (input.task.id === "frontend-implement-pi" ||
+                input.task.id === "frontend-repair-pi") &&
+            (input.task.writeSet?.length ?? 0) > 0) {
+            try {
+                const { captureFrontendWriterAttemptIntent } = await import("../workflows/dag/frontend-writer-recovery.js");
+                await captureFrontendWriterAttemptIntent({
+                    cwd: input.cwd,
+                    runDir: meta.runDir,
+                    writeSet: input.task.writeSet,
+                });
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    stdout: "",
+                    stderr: `frontend writer attempt baseline capture failed: ${error instanceof Error ? error.message : String(error)}`,
+                    failureCategory: "write-guard",
+                    durationMs: Date.now() - started,
+                };
+            }
+        }
+        result = await piStepFn({
+            attachedFiles: [],
+            modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
+            prompt: input.prompt,
+            repoRoot: input.cwd,
+            step,
+            toolNames: resolveDagPiToolNames(input.task),
+            userMessage: buildDagPiUserMessage(input.task, persona, step),
+            sessionEventsPath: path.join(meta.runDir, input.task.id, "session-events.jsonl"),
+            // Absolute max wall clock from adaptive liveness policy (defaults to 4h).
+            timeoutMs: input.timeoutMs,
+            stallTimeoutMs: input.stallTimeoutMs,
+            abortGraceMs: input.abortGraceMs,
+            ...(writerToolPolicy ? { writerToolPolicy } : {}),
+            onActivity: bridgeActivity
+                ? (activity) => {
+                    if (activity.kind === "lease" ||
+                        activity.kind === "synthetic-heartbeat") {
+                        return;
+                    }
+                    bridgeActivity(activity.kind, activity.at);
+                }
+                : undefined,
+        });
+    }
+    catch (error) {
+        if (playwrightToolContext) {
+            try {
+                await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "post-execution");
+            }
+            catch {
+                // best-effort
+            }
+        }
+        throw error;
+    }
+    if (playwrightToolContext) {
+        try {
+            await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "post-execution");
+        }
+        catch {
+            // best-effort controller cleanup must not mask the primary result
+        }
+    }
+    const context = {
+        channel: "dag",
+        cwd: input.cwd,
+        dagRunId: meta.runId,
+        dagNodeId: input.task.id,
+    };
+    await writePiExecutorArtifacts(path.join(meta.runDir, input.task.id), {
+        prompt: input.prompt,
+        model: input.model,
+        context,
+        result,
+        persona,
+        step,
+    });
+    const mapped = mapPiResultToDagNodeResult(result, input.task.writerOutcomePolicy
+        ? WRITER_OUTCOME_PROTOCOL_LINE
+        : input.task.firstProtocolLine);
+    if (!isWriteTask) {
+        return mapped;
+    }
+    let writeGuardOk = true;
+    let writeGuardViolations = [];
+    let changeManifestAfterStatus;
+    let changeManifestChangedFiles;
+    if (beforeStatus !== undefined) {
+        let recoveryEvidence;
+        let removalPendingRecheck;
+        try {
+            let afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
+            let afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
+            let afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            // Benign tool artifact recovery: a new untracked bounded regular file
+            // literally named `nul` at the repository root is removed with
+            // the Node file API, then git status is recaptured so the guard,
+            // outcome validation and change manifest only ever see the
+            // sanitized diff. Every non-matching candidate stays fail-closed.
+            if (afterSnapshot.has("nul")) {
+                const recoverRootNulArtifactFn = writeGuardDependencies.recoverRootNulArtifact ??
+                    recoverRootNulArtifact;
+                const recovery = await recoverRootNulArtifactFn({
+                    rootCwd: input.cwd,
+                    beforeSnapshot: snapshotGitStatusPorcelain(beforeStatus),
+                    afterSnapshot,
+                    afterPathFingerprints,
+                    candidateAuthorized: validateShellWriteGuardFromDiff({
+                        changedFiles: ["nul"],
+                        task: input.task,
+                        concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+                    }).ok,
+                });
+                const beforeStatusSha256 = createHash("sha256")
+                    .update(beforeStatus)
+                    .digest("hex");
+                const afterStatusSha256 = createHash("sha256")
+                    .update(afterStatus)
+                    .digest("hex");
+                if (recovery.action === "removed") {
+                    const evidenceBase = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "recovered",
+                        result: "removed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        removedAt: recovery.removedAt,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                    };
+                    removalPendingRecheck = evidenceBase;
+                    const recheckedStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, {
+                        phase: "pi-writer-after-recheck",
+                    });
+                    const recheckedSnapshot = snapshotGitStatusPorcelain(recheckedStatus);
+                    afterStatus = recheckedStatus;
+                    afterSnapshot = recheckedSnapshot;
+                    afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, recheckedSnapshot);
+                    recoveryEvidence = {
+                        ...evidenceBase,
+                        recheck: {
+                            statusSha256: createHash("sha256")
+                                .update(recheckedStatus)
+                                .digest("hex"),
+                            nulStillPresent: recheckedSnapshot.has("nul"),
+                        },
+                    };
+                    removalPendingRecheck = undefined;
+                }
+                else if (recovery.action === "skipped") {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "skipped",
+                        result: "kept",
+                        ...(recovery.observedSizeBytes === undefined
+                            ? {}
+                            : { observedSizeBytes: recovery.observedSizeBytes }),
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                }
+                else {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "failed",
+                        result: "removal-failed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        errorDetail: recovery.errorDetail,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                    writeGuardOk = false;
+                    writeGuardViolations = [
+                        `nul artifact removal failed: ${recovery.errorDetail}`,
+                    ];
+                }
+            }
+            const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
+            changeManifestAfterStatus = afterStatus;
+            changeManifestChangedFiles = changedFiles;
+            // Phase 5: record the attempt changed paths/hashes into the rollback
+            // intent so a transient partial write can be CAS-restored.
+            if ((input.task.id === "frontend-implement-pi" ||
+                input.task.id === "frontend-repair-pi") &&
+                (input.task.writeSet?.length ?? 0) > 0) {
+                try {
+                    const { recordFrontendWriterAttempt } = await import("../workflows/dag/frontend-writer-recovery.js");
+                    await recordFrontendWriterAttempt({
+                        cwd: input.cwd,
+                        runDir: meta.runDir,
+                        changedPaths: changedFiles,
+                    });
+                }
+                catch {
+                    // best-effort: a missing intent (no baseline captured) is a no-op
+                }
+            }
+            const guard = validateShellWriteGuardFromDiff({
+                changedFiles,
+                task: input.task,
+                concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+            });
+            writeGuardOk = writeGuardOk && guard.ok;
+            writeGuardViolations = [...writeGuardViolations, ...guard.violations];
+        }
+        catch (error) {
+            await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
+            if (removalPendingRecheck) {
+                // The artifact was already deleted but the recheck read failed:
+                // record the recovery facts with the recheck failure so the
+                // evidence trail stays complete while the node remains failed.
+                recoveryEvidence = {
+                    ...removalPendingRecheck,
+                    recheck: {
+                        failed: true,
+                        errorDetail: boundedRecoveryErrorDetail(error),
+                    },
+                };
+            }
+            writeGuardOk = false;
+            writeGuardViolations = [
+                `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            ];
+        }
+        if (recoveryEvidence) {
+            await persistBenignToolArtifactRecovery({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                evidence: recoveryEvidence,
+            });
+        }
+    }
+    let writerOutcomeViolation;
+    if (mapped.ok && input.task.writerOutcomePolicy) {
+        if (changeManifestChangedFiles === undefined) {
+            writerOutcomeViolation =
+                "writer outcome validation failed: actual diff is unavailable";
+        }
+        else {
+            const outcomeValidation = validateWriterImplementationOutcome(mapped.assistantText || mapped.stdout, changeManifestChangedFiles, {
+                requireChangedFiles: input.task.writerOutcomePolicy.requireChangedFiles === true,
+                allowMissingChangedOutcomeWhenDiffPresent: isBackendTestCompletenessRetryCandidate(input.task),
+            });
+            if (!outcomeValidation.ok) {
+                writerOutcomeViolation = outcomeValidation.reason;
+            }
+        }
+    }
+    if (writeGuardOk &&
+        beforeStatus !== undefined &&
+        changeManifestChangedFiles !== undefined) {
+        await persistWriterChangeManifest({
+            runDir: meta.runDir,
+            nodeId: input.task.id,
+            writerNodeId: input.task.id,
+            effectiveWriteSet: input.task.writeSet ?? [],
+            approvalSourceNodeId: input.task.resolvedFinalWriteSetApproval?.approvalSourceNodeId,
+            approvalDigest: input.task.resolvedFinalWriteSetApproval?.approvalDigest,
+            changedFiles: changeManifestChangedFiles,
+            beforeStatus,
+            afterStatus: changeManifestAfterStatus ?? "",
+        });
+    }
+    let completenessFailure;
+    if (writeGuardOk &&
+        isBackendTestCompletenessRetryCandidate(input.task)) {
+        try {
+            const writerRole = backendTestWriterProgressRoleForTask(input.task.id);
+            const backendLayout = resolveBackendTestLayout(meta.spec.backendTestLayout
+                ? {
+                    testRoot: meta.spec.backendTestLayout.testRoot,
+                    markdownRel: meta.spec.backendTestLayout.markdownRel,
+                    scriptRel: meta.spec.backendTestLayout.scriptRel,
+                }
+                : undefined);
+            const progress = isBackendTestShardChildTask(input.task)
+                ? await assessBackendTestShardChildCompleteness({
+                    workspaceRoot: input.cwd,
+                    role: writerRole === "pytest-generate" ? "pytest-generate" : "md-generate",
+                    writeSet: input.task.writeSet ?? [],
+                })
+                : isBackendTestMdPlanTask(input.task)
+                    ? await assessBackendTestMdPlanCompleteness(input.cwd, backendLayout)
+                    : isBackendTestPytestPlanTask(input.task)
+                        ? await assessBackendTestPytestPlanCompleteness(input.cwd, backendLayout)
+                        : writerRole === "pytest-generate"
+                            ? await assessBackendTestPytestWriterCompleteness(input.cwd, backendLayout)
+                            : await assessBackendTestMdWriterCompleteness(input.cwd, backendLayout);
+            await writeBackendTestWriterProgressArtifacts({
+                runDir: meta.runDir,
+                progress,
+                attempt: input.attempt ?? 1,
+                maxAttempts: input.task.retryPolicy?.maxAttempts ?? 3,
+            });
+            if (progress.status !== "PASS") {
+                const classified = classifyBackendTestWriterCompletenessFailure(progress);
+                // A recoverable partial write set (missing/broken files) always wins
+                // over empty-output / invalid-output / writer-empty-diff: it carries
+                // the concrete target paths the continuation attempt needs.
+                if (classified.recoverable) {
+                    completenessFailure = {
+                        failureCategory: INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+                        detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                    };
+                }
+                else if (mapped.ok && !writerOutcomeViolation) {
+                    // Non-recoverable completeness issue only overrides a clean
+                    // successful path; on an already-failed attempt, keep the
+                    // executor's original category so retries reflect the real
+                    // cause (empty-output / invalid-output / writer-empty-diff).
+                    completenessFailure = {
+                        failureCategory: "invalid-output",
+                        detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            completenessFailure = {
+                failureCategory: "invalid-output",
+                detail: `backend-test completeness gate crashed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    if (mapped.ok && writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
+        return mapped;
+    }
+    const writerThinkingExhausted = isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles);
+    const stderrParts = [mapped.stderr];
+    if (!writeGuardOk) {
+        stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
+    }
+    if (writerOutcomeViolation) {
+        stderrParts.push(writerOutcomeViolation);
+    }
+    if (completenessFailure) {
+        stderrParts.push(completenessFailure.detail);
+    }
+    if (writerThinkingExhausted) {
+        stderrParts.push(`${WRITER_THINKING_EXHAUSTED_CATEGORY}: stopReason=length, thinking observed, 0 write tool calls, 0 attributed diff; recommend a model switch and a new run`);
+    }
+    if (meta.writeGuardAttribution === "best-effort") {
+        stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
+    }
+    // Pure provider stall/timeout with zero workspace side effects is eligible
+    // for a single writer transport retry (implement-pi flake resilience).
+    // Partial writes, tool calls, or write-guard failures keep raw `timeout`.
+    const writerCleanTimeout = !mapped.ok &&
+        mapped.failureCategory === "timeout" &&
+        writeGuardOk &&
+        !completenessFailure &&
+        !writerThinkingExhausted &&
+        isWriterTransportRetryCandidate(input.task) &&
+        changeManifestChangedFiles !== undefined &&
+        changeManifestChangedFiles.length === 0 &&
+        readWriterThinkingExhaustionEvidence(result).writeToolCallCount === 0;
+    return {
+        ...mapped,
+        ok: false,
+        stderr: stderrParts.filter(Boolean).join("\n\n"),
+        failureCategory: mapped.ok
+            ? writeGuardOk
+                ? completenessFailure
+                    ? completenessFailure.failureCategory
+                    : changeManifestChangedFiles?.length === 0 &&
+                        isWriterEmptyDiffRetryCandidate(input.task) &&
+                        isChangedWriterImplementationOutcome(mapped.assistantText || mapped.stdout)
+                        ? WRITER_EMPTY_DIFF_RETRY_CATEGORY
+                        : "invalid-output"
+                : "write-guard"
+            : // When the attempt already failed with a writer-style category
+                // (empty-output / invalid-output / writer-empty-diff) but the workspace
+                // shows a recoverable partial write set, prefer incomplete-write-set so
+                // the continuation is retryable and carries the embedded target paths.
+                // Provider/transport failures (quota, auth, network, timeout,
+                // rate-limit, unavailable) keep their original category so a provider
+                // outage is never masked as a recoverable local write problem — except
+                // clean timeouts with zero attributed writes, remapped below.
+                writeGuardOk &&
+                    completenessFailure?.failureCategory ===
+                        INCOMPLETE_WRITE_SET_RETRY_CATEGORY &&
+                    (mapped.failureCategory === "empty-output" ||
+                        mapped.failureCategory === "invalid-output" ||
+                        mapped.failureCategory === WRITER_EMPTY_DIFF_RETRY_CATEGORY)
+                    ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
+                    : // writer-thinking-exhausted: a length-stopped thinking-only attempt with
+                        // zero write tool calls and zero attributed diff is terminal and
+                        // non-retryable; recommend a model switch + fresh run. Only applies on
+                        // the empty-output base category so provider/transport failures keep
+                        // their original category, and only when the completeness gate did not
+                        // upgrade to incomplete-write-set above.
+                        writerThinkingExhausted
+                            ? WRITER_THINKING_EXHAUSTED_CATEGORY
+                            : writerCleanTimeout
+                                ? WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY
+                                : mapped.failureCategory,
+        durationMs: mapped.durationMs || Date.now() - started,
+    };
+}
+export function validateWriterImplementationOutcome(text, changedFiles, options) {
+    const parsed = parseWriterImplementationOutcome(text);
+    const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
+    if (parsed.kind === "missing" &&
+        options?.allowMissingChangedOutcomeWhenDiffPresent === true &&
+        changedFiles.length > 0) {
+        return { ok: true, outcome: "changed" };
+    }
+    if (parsed.kind !== "valid") {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: ${parsed.kind} outcome; ${diagnostics}; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked`,
+        };
+    }
+    const outcome = parsed.outcome;
+    if (outcome === "blocked") {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully; ${diagnostics}`,
+        };
+    }
+    if (outcome === "changed" && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: changed outcome has an empty diff; ${diagnostics}`,
+        };
+    }
+    if (outcome === "already-satisfied" && changedFiles.length > 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: already-satisfied outcome has a non-empty diff; ${diagnostics}`,
+        };
+    }
+    if (options?.requireChangedFiles === true && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: node requires a non-empty diff; ${diagnostics}`,
+        };
+    }
+    return { ok: true, outcome };
+}
+function parseWriterImplementationOutcome(text) {
+    const lines = text.split(/\r?\n/);
+    const candidates = [];
+    for (const [lineIndex, line] of lines.entries()) {
+        const localizedOutcome = localizedWriterImplementationOutcome(line);
+        if (localizedOutcome) {
+            candidates.push({
+                lineIndex,
+                value: localizedOutcome,
+                outcome: localizedOutcome,
+            });
+            continue;
+        }
+        const nextLine = lines[lineIndex + 1];
+        const normalized = normalizeProtocolLine(line, WRITER_OUTCOME_PROTOCOL_LINE, nextLine);
+        if (normalized === undefined)
+            continue;
+        const value = normalized.slice(WRITER_OUTCOME_PROTOCOL_LINE.length).trim();
+        const outcome = isWriterImplementationOutcome(value) ? value : undefined;
+        candidates.push({
+            lineIndex,
+            value,
+            outcome,
+        });
+    }
+    if (candidates.length === 0) {
+        return { kind: "missing", candidates };
+    }
+    if (candidates.some((candidate) => candidate.outcome === undefined)) {
+        return { kind: "unknown", candidates };
+    }
+    const outcomes = new Set(candidates.map((candidate) => candidate.outcome));
+    if (outcomes.size !== 1) {
+        return { kind: "conflicting", candidates };
+    }
+    return {
+        kind: "valid",
+        outcome: candidates[0].outcome,
+        candidates,
+    };
+}
+function localizedWriterImplementationOutcome(line) {
+    const normalized = normalizedProtocolValue(line);
+    const match = /^(?:实现|实施)结果\s*[:：]\s*(已变更|已更改|已修改|已满足|无需变更|已阻塞|阻塞)$/u.exec(normalized);
+    if (!match)
+        return undefined;
+    switch (match[1]) {
+        case "已变更":
+        case "已更改":
+        case "已修改":
+            return "changed";
+        case "已满足":
+        case "无需变更":
+            return "already-satisfied";
+        case "已阻塞":
+        case "阻塞":
+            return "blocked";
+        default:
+            return undefined;
+    }
+}
+function isWriterImplementationOutcome(value) {
+    return (value === "changed" || value === "already-satisfied" || value === "blocked");
+}
+function isChangedWriterImplementationOutcome(text) {
+    const parsed = parseWriterImplementationOutcome(text);
+    return parsed.kind === "valid" && parsed.outcome === "changed";
+}
+function writerOutcomeDiagnostics(text, parsed, changedFiles) {
+    const firstNonEmpty = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? "(empty)";
+    const candidateSummary = parsed.candidates.length === 0
+        ? "none"
+        : parsed.candidates
+            .slice(0, 4)
+            .map((candidate) => candidate.outcome
+            ? `${candidate.outcome}@line${candidate.lineIndex + 1}`
+            : `unknown(${boundedWriterDiagnostic(candidate.value)})@line${candidate.lineIndex + 1}`)
+            .join(",");
+    return `firstNonEmpty=${boundedWriterDiagnostic(firstNonEmpty)}; candidates=${candidateSummary}; changedFiles=${changedFiles}`;
+}
+function boundedWriterDiagnostic(value) {
+    return JSON.stringify(truncateUtf8Preview(redactSecrets(value), 160));
+}
+export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
+    const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
+    return {
+        ok: result.ok,
+        stdout: assistantText || result.stdout,
+        stderr: result.stderr,
+        failureCategory: result.failureCategory,
+        durationMs: result.durationMs,
+        assistantText,
+        backend: result.backend,
+        sdkAttempted: result.sdkAttempted,
+        tokensUsed: result.tokensUsed,
+        parsedEvents: result.parsedEvents,
+        stopReason: readWriterThinkingExhaustionEvidence(result).stopReason,
+    };
+}
+function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
+    if (!assistantText || !firstProtocolLine)
+        return assistantText;
+    const lines = assistantText.split(/\r?\n/);
+    let protocolIndex = -1;
+    let protocolNextLineIndex = -1;
+    let protocolLine = "";
+    for (const [index, line] of lines.entries()) {
+        const nextLine = lines[index + 1];
+        const normalized = normalizeProtocolLine(line, firstProtocolLine, nextLine);
+        if (normalized !== undefined) {
+            protocolIndex = index;
+            if (normalizeProtocolLine(line, firstProtocolLine) === undefined &&
+                nextLine !== undefined &&
+                normalizedProtocolValue(nextLine) !== "") {
+                protocolNextLineIndex = index + 1;
+            }
+            protocolLine = normalized;
+            break;
+        }
+    }
+    if (protocolIndex < 0)
+        return assistantText;
+    if (protocolIndex === 0) {
+        const remaining = lines.slice(protocolNextLineIndex === 1 ? 2 : 1);
+        return [protocolLine, ...remaining].join("\n");
+    }
+    const before = lines.slice(0, protocolIndex);
+    const after = lines.slice(protocolIndex + 1);
+    if (protocolNextLineIndex === protocolIndex + 1) {
+        after.shift();
+    }
+    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, firstProtocolLine, nextLine) {
+    const normalizedLine = stripMarkdownLineDecorations(line);
+    if (!firstProtocolLine)
+        return normalizedLine;
+    const label = firstProtocolLine.replace(/[:：]\s*$/, "").trim();
+    const labelPattern = label
+        .split(/[_\-\s]+/)
+        .filter(Boolean)
+        .map(escapeRegExp)
+        .join("[_\\-\\s]+");
+    if (!labelPattern)
+        return undefined;
+    const direct = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
+    if (direct) {
+        const value = normalizedProtocolValue(direct[1] ?? "");
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    // Writers sometimes place a short delivery sentence before the protocol
+    // line. Accept the protocol token when it appears inline, while preserving
+    // the candidate value so template repetitions still fail as unknown or
+    // conflicting outcomes.
+    const inline = normalizedLine.match(new RegExp(`${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
+    if (inline) {
+        const value = normalizedProtocolValue(inline[1] ?? "");
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
+    if (splitValue && nextLine !== undefined) {
+        const value = normalizedProtocolValue(nextLine);
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    return undefined;
+}
+function normalizedProtocolValue(value) {
+    let normalized = stripMarkdownLineDecorations(value);
+    normalized = normalized.replace(/^[:：]\s*/, "").trim();
+    normalized = normalized.replace(/[。.!；;，,]+$/u, "").trim();
+    normalized = stripMarkdownLineDecorations(normalized);
+    return normalized;
+}
+function stripMarkdownLineDecorations(line) {
+    let trimmed = line.trim();
+    trimmed = trimmed.replace(/^(?:>\s*)+/, "");
+    trimmed = trimmed.replace(/^(?:[-*+]\s+|\d+[.)]\s+)/, "");
+    const emphasized = trimmed.match(/^(\*{1,3}|_{1,3}|`{1,3})\s*(.*?)\s*\1$/);
+    trimmed = (emphasized?.[2] ?? trimmed).trim();
+    return trimmed;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function persistWriterGitBaseline(input) {
+    const fingerprintEntries = [...input.beforePathFingerprints.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const baseline = {
+        schemaVersion: 1,
+        nodeId: input.nodeId,
+        phase: "pi-writer-before",
+        capturedAt: new Date().toISOString(),
+        statusSha256: createHash("sha256").update(input.beforeStatus).digest("hex"),
+        dirtyPaths: [...input.beforeSnapshot.keys()].sort(),
+        pathFingerprintsSha256: createHash("sha256")
+            .update(JSON.stringify(fingerprintEntries))
+            .digest("hex"),
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "write-guard-baseline.json", baseline);
+}
+async function persistGitWriteGuardDiagnostics(runDir, nodeId, error) {
+    if (!(error instanceof GitStatusUnavailableError))
+        return;
+    await writeDagNodeJsonArtifact(runDir, nodeId, "git-write-guard-diagnostics.json", error.diagnostics);
+}
+function boundedRecoveryErrorDetail(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return detail.length <= 1000
+        ? detail
+        : `${detail.slice(0, 1000)}...[truncated]`;
+}
+/**
+ * Persist bounded run-owned evidence for a recognized repository-root `nul`
+ * candidate: candidate path, reason, action, result and recheck facts plus
+ * status hashes. Never records environment variables or secrets.
+ */
+async function persistBenignToolArtifactRecovery(input) {
+    const artifact = {
+        schemaVersion: 1,
+        nodeId: input.nodeId,
+        candidatePath: input.evidence.candidatePath,
+        reason: input.evidence.reason,
+        action: input.evidence.action,
+        result: input.evidence.result,
+        ...(input.evidence.observedSizeBytes === undefined
+            ? {}
+            : { observedSizeBytes: input.evidence.observedSizeBytes }),
+        ...(input.evidence.errorDetail
+            ? { errorDetail: input.evidence.errorDetail }
+            : {}),
+        ...(input.evidence.removedAt
+            ? { removedAt: input.evidence.removedAt }
+            : {}),
+        beforeStatusSha256: input.evidence.beforeStatusSha256,
+        afterStatusSha256: input.evidence.afterStatusSha256,
+        recheck: input.evidence.recheck,
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "benign-tool-artifact-recovery.json", artifact);
+}
+/**
+ * Validate the writer's observed diff against its declared write boundary.
+ * Inlined mirror of runPostRunWriteGuard that reuses the already-computed diff
+ * so the change manifest and the guard share one source of truth.
+ */
+function validateShellWriteGuardFromDiff(input) {
+    return validateShellWriteGuard({
+        changedPaths: input.changedFiles,
+        writePolicy: input.task.writePolicy,
+        writeSet: input.task.writeSet,
+        allowedPaths: input.task.allowedPaths,
+        forbiddenPaths: input.task.forbiddenPaths,
+        concurrentSiblingWriteSets: input.concurrentSiblingWriteSets,
+        allowSiblingWriteSetAttribution: input.task.writePolicy === "exclusive" &&
+            (input.concurrentSiblingWriteSets?.length ?? 0) > 0,
+    });
+}
+/**
+ * Persist the writer's actual changeset as a run-owned artifact so the
+ * project governance context resolver can attribute exactly this run's
+ * writes (not final `git status`, which may include pre-existing changes).
+ */
+async function persistWriterChangeManifest(input) {
+    const manifest = {
+        schemaVersion: 1,
+        writerNodeId: input.writerNodeId,
+        effectiveWriteSet: [...input.effectiveWriteSet],
+        ...(input.approvalSourceNodeId
+            ? { approvalSourceNodeId: input.approvalSourceNodeId }
+            : {}),
+        ...(input.approvalDigest
+            ? { approvalDigest: input.approvalDigest }
+            : {}),
+        changedFiles: input.changedFiles,
+        beforeStatusSha256: createHash("sha256")
+            .update(input.beforeStatus)
+            .digest("hex"),
+        afterStatusSha256: createHash("sha256")
+            .update(input.afterStatus)
+            .digest("hex"),
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "change-manifest.json", manifest);
+}