@bf-meishijian/aip 0.0.1 → 0.0.3

package/dist/coding-run-manager.js

@@ -0,0 +1,1090 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, open, realpath, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { createAgentSession, DefaultResourceLoader, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { collectDeliveryFiles, deliveryDirectory, initializeDeliveryFiles, } from "./delivery-files.js";
+import { liveEmployee, TEAM_AGENTS } from "./live-employee.js";
+import { prepareMergeRequest, registerMergeRequest, } from "./merge-requests.js";
+import { paths } from "./paths.js";
+import { PlatformClientError } from "./platform-client.js";
+import { readJson, writeSecureJson } from "./secure-json.js";
+const execFileAsync = promisify(execFile);
+export class CodingRunManager {
+    pi;
+    active = new Map();
+    constructor(pi) {
+        this.pi = pi;
+    }
+    isBusy() {
+        return this.active.size > 0;
+    }
+    async execute(client, host, command) {
+        if (!command.run)
+            throw new Error("CODING_RUN_COMMAND_INVALID");
+        const imageRun = command.run;
+        let images;
+        try {
+            images = await Promise.all((command.run.attachments ?? []).map((attachment) => client.attachmentContent(imageRun.runId, attachment.id, {
+                hostId: host.hostId,
+                generation: host.generation,
+                turnId: imageRun.turnId,
+            })));
+        }
+        catch (error) {
+            const active = this.active.get(imageRun.runId);
+            if (active?.turnId === imageRun.turnId) {
+                active.stopping = true;
+                active.observed.stopping = true;
+                await active.session.abort();
+                await active.finished;
+                if (this.active.get(imageRun.runId) === active)
+                    this.active.delete(imageRun.runId);
+            }
+            throw error;
+        }
+        if (command.run.action === "START") {
+            const input = command.run.runInput;
+            await this.start(client, host, command.run.runId, command.run.turnId, input, false, command.run.contentMarkdown, images);
+        }
+        else if (command.run.action === "STEER") {
+            let active = this.active.get(command.run.runId);
+            if (!command.run.contentMarkdown && images.length === 0)
+                throw new Error("CODING_RUN_MESSAGE_MISSING");
+            if (active && active.turnId !== command.run.turnId) {
+                if (!active.observed.terminalReached)
+                    throw new Error("CODING_RUN_TURN_MISMATCH");
+                active.stopping = true;
+                active.observed.stopping = true;
+                await active.session.abort();
+                if (this.active.get(command.run.runId) === active)
+                    this.active.delete(command.run.runId);
+                active = undefined;
+            }
+            if (active) {
+                if (images.length > 0 && !active.session.model?.input.includes("image"))
+                    throw new Error("MODEL_IMAGES_UNSUPPORTED");
+                await active.emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "QUEUED" });
+                if (images.length > 0)
+                    await active.session.steer(command.run.contentMarkdown ?? "", images);
+                else
+                    await active.session.steer(command.run.contentMarkdown ?? "");
+                await active.emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
+            }
+            else {
+                if (!command.run.runInput)
+                    throw new Error("CODING_RUN_INPUT_MISSING");
+                await this.start(client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, images);
+            }
+        }
+        else if (command.run.action === "STOP") {
+            const active = this.active.get(command.run.runId);
+            if (active) {
+                if (active.turnId !== command.run.turnId)
+                    throw new Error("CODING_RUN_TURN_MISMATCH");
+                active.stopping = true;
+                active.observed.stopping = true;
+                await active.session.abort();
+                for (const [activityKey, agentId] of active.observed.activeTasks) {
+                    await active.emit("SUBAGENT_STOPPED", {
+                        activityKey,
+                        agentId,
+                        summary: "随主执行停止",
+                    });
+                }
+                active.observed.activeTasks.clear();
+                await active.emit("RUN_STOPPED", {});
+            }
+            else {
+                const stateFile = join(paths().runState, `${command.run.runId}.json`);
+                const state = await readJson(stateFile);
+                await eventEmitter(client, host, command.run.runId, command.run.turnId, state?.lastEventSequence ?? 0, (sequence) => writeSecureJson(stateFile, { ...state, lastEventSequence: sequence }), (value) => redactHostText(value, [paths().root]))("RUN_STOPPED", {});
+            }
+        }
+        else if (command.run.action === "RESUME") {
+            await this.start(client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, images);
+        }
+    }
+    async start(client, host, runId, turnId, input, resume, resumePrompt, images = []) {
+        const active = this.active.get(runId);
+        if (active) {
+            if (active.turnId === turnId)
+                return;
+            if (!active.observed.terminalReached)
+                throw new Error("CODING_RUN_TURN_MISMATCH");
+            await active.finished;
+            if (this.active.get(runId) === active)
+                this.active.delete(runId);
+        }
+        if (process.env.AIP_TEST_PI === "1") {
+            await this.synthetic(client, host, runId, turnId, input);
+            return;
+        }
+        const local = paths();
+        const runRoot = join(local.runWorktrees, runId);
+        await mkdir(runRoot, { recursive: true, mode: 0o700 });
+        await mkdir(local.piSessions, { recursive: true, mode: 0o700 });
+        await mkdir(local.piAgent, { recursive: true, mode: 0o700 });
+        const stateFile = join(local.runState, `${runId}.json`);
+        const storedState = await readJson(stateFile);
+        const cwd = await prepareProjects(local.repositoryCache, runRoot, runId, input.projects, Boolean(storedState?.prepared));
+        for (const project of input.projects)
+            project.devBranch ||= `aip/${runId}/${project.id.slice(0, 8)}`;
+        if (!storedState?.prepared || input.inputConflict)
+            await initializeDeliveryFiles(runRoot, input, Boolean(storedState?.prepared));
+        const deliveryInputHash = createHash("sha256")
+            .update(JSON.stringify([
+            input.primaryProjectId,
+            input.requirement.body_markdown,
+            input.technicalDesign?.content,
+        ]))
+            .digest("hex");
+        const childSessions = storedState?.childSessions ?? {};
+        let pendingDelivery = storedState?.phase !== input.phase ||
+            resumePrompt ||
+            images.length > 0 ||
+            (storedState?.deliveryInputHash && storedState.deliveryInputHash !== deliveryInputHash)
+            ? undefined
+            : storedState?.pendingDelivery
+                ? {
+                    ...storedState.pendingDelivery,
+                    turnId,
+                    hostId: host.hostId,
+                    generation: host.generation,
+                }
+                : undefined;
+        const phaseSessions = storedState?.phaseSessions ?? {};
+        const sessionPhase = input.executionPurpose === "RELEASE" ? "DEVELOPMENT" : input.phase;
+        let sessionFileRef = phaseSessions[sessionPhase];
+        let lastEventSequence = storedState?.lastEventSequence ?? 0;
+        const observed = {
+            pendingQuestion: storedState?.phase === input.phase ? (storedState.pendingQuestion ?? "") : "",
+            memberResults: new Map(),
+            activeTasks: new Map(),
+            stopping: false,
+            terminalReached: false,
+        };
+        const persistState = () => writeSecureJson(stateFile, {
+            phase: input.phase,
+            mrContext: {
+                runId,
+                turnId,
+                workItem: input.workItem,
+                projects: input.projects,
+                primaryProjectId: input.primaryProjectId,
+            },
+            prepared: true,
+            phaseSessions,
+            sessionFile: sessionFileRef,
+            lastEventSequence,
+            pendingQuestion: observed.pendingQuestion,
+            childSessions,
+            pendingDelivery,
+            deliveryInputHash,
+        });
+        const redact = (value) => redactHostText(value, [runRoot, local.root]);
+        const emit = eventEmitter(client, host, runId, turnId, lastEventSequence, (sequence) => {
+            lastEventSequence = sequence;
+            return persistState();
+        }, redact);
+        if (input.phase === "PREPARATION") {
+            await persistState();
+            await emit("PREPARATION_COMPLETED", {
+                primaryProjectId: input.primaryProjectId,
+                projects: await Promise.all(input.projects.map(async (p) => ({
+                    projectId: p.id,
+                    projectName: p.name,
+                    baselineCommit: (await execFileAsync("git", ["rev-parse", "HEAD"], {
+                        cwd: join(runRoot, safeName(p.name)),
+                    })).stdout.trim(),
+                    directory: join(runRoot, safeName(p.name)),
+                    branch: (await execFileAsync("git", ["branch", "--show-current"], {
+                        cwd: join(runRoot, safeName(p.name)),
+                    })).stdout.trim(),
+                }))),
+            });
+            return;
+        }
+        const terminal = terminalExtension(client, host, runId, turnId, runRoot, input, observed, redact, async (batch) => {
+            pendingDelivery = batch;
+            await persistState();
+        }, () => pendingDelivery, (question) => emit("QUESTION_UPDATED", { question: redact(question) }), () => emit.flush());
+        if (!this.pi.resolveRuntimeModel)
+            throw new Error("PI_RUNTIME_UNAVAILABLE");
+        const resolved = await this.pi.resolveRuntimeModel(input.providerId, input.modelId, {
+            runId,
+            turnId,
+            hostId: host.hostId,
+            generation: host.generation,
+        });
+        if (images.length > 0 && !resolved.model.input?.includes("image"))
+            throw new Error("MODEL_IMAGES_UNSUPPORTED");
+        const binding = {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            member: "supervisor",
+        };
+        const availableAgents = Object.entries(TEAM_AGENTS)
+            .filter(([member]) => input.team?.members[`${member}Id`])
+            .map(([, name]) => name);
+        const live = liveEmployee(client, runId, binding, await client.employeeConfig(runId, { ...binding, purpose: "LOAD" }), runRoot, availableAgents.length > 0, input.executionPurpose === "RELEASE", input.phase, () => observed.terminalReached);
+        const childInstances = new Map();
+        const childUpdates = new Map();
+        const childTasks = new Map();
+        const team = (api) => {
+            api.registerTool({
+                name: "subagent",
+                label: "派发研发团队",
+                description: `向实际绑定员工分派子任务，返回真实子会话结果。可用员工：${availableAgents.join("、")}。`,
+                parameters: Type.Object({
+                    agent: Type.Union(availableAgents.map((name) => Type.Literal(name))),
+                    task: Type.String({ minLength: 1 }),
+                }),
+                async execute(callId, params, signal, onUpdate) {
+                    const member = Object.entries(TEAM_AGENTS).find(([, name]) => name === params.agent)?.[0];
+                    childTasks.set(member, callId);
+                    const childBinding = { ...binding, member };
+                    let child = childInstances.get(member);
+                    observed.memberResults.delete(params.agent);
+                    childUpdates.set(member, (text) => onUpdate?.({ content: [{ type: "text", text }], details: { agent: params.agent } }));
+                    if (!child) {
+                        const childLive = liveEmployee(client, runId, childBinding, await client.employeeConfig(runId, { ...childBinding, purpose: "LOAD" }), runRoot, true, false, input.phase);
+                        const resultExtension = (pi) => pi.registerTool({
+                            name: "submit_member_result",
+                            label: "提交成员结果",
+                            description: "如实记录本次子任务的结果，未解决的问题必须 FAIL。仅向主管汇报，不确认最终交付。",
+                            parameters: Type.Object({
+                                status: Type.Union([Type.Literal("PASS"), Type.Literal("FAIL")]),
+                                summary: Type.String({ minLength: 1 }),
+                            }),
+                            async execute(_id, result) {
+                                const revisions = (await captureProjectRevisions(runRoot, input.projects, input.workItem.key, input.primaryProjectId)).filter((r) => Boolean(r));
+                                observed.memberResults.set(params.agent, {
+                                    status: result.status,
+                                    summary: result.summary,
+                                    revisions,
+                                });
+                                return toolResult("结果已记录，向主管返回结论。");
+                            },
+                        });
+                        const childLoader = new DefaultResourceLoader({
+                            cwd,
+                            agentDir: local.piAgent,
+                            noExtensions: true,
+                            noSkills: true,
+                            noPromptTemplates: true,
+                            noThemes: true,
+                            noContextFiles: true,
+                            extensionFactories: [childLive.extension, resultExtension],
+                            systemPrompt: "你是研发团队中的独立数字员工，按本次固定职责工作。",
+                        });
+                        await childLoader.reload();
+                        const file = childSessions[`${input.phase}:${member}`];
+                        const childManager = file
+                            ? SessionManager.open(join(local.piSessions, file), local.piSessions, cwd)
+                            : SessionManager.create(cwd, local.piSessions);
+                        const created = await createAgentSession({
+                            cwd,
+                            agentDir: local.piAgent,
+                            modelRuntime: resolved.runtime,
+                            model: resolved.model,
+                            thinkingLevel: input.thinkingLevel,
+                            resourceLoader: childLoader,
+                            sessionManager: childManager,
+                        });
+                        child = created.session;
+                        childLive.attach(child);
+                        childInstances.set(member, child);
+                        const childFile = childManager.getSessionFile();
+                        if (!childFile)
+                            throw new Error("CHILD_SESSION_FILE_MISSING");
+                        childSessions[`${input.phase}:${member}`] = basename(childFile);
+                        await persistState();
+                        subscribeSession(child, async (kind, payload) => {
+                            if (kind === "MESSAGE_STARTED")
+                                return;
+                            if (kind === "TEXT_DELTA") {
+                                childUpdates.get(member)?.(String(payload.text ?? ""));
+                                return;
+                            }
+                            await emit(kind, {
+                                ...payload,
+                                agentId: params.agent,
+                                phase: input.phase,
+                                parentActivityKey: childTasks.get(member),
+                                sessionId: childSessions[`${input.phase}:${member}`],
+                            });
+                        }, observed, redact);
+                    }
+                    await emit("SUBAGENT_UPDATED", {
+                        phase: input.phase,
+                        task: params.task,
+                        activityKey: callId,
+                        agentId: params.agent,
+                        sessionFileRef: childSessions[`${input.phase}:${member}`],
+                        summary: "独立子会话已就绪",
+                    });
+                    const abort = () => {
+                        void child?.abort();
+                    };
+                    signal?.addEventListener("abort", abort, { once: true });
+                    try {
+                        await child.prompt(`${initialPrompt(input, runRoot)}\n\n本次主管分派给 ${params.agent} 的任务：${params.task}\n只完成自身职责，最后调用 submit_member_result；主管负责其他成员协调和最终交付。`);
+                        await child.waitForIdle();
+                        if (signal?.aborted || observed.stopping)
+                            throw new Error("SUBAGENT_STOPPED");
+                        const result = observed.memberResults.get(params.agent);
+                        if (!result)
+                            throw new Error("SUBAGENT_RESULT_MISSING");
+                        return {
+                            content: [{ type: "text", text: JSON.stringify(result) }],
+                            details: {
+                                agent: params.agent,
+                                status: result.status,
+                                sessionFileRef: childSessions[`${input.phase}:${member}`],
+                            },
+                        };
+                    }
+                    finally {
+                        childUpdates.delete(member);
+                        signal?.removeEventListener("abort", abort);
+                    }
+                },
+            });
+        };
+        const loader = new DefaultResourceLoader({
+            cwd,
+            agentDir: local.piAgent,
+            extensionFactories: [...(availableAgents.length ? [team] : []), terminal, live.extension],
+            noSkills: true,
+            noExtensions: true,
+            noPromptTemplates: true,
+            noThemes: true,
+            noContextFiles: true,
+            systemPrompt: input.team
+                ? "你是研发团队的主管，由平台提供固定团队身份和实时能力配置。"
+                : "你是负责本工单实现、自审、测试与最终交付的数字员工。",
+        });
+        await loader.reload();
+        const existingSession = phaseSessions[sessionPhase]
+            ? join(local.piSessions, phaseSessions[sessionPhase])
+            : null;
+        let sessionManager;
+        if (existingSession) {
+            sessionManager = SessionManager.open(existingSession, local.piSessions, cwd);
+        }
+        else {
+            sessionManager = SessionManager.create(cwd, local.piSessions);
+            const allocatedSessionFile = sessionManager.getSessionFile();
+            if (!allocatedSessionFile)
+                throw new Error("PI_SESSION_FILE_MISSING");
+            const placeholder = await open(allocatedSessionFile, "wx", 0o600);
+            await placeholder.close();
+            sessionManager.setSessionFile(allocatedSessionFile);
+            sessionManager.appendCustomEntry("aip-run-binding", {
+                runId,
+            });
+        }
+        const sessionFile = sessionManager.getSessionFile();
+        if (!sessionFile)
+            throw new Error("PI_SESSION_FILE_MISSING");
+        if (!(await exists(sessionFile)))
+            throw new Error("PI_SESSION_FILE_NOT_PERSISTED");
+        const { session } = await createAgentSession({
+            cwd,
+            agentDir: local.piAgent,
+            modelRuntime: resolved.runtime,
+            model: resolved.model,
+            thinkingLevel: input.thinkingLevel,
+            resourceLoader: loader,
+            sessionManager,
+        });
+        live.attach(session);
+        const activeRun = { session, input, turnId, emit, stopping: false, observed };
+        this.active.set(runId, activeRun);
+        subscribeSession(session, (kind, payload) => emit(kind, {
+            ...payload,
+            phase: input.phase,
+            agentId: payload.agentId ?? "supervisor",
+            sessionId: sessionFileRef,
+        }), observed, redact);
+        sessionFileRef = basename(sessionFile);
+        phaseSessions[sessionPhase] = sessionFileRef;
+        await persistState();
+        await emit("RUN_STARTED", { sessionFileRef, phase: input.phase });
+        if (resumePrompt || images.length > 0) {
+            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "QUEUED" });
+            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
+        }
+        const prompt = `${initialPrompt(input, runRoot)}${resumePrompt ? `\n\n${resumePrompt}` : resume ? "\n\n继续当前会话未完成的工作，先读取最新文件和交接结果。" : ""}`;
+        activeRun.finished = driveToTerminal(session, prompt, observed, client, host, runId, turnId, emit, input.executionPurpose === "RELEASE", input.phase, images)
+            .catch(async (error) => {
+            if (activeRun.stopping)
+                return;
+            await emit("RUN_FAILED", {
+                code: error instanceof Error ? error.message.slice(0, 200) : "PI_RUN_FAILED",
+            });
+        })
+            .finally(async () => {
+            await emit.flush();
+            if (this.active.get(runId) === activeRun)
+                this.active.delete(runId);
+        });
+    }
+    async synthetic(client, host, runId, turnId, input) {
+        const emit = eventEmitter(client, host, runId, turnId);
+        await emit("RUN_STARTED", { sessionFileRef: `${runId}.jsonl` });
+        await emit("SUBAGENT_STARTED", {
+            activityKey: "reviewer-1",
+            agentId: "platform-reviewer",
+            summary: "审查实现",
+        });
+        await emit("SUBAGENT_COMPLETED", {
+            activityKey: "reviewer-1",
+            agentId: "platform-reviewer",
+            summary: "审查通过",
+        });
+        await emit("MESSAGE_COMPLETED", {
+            contentMarkdown: "实现、测试与代码审查已经完成，等待确认交付。",
+        });
+        await client.reportCodingTerminal(runId, {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            kind: "DELIVERY",
+            summary: "本地 Coding Run 验收交付",
+            knownIssues: "",
+            projectFacts: input.projects.map((project) => ({
+                projectId: project.id,
+                projectName: project.name,
+                commitSha: project.baselineCommit,
+                treeHash: "a".repeat(40),
+                branch: project.testBranch,
+            })),
+            testFacts: input.projects.map((project) => ({
+                projectId: project.id,
+                command: "pnpm test",
+                exitCode: 0,
+                commitSha: project.baselineCommit,
+                treeHash: "a".repeat(40),
+                finishedAt: new Date().toISOString(),
+            })),
+        });
+    }
+}
+function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistSequence, redact = (value) => redactHostText(value)) {
+    let sequence = initialSequence;
+    let queue = Promise.resolve();
+    const emit = (kind, payload) => {
+        sequence += 1;
+        const event = {
+            eventId: crypto.randomUUID(),
+            sequence,
+            turnId,
+            kind,
+            payload: kind === "PREPARATION_COMPLETED" ? payload : redactPayload(payload, redact),
+            createdAt: new Date().toISOString(),
+        };
+        queue = queue
+            .then(() => client.appendCodingEvents(runId, {
+            hostId: host.hostId,
+            generation: host.generation,
+            events: [event],
+        }))
+            .then(() => persistSequence?.(event.sequence))
+            .then(() => undefined)
+            .catch((error) => {
+            if (error instanceof PlatformClientError &&
+                error.status === 409 &&
+                error.code === "CODING_EVENT_TURN_STALE")
+                return;
+            throw error;
+        });
+        return queue;
+    };
+    return Object.assign(emit, { flush: () => queue });
+}
+function redactPayload(value, redact) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactPayloadValue(item, redact)]));
+}
+function redactPayloadValue(value, redact) {
+    if (typeof value === "string")
+        return redact(value);
+    if (Array.isArray(value))
+        return value.map((item) => redactPayloadValue(item, redact));
+    if (value && typeof value === "object")
+        return redactPayload(value, redact);
+    return value;
+}
+async function driveToTerminal(session, initial, observed, client, host, runId, turnId, emit, release, phase, images = []) {
+    let prompt = initial;
+    for (let attempt = 0; attempt <= 2; attempt += 1) {
+        if (!session.model?.input.includes("image") &&
+            session.messages?.some((message) => "content" in message &&
+                Array.isArray(message.content) &&
+                message.content.some((block) => block.type === "image")))
+            throw new Error("MODEL_IMAGES_UNSUPPORTED");
+        if (attempt === 0 && images.length > 0)
+            await session.prompt(prompt, { images });
+        else
+            await session.prompt(prompt);
+        await session.waitForIdle();
+        if (observed.stopping || observed.terminalReached || observed.pendingQuestion)
+            return;
+        if (attempt < 2) {
+            prompt = release
+                ? `请调用 submit_pull_requests 完成提 PR；最近错误：${observed.lastDeliveryError ?? "尚未提交"}。`
+                : `你尚未成功交付。自主补齐必需产物后调用 ${phase === "DEVELOPMENT" ? "complete_development" : "submit_delivery"}。最近提交结果：${observed.lastDeliveryError ?? "尚未提交"}。缺文件就在当前会话补齐，传输故障不要重写报告。无法继续时说明真实原因，需要沟通可记录待回应问题。`;
+            continue;
+        }
+        await client.reportCodingTerminal(runId, {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            kind: "FAILED",
+            summary: observed.lastDeliveryError ?? "Agent 多次结束但没有形成明确终态",
+            knownIssues: "",
+            failureCode: observed.lastDeliveryError?.split("\n")[0]?.slice(0, 200) ?? "PI_TERMINAL_TOOL_NOT_CALLED",
+            projectFacts: [],
+            testFacts: [],
+        });
+        observed.terminalReached = true;
+        await emit("RUN_FAILED", { code: "PI_TERMINAL_TOOL_NOT_CALLED" });
+    }
+}
+function terminalExtension(client, host, runId, turnId, runRoot, input, observed, redact, persistBatch, pendingBatch, emitQuestion, flushEvents) {
+    return (pi) => {
+        pi.registerTool({
+            name: input.executionPurpose === "RELEASE"
+                ? "submit_pull_requests"
+                : input.phase === "DEVELOPMENT"
+                    ? "complete_development"
+                    : "submit_delivery",
+            label: "提交交付",
+            description: input.executionPurpose === "RELEASE"
+                ? "核实上线清单并提交分支后，使用 Runtime GitLab 身份创建或复用 MR 并登记工单。"
+                : "开发、review、测试完成后提交交付事实。",
+            parameters: input.executionPurpose === "RELEASE"
+                ? Type.Object({
+                    checklistSummary: Type.String({
+                        description: "核实依据、无需修改或修改摘要；缺口未解决时不要提交",
+                    }),
+                    projects: Type.Array(Type.Object({
+                        project: Type.String({
+                            description: `项目名称，只能选择：${input.projects.map((p) => p.name).join("、")}`,
+                        }),
+                        title: Type.String({ description: "包含工单编号及本项目变更摘要的 MR 标题" }),
+                        description: Type.String({
+                            description: "任务目的、本项目改动、测试与验收结论、发布注意、依赖、风险回滚及清单和报告链接",
+                        }),
+                    })),
+                })
+                : Type.Object({}),
+            async execute(_toolCallId, rawParams) {
+                try {
+                    if (input.executionPurpose === "RELEASE") {
+                        const params = rawParams;
+                        if (!params?.checklistSummary?.trim())
+                            throw new Error("AIP_RELEASE_CHECKLIST_SUMMARY_REQUIRED");
+                        const files = await collectDeliveryFiles(runRoot, input, ["RELEASE_CHECKLIST"]);
+                        const checklist = {
+                            status: "VERIFIED",
+                            summary: params.checklistSummary,
+                            markdown: files[0].content,
+                        };
+                        await client.submitPullRequests(runId, {
+                            hostId: host.hostId,
+                            generation: host.generation,
+                            turnId,
+                            workItemId: input.workItem.id,
+                            projects: [],
+                            checklist,
+                        });
+                        const context = {
+                            runId,
+                            turnId,
+                            workItem: input.workItem,
+                            projects: input.projects,
+                            primaryProjectId: input.primaryProjectId,
+                        };
+                        for (const project of input.projects) {
+                            const explanation = params.projects?.find((item) => item.project === project.name);
+                            if (!explanation)
+                                throw new Error(`AIP_MR_DESCRIPTION_REQUIRED:${project.name}`);
+                            const pendingFile = join(runRoot, `mr-pending-${safeName(project.id)}.json`);
+                            const result = await prepareMergeRequest({
+                                project,
+                                cwd: join(runRoot, safeName(project.name)),
+                                title: explanation.title,
+                                description: explanation.description,
+                                pendingFile,
+                            });
+                            await registerMergeRequest(client, context, host, result, pendingFile);
+                        }
+                        await client.submitPullRequests(runId, {
+                            hostId: host.hostId,
+                            generation: host.generation,
+                            turnId,
+                            workItemId: input.workItem.id,
+                            projects: [],
+                            completeRelease: true,
+                        });
+                        observed.terminalReached = true;
+                        return toolResult("上线清单已核实，MR 已提交并登记，等待合并；平台负责查询最新状态。");
+                    }
+                    const existing = pendingBatch();
+                    if (existing && existing.turnId === turnId) {
+                        await flushEvents();
+                        await uploadBatch(client, runId, existing);
+                        await persistBatch(undefined);
+                        observed.terminalReached = true;
+                        return toolResult("交付已提交，等待经办人确认。");
+                    }
+                    const files = await collectDeliveryFiles(runRoot, input, input.phase === "DEVELOPMENT"
+                        ? ["SUMMARY", "CODE_REVIEW", "IMPLEMENTATION_PLAN", "RELEASE_CHECKLIST"]
+                        : undefined);
+                    const projectFacts = await collectProjectFacts(runRoot, input.projects, input.workItem.key, input.primaryProjectId);
+                    const batch = {
+                        hostId: host.hostId,
+                        generation: host.generation,
+                        turnId,
+                        kind: input.phase === "DEVELOPMENT" ? "DEVELOPMENT_COMPLETED" : "DELIVERY",
+                        submissionId: crypto.randomUUID(),
+                        files,
+                        summary: files.find((file) => file.slot === "SUMMARY").content,
+                        knownIssues: "",
+                        projectFacts,
+                        testFacts: [],
+                    };
+                    await persistBatch(batch);
+                    await flushEvents();
+                    await uploadBatch(client, runId, batch);
+                    await persistBatch(undefined);
+                    observed.terminalReached = true;
+                    return toolResult("交付已提交，等待经办人确认。");
+                }
+                catch (error) {
+                    observed.lastDeliveryError =
+                        error instanceof Error ? error.message : "AIP_DELIVERY_FAILED";
+                    if (error instanceof PlatformClientError && error.status < 500 && error.status !== 429)
+                        await persistBatch(undefined);
+                    throw error;
+                }
+            },
+        });
+        pi.registerTool({
+            name: "update_question",
+            label: "更新待回应问题",
+            description: "仅记录当前执行必须由人决定的业务问题，不把一般建议变为审批；真正解决后传空字符串清除。普通聊天继续使用 steer，不停止 Run。",
+            parameters: Type.Object({ question: Type.String() }),
+            async execute(_id, params) {
+                // The caller binding supplies technical identity; the model only owns the question text.
+                observed.pendingQuestion = params.question.trim();
+                await emitQuestion(params.question);
+                return toolResult(params.question);
+            },
+        });
+        if (input.executionPurpose === "RELEASE")
+            pi.registerTool({
+                name: "request_code_changes",
+                label: "返回开发修改",
+                description: "用户明确要求修改应用代码时，将工单返回开发，再测试和人工确认；仅讨论或文档修改不要调用。",
+                parameters: Type.Object({
+                    reason: Type.String({ description: "用户要求修改的内容及原因" }),
+                }),
+                async execute(_id, params) {
+                    await client.request(`/api/v1/coding-runs/${runId}/return-to-development`, {
+                        method: "POST",
+                        body: JSON.stringify({
+                            hostId: host.hostId,
+                            generation: host.generation,
+                            turnId,
+                            reason: params.reason,
+                        }),
+                    });
+                    observed.terminalReached = true;
+                    return toolResult("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
+                },
+            });
+        pi.registerTool({
+            name: "report_blocker",
+            label: "报告阻塞",
+            description: "仅在认证、权限、仓库、外部环境或输入冲突真实阻塞时报告。",
+            parameters: Type.Object({
+                category: Type.Union([
+                    Type.Literal("AUTHENTICATION"),
+                    Type.Literal("PERMISSION"),
+                    Type.Literal("REPOSITORY"),
+                    Type.Literal("EXTERNAL_ENVIRONMENT"),
+                    Type.Literal("INPUT_CONFLICT"),
+                ]),
+                summary: Type.String(),
+            }),
+            async execute(_id, params) {
+                await client.reportCodingTerminal(runId, {
+                    hostId: host.hostId,
+                    generation: host.generation,
+                    turnId,
+                    kind: "BLOCKED",
+                    summary: redact(params.summary),
+                    knownIssues: "",
+                    blockerCategory: params.category,
+                    projectFacts: [],
+                    testFacts: [],
+                });
+                observed.terminalReached = true;
+                return toolResult("阻塞已报告。");
+            },
+        });
+    };
+}
+function subscribeSession(session, emit, observed, redact) {
+    let messageId = crypto.randomUUID();
+    let pendingText = "";
+    let textFlushTimer;
+    const pendingToolUpdates = new Map();
+    const toolUpdateTimers = new Map();
+    const flushText = () => {
+        if (textFlushTimer)
+            clearTimeout(textFlushTimer);
+        textFlushTimer = undefined;
+        if (!pendingText)
+            return;
+        const text = pendingText;
+        pendingText = "";
+        void emit("TEXT_DELTA", { text, messageId });
+    };
+    const flushToolUpdate = (activityKey) => {
+        const timer = toolUpdateTimers.get(activityKey);
+        if (timer)
+            clearTimeout(timer);
+        toolUpdateTimers.delete(activityKey);
+        const update = pendingToolUpdates.get(activityKey);
+        pendingToolUpdates.delete(activityKey);
+        if (update)
+            void emit(update.kind, update.payload);
+    };
+    session.subscribe((event) => {
+        if (event.type === "message_start" && event.message.role === "assistant") {
+            messageId = crypto.randomUUID();
+            void emit("MESSAGE_STARTED", { messageId });
+        }
+        else if (event.type === "message_update" &&
+            event.assistantMessageEvent.type === "text_delta" &&
+            event.assistantMessageEvent.delta) {
+            pendingText += redact(event.assistantMessageEvent.delta);
+            if (pendingText.length >= 4_000)
+                flushText();
+            else
+                textFlushTimer ??= setTimeout(flushText, 200);
+        }
+        else if (event.type === "tool_execution_start") {
+            flushText();
+            const subagent = event.toolName === "subagent";
+            if (subagent)
+                observed.activeTasks.set(event.toolCallId, String(event.args?.agent));
+            void emit(subagent ? "SUBAGENT_STARTED" : "TOOL_STARTED", subagent
+                ? {
+                    activityKey: event.toolCallId,
+                    agentId: String(event.args?.agent ?? "platform-reviewer"),
+                    summary: String(event.args?.task ?? "团队子任务开始"),
+                    task: String(event.args?.task ?? ""),
+                }
+                : {
+                    activityKey: event.toolCallId,
+                    toolName: event.toolName,
+                    summary: `执行 ${event.toolName}`,
+                });
+        }
+        else if (event.type === "tool_execution_update") {
+            pendingToolUpdates.set(event.toolCallId, event.toolName === "subagent"
+                ? {
+                    kind: "SUBAGENT_UPDATED",
+                    payload: {
+                        activityKey: event.toolCallId,
+                        agentId: String(event.args?.agent ?? "platform-reviewer"),
+                        currentAction: redact(textFromResult(event.partialResult)),
+                    },
+                }
+                : {
+                    kind: "TOOL_UPDATED",
+                    payload: {
+                        activityKey: event.toolCallId,
+                        toolName: event.toolName,
+                        currentAction: redact(textFromResult(event.partialResult)),
+                    },
+                });
+            if (!toolUpdateTimers.has(event.toolCallId))
+                toolUpdateTimers.set(event.toolCallId, setTimeout(() => flushToolUpdate(event.toolCallId), 200));
+        }
+        else if (event.type === "tool_execution_end") {
+            flushToolUpdate(event.toolCallId);
+            if (event.toolName === "subagent")
+                observed.activeTasks.delete(event.toolCallId);
+            void emit(event.toolName === "subagent"
+                ? observed.stopping
+                    ? "SUBAGENT_STOPPED"
+                    : event.isError
+                        ? "SUBAGENT_FAILED"
+                        : "SUBAGENT_COMPLETED"
+                : "TOOL_COMPLETED", event.toolName === "subagent"
+                ? {
+                    activityKey: event.toolCallId,
+                    agentId: String(event.result?.details?.agent ??
+                        "platform-reviewer"),
+                    summary: redact(textFromResult(event.result)),
+                }
+                : {
+                    activityKey: event.toolCallId,
+                    toolName: event.toolName,
+                    isError: event.isError === true,
+                    summary: redact(textFromResult(event.result)),
+                });
+        }
+        else if (event.type === "message_end" && event.message.role === "assistant") {
+            flushText();
+            const content = textFromMessage(event.message.content);
+            if (content)
+                void emit("MESSAGE_COMPLETED", { contentMarkdown: redact(content), messageId });
+        }
+    });
+}
+export async function prepareProjects(cacheRoot, runRoot, runId, projects, resume) {
+    await mkdir(cacheRoot, { recursive: true, mode: 0o700 });
+    for (const project of projects) {
+        const mirror = join(cacheRoot, `${project.id}.git`);
+        if (!(await exists(mirror))) {
+            await execFileAsync("git", ["clone", "--bare", project.repositoryUrl, mirror]).catch(() => {
+                throw new Error("CODING_REPOSITORY_ACCESS_FAILED");
+            });
+        }
+        else {
+            const [{ stdout: bare }, { stdout: origin }] = await Promise.all([
+                execFileAsync("git", ["--git-dir", mirror, "rev-parse", "--is-bare-repository"]),
+                execFileAsync("git", ["--git-dir", mirror, "config", "--get", "remote.origin.url"]),
+            ]);
+            if (bare.trim() !== "true")
+                throw new Error("CODING_REPOSITORY_CACHE_NOT_BARE");
+            if ((await canonicalRepository(origin.trim())) !==
+                (await canonicalRepository(project.repositoryUrl)))
+                throw new Error("CODING_REPOSITORY_ORIGIN_MISMATCH");
+        }
+        if (!resume) {
+            // Shared worktrees own refs/heads/aip/*; fetching must only update remote-tracking refs.
+            await execFileAsync("git", [
+                "--git-dir",
+                mirror,
+                "config",
+                "--replace-all",
+                "remote.origin.fetch",
+                "+refs/heads/*:refs/remotes/origin/*",
+            ]);
+            await execFileAsync("git", ["--git-dir", mirror, "fetch", "origin"]).catch(() => {
+                throw new Error("CODING_REPOSITORY_ACCESS_FAILED");
+            });
+            await execFileAsync("git", [
+                "--git-dir",
+                mirror,
+                "cat-file",
+                "-e",
+                `refs/remotes/origin/${project.baselineBranch}`,
+            ]).catch(() => {
+                throw new Error("CODING_BASELINE_BRANCH_UNAVAILABLE");
+            });
+        }
+        const target = join(runRoot, safeName(project.name));
+        const expectedBranch = project.devBranch || `aip/${runId}/${project.id.slice(0, 8)}`;
+        const existingWorktree = await exists(target);
+        if (!existingWorktree) {
+            if (resume)
+                throw new Error("CODING_RUN_WORKTREE_MISSING");
+            await execFileAsync("git", [
+                "--git-dir",
+                mirror,
+                "worktree",
+                "add",
+                "-b",
+                expectedBranch,
+                target,
+                `refs/remotes/origin/${project.baselineBranch}`,
+            ]).catch(() => {
+                throw new Error("CODING_WORKTREE_CREATE_FAILED");
+            });
+        }
+        await validateWorktree(mirror, target, expectedBranch, resume || existingWorktree);
+    }
+    const onlyProject = projects.length === 1 ? projects[0] : null;
+    return onlyProject ? join(runRoot, safeName(onlyProject.name)) : runRoot;
+}
+async function validateWorktree(mirror, target, expectedBranch, resume) {
+    const facts = await Promise.all([
+        execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: target }),
+        execFileAsync("git", ["rev-parse", "--git-common-dir"], { cwd: target }),
+        execFileAsync("git", ["branch", "--show-current"], { cwd: target }),
+    ]).catch(() => {
+        throw new Error("CODING_WORKTREE_OWNERSHIP_INVALID");
+    });
+    const [{ stdout: inside }, { stdout: common }, { stdout: branch }] = facts;
+    if (inside.trim() !== "true")
+        throw new Error("CODING_WORKTREE_OWNERSHIP_INVALID");
+    const commonPath = common.trim();
+    const [actualCommon, expectedCommon] = await Promise.all([
+        realpath(commonPath.startsWith("/") ? commonPath : resolve(target, commonPath)),
+        realpath(mirror),
+    ]);
+    if (actualCommon !== expectedCommon)
+        throw new Error("CODING_WORKTREE_OWNERSHIP_INVALID");
+    if (branch.trim() !== expectedBranch)
+        throw new Error("CODING_WORKTREE_BRANCH_MISMATCH");
+    if (resume)
+        return;
+    const { stdout: status } = await execFileAsync("git", ["status", "--porcelain"], {
+        cwd: target,
+    });
+    if (status.trim())
+        throw new Error("CODING_WORKTREE_NOT_CLEAN");
+}
+async function canonicalRepository(value) {
+    if (value.startsWith("/"))
+        return realpath(value).catch(() => resolve(value));
+    if (value.startsWith("file://")) {
+        const path = new URL(value);
+        return realpath(path).catch(() => resolve(path.pathname));
+    }
+    return value.replace(/\/$/u, "");
+}
+export function initialPrompt(input, runRoot) {
+    const directory = deliveryDirectory(runRoot, input);
+    if (input.executionPurpose === "RELEASE")
+        return `当前是人工验收通过后的上线准备，恢复原开发会话。工单 ${input.workItem.key}：${input.workItem.title}。项目分支：${input.projects.map((p) => `${p.name} ${p.devBranch} → ${p.baselineBranch}`).join("；")}。共享工作区已由测试会话处理，不能依赖旧会话记忆：先读取最新代码、${directory}/report.md、release_checklist.md、summary.md 和适用的 design.md。以项目源分支和目标分支为依据，不按 commit ID 或 tree hash 校验验收一致性。核实上线清单，明确无需修改或修改摘要；清单覆盖项目与分支、SQL、Apollo、定时任务、Kafka/RabbitMQ资源、监控告警、发布顺序、验证和回滚。以设计为预期、代码核实；没有设计则从代码提取。无法证明的环境事实标明待核实，不涉及说明原因；测试环境部署记录不能代替上线清单。用户明确要求修改应用代码时调用 request_code_changes，返回开发→测试→人工确认，不能在此阶段擅自修改后放行。清单有缺口时使用 update_question 说明，不能宣称核实完成。核实完成后提交清单文档改动，再调用 submit_pull_requests，传入核实摘要和各项目 MR 标题说明；工具使用 Runtime 的 glab 身份推送、创建或复用 MR 并结构化登记工单。说明覆盖任务目的、本项目改动、测试验收、发布注意、跨项目依赖、风险回滚及材料入口。MR仍打开时复用；关闭后仅在用户明确重提时创建新MR。平台查询状态，不负责创建。仅说明或更新文档不退回研发；不执行实际发布、知识整理、关单。`;
+    const projects = input.projects
+        .map((p) => `- ${p.name}: ${join(runRoot, safeName(p.name))}（开发分支 ${p.devBranch} → 基准分支 ${p.baselineBranch}；测试分支 ${p.testBranch}）${p.id === input.primaryProjectId ? "（主项目）" : ""}`)
+        .join("\n");
+    return `${input.phase === "DEVELOPMENT" ? "当前是开发阶段：按员工与阶段配置完成工作，填写需求汇总 summary.md、plan.md、code_review.md、release_checklist.md 后调用 complete_development。由主管安排适合的成员协作。" : "当前是系统测试阶段：读取开发交接文件，随测试修复维护开发产出的 release_checklist.md，按需要安排成员协作。开始研发已授权将工单代码合并并 push 到项目已确认的 testBranch，触发测试环境自动部署；必须实际 push，只有本地合并不会触发部署。当前仓库使用共享 bare mirror，推送使用 git -c remote.origin.mirror=false push origin <已确认测试分支>，不要修改全局或共享缓存的 mirror 配置；操作后回到本工单分支。这是测试部署，不是生产上线；不得推送生产分支或执行生产发布。使用环境 Skill 观察部署目标和实际版本，将实际观察和验证结论写入测试报告；失败时修复、提交合并、等待部署、重测。人工打回复用当前环境。不默认重新审核，报告区分审核版本和后续修复。"} 需要业务判断时正常提问，使用 update_question 维护待回应问题；不要调用 report_blocker 表示普通提问。${input.inputConflict ? `正式输入已变化：先读取 ${directory}/prd.platform.md 和适用的 design.platform.md，对照合并到 prd.md/design.md；本地副本未被覆盖，对照文件不收集。` : ""}请完成工单 ${input.workItem.key}：${input.workItem.title}。项目：\n${projects}\n先用 read 读取 ${directory}/prd.md${input.technicalDesign ? ` 和 ${directory}/design.md` : ""}。\n在 ${directory} 完成 ${input.phase === "DEVELOPMENT" ? "summary.md、plan.md、code_review.md、release_checklist.md" : "summary.md、plan.md、report.md、code_review.md、release_checklist.md；test_plan.md 可选"}。summary.md 是本工单的问题、目标和范围汇总，不是实现摘要。release_checklist.md 是实际上线操作清单，覆盖项目与源/目标分支、SQL、Apollo、定时任务、Kafka/RabbitMQ资源、监控告警、发布顺序、验证及回滚；有设计以设计为预期并核对代码，没有设计从代码提取；未知环境事实标明待核实，不涉及写原因，不能用测试部署记录代替。全流程不以 commit ID 或 tree hash 判断是否需要补验。允许修改 PRD/Design，本轮将回收最终内容。报告包含各项目实际验证结果、版本、证据、未验证和遗留。只有上述固定槽位会被回收。\n${input.team ? "只向实际可用成员分派任务，无子成员时由主管自行完成并汇总。" : "自行完成当前阶段工作。"}团队自主选择开发、审核和测试方法，如实记录完成情况、未验证项及遗留问题，不编造结果。平台只检查必需产物，不要求指定成员、PASS组合或测试命令。由主管调用当前阶段的无参数完成工具，Runtime读取文件并上传。缺文件按工具错误补齐后再次提交。`;
+}
+async function uploadBatch(client, runId, batch) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            await client.reportCodingTerminal(runId, batch);
+            return;
+        }
+        catch (error) {
+            if (error instanceof PlatformClientError && error.status < 500 && error.status !== 429)
+                throw error;
+            if (attempt >= 2)
+                throw new Error(`AIP_DELIVERY_UPLOAD_FAILED：同批材料尚未提交成功，可恢复重试；${error instanceof Error ? error.message : "网络错误"}`);
+            await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
+        }
+    }
+}
+function textFromMessage(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => Boolean(part &&
+        typeof part === "object" &&
+        part.type === "text" &&
+        typeof part.text === "string"))
+        .map((part) => part.text)
+        .join("\n");
+}
+function textFromResult(value) {
+    if (!value || typeof value !== "object")
+        return "";
+    return textFromMessage(value.content).slice(0, 4000);
+}
+function toolResult(text) {
+    return { content: [{ type: "text", text }], details: {} };
+}
+function safeName(value) {
+    return basename(value).replace(/[^a-zA-Z0-9._-]/gu, "-") || "project";
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function collectProjectFacts(runRoot, projects, key, primaryProjectId) {
+    return Promise.all(projects.map(async (project) => {
+        const cwd = join(runRoot, safeName(project.name));
+        const excludeKey = project.id === primaryProjectId ? key : undefined;
+        const [{ stdout: head }, tree, { stdout: branch }] = await Promise.all([
+            execFileAsync("git", ["rev-parse", "HEAD"], { cwd }),
+            worktreeTreeHash(cwd, excludeKey),
+            execFileAsync("git", ["branch", "--show-current"], { cwd }),
+        ]);
+        const commitSha = head.trim();
+        return {
+            projectId: project.id,
+            projectName: project.name,
+            commitSha,
+            treeHash: tree,
+            branch: branch.trim(),
+        };
+    }));
+}
+async function captureProjectRevisions(runRoot, projects, key, primaryProjectId) {
+    return collectProjectFacts(runRoot, projects, key, primaryProjectId);
+}
+export async function worktreeTreeHash(cwd, key, committed = false, ref = "HEAD") {
+    const temporary = await mkdtemp(join(tmpdir(), "aip-tested-tree-"));
+    const index = join(temporary, "index");
+    const options = { cwd, env: { ...process.env, GIT_INDEX_FILE: index } };
+    try {
+        await execFileAsync("git", ["read-tree", ref], options);
+        if (!committed)
+            await execFileAsync("git", ["add", "-A"], options);
+        if (key) {
+            const names = [
+                "summary.md",
+                "prd.md",
+                "design.md",
+                "plan.md",
+                "test_plan.md",
+                "report.md",
+                "code_review.md",
+                "release_checklist.md",
+                "prd.platform.md",
+                "design.platform.md",
+            ];
+            await execFileAsync("git", [
+                "rm",
+                "--cached",
+                "--force", // This removes entries only from the dedicated temporary index.
+                "--ignore-unmatch",
+                "--",
+                ...names.map((name) => `docs/aip/${key}/${name}`),
+            ], options);
+        }
+        return (await execFileAsync("git", ["write-tree"], options)).stdout.trim();
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+export function redactHostText(value, roots = []) {
+    let redacted = value;
+    for (const root of [...roots].filter(Boolean).sort((a, b) => b.length - a.length))
+        redacted = redacted.split(root).join("[本地路径]");
+    redacted = redacted
+        .replace(/data:image\/[^;,\s]+;base64,[A-Za-z0-9+/=]+/giu, "[图片内容已脱敏]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/giu, "Bearer [已脱敏]")
+        .replace(/\b(?:sk-[A-Za-z0-9_-]{12,}|ghp_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,}|xox[baprs]-[A-Za-z0-9-]{12,})\b/gu, "[凭证已脱敏]")
+        .replace(/\b([A-Z0-9_]*(?:TOKEN|PASSWORD|SECRET|API_KEY|AUTH)[A-Z0-9_]*)=([^\s]+)/giu, "$1=[已脱敏]")
+        .replace(/(["']?(?:access_token|refresh_token|id_token|api_key|password|secret|token)["']?\s*:\s*["']?)[^"'\s,}]+/giu, "$1[已脱敏]")
+        .replace(/-----BEGIN [^-]+ PRIVATE KEY-----[\s\S]*?-----END [^-]+ PRIVATE KEY-----/gu, "[私钥已脱敏]")
+        .replace(/(?:\/(?:Users|home|private\/var|var\/folders|tmp)\/[^\s'"`<>]*)/gu, "[本地路径]")
+        .replace(/\b[A-Za-z]:\\(?:[^\s'"`<>]+\\?)+/gu, "[本地路径]");
+    return redacted.slice(0, 100_000);
+}
+//# sourceMappingURL=coding-run-manager.js.map