@bf-meishijian/aip 0.0.5 → 0.0.6

package/dist/coding-run-manager.js

@@ -6,11 +6,14 @@ import { basename, dirname, 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 { createCodingSubagents } from "./coding-subagents.js";
+import { collectDeliveryFiles, deliveryDirectory, initializeDeliveryFiles, publishReviewMaterials, } from "./delivery-files.js";
 import { liveEmployee } from "./live-employee.js";
 import { prepareMergeRequest, registerMergeRequest, } from "./merge-requests.js";
 import { paths } from "./paths.js";
+import { PiMessageQueue } from "./pi-message-queue.js";
 import { PlatformClientError } from "./platform-client.js";
+import { materializeReviewReport } from "./review-report.js";
 import { readJson, writeSecureJson } from "./secure-json.js";
 import { DELIVERY_FILES, STAGE_DELIVERY_PROTOCOLS, stageEmployeeIds } from "./stage-delivery.js";
 const execFileAsync = promisify(execFile);
@@ -27,6 +30,25 @@ export class CodingRunManager {
     async execute(client, host, command) {
         if (!command.run)
             throw new Error("CODING_RUN_COMMAND_INVALID");
+        if (command.run.action === "REVIEW_REPORT") {
+            const report = command.run.reviewReport;
+            if (!report || !command.run.runInput)
+                throw new Error("REVIEW_REPORT_INPUT_MISSING");
+            const files = await materializeReviewReport(join(paths().runWorktrees, command.run.runId), command.run.runInput, report.files);
+            await client.acknowledgeReviewReport(command.run.runId, {
+                hostId: host.hostId,
+                generation: host.generation,
+                turnId: command.run.turnId,
+                roundId: report.roundId,
+                files,
+            });
+            return;
+        }
+        if (command.run.action === "RECALL_QUEUE") {
+            return {
+                recalledMessageIds: this.active.get(command.run.runId)?.observed.messageQueue?.recall() ?? [],
+            };
+        }
         const imageRun = command.run;
         let images;
         try {
@@ -41,6 +63,7 @@ export class CodingRunManager {
             if (active?.turnId === imageRun.turnId) {
                 active.stopping = true;
                 active.observed.stopping = true;
+                await active.subagents?.stop();
                 await active.session.abort();
                 await active.finished;
                 if (this.active.get(imageRun.runId) === active)
@@ -52,7 +75,18 @@ export class CodingRunManager {
             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") {
+        else if (command.run.action === "CONTINUE") {
+            const active = this.active.get(command.run.runId);
+            if (active) {
+                await active.finished;
+                if (active.stopping || active.observed.userIntervened)
+                    return;
+            }
+            if (!command.run.runInput || !command.run.contentMarkdown || !command.run.continuation)
+                throw new Error("CODING_RUN_CONTINUATION_MISSING");
+            await this.start(client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, [], command.run.continuation);
+        }
+        else if (command.run.action === "STEER" || command.run.action === "FOLLOW_UP") {
             let active = this.active.get(command.run.runId);
             if (!command.run.contentMarkdown && images.length === 0)
                 throw new Error("CODING_RUN_MESSAGE_MISSING");
@@ -61,6 +95,13 @@ export class CodingRunManager {
                     throw new Error("CODING_RUN_TURN_MISMATCH");
                 active.stopping = true;
                 active.observed.stopping = true;
+                await active.emit("EXECUTION_DECIDED", {
+                    phase: active.input.phase,
+                    decision: "SKIP",
+                    reason: "SUPERSEDED",
+                    stopReason: "SUPERSEDED",
+                });
+                await active.subagents?.stop();
                 await active.session.abort();
                 if (this.active.get(command.run.runId) === active)
                     this.active.delete(command.run.runId);
@@ -69,17 +110,48 @@ export class CodingRunManager {
             if (active) {
                 if (images.length > 0 && !active.supportsImages)
                     throw new Error("MODEL_IMAGES_UNSUPPORTED");
-                active.observed.pendingSteerText = command.run.contentMarkdown ?? "";
-                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 ?? "");
+                active.observed.userIntervened = true;
+                const handoff = active.observed.awaitingDecision || active.session.isIdle;
+                if (handoff)
+                    active.observed.handingOffInput = true;
+                await active.emit("AUTO_CONTINUATION_CHANGED", {
+                    phase: active.input.phase,
+                    autoContinueEnabled: false,
+                    reason: "USER_MESSAGE",
+                    source: "HOST_HANDLED",
+                });
+                if (handoff || active.session.isIdle || active.observed.awaitingDecision) {
+                    active.observed.handingOffInput = true;
+                    // Pi is idle: steer only queues input and cannot start a new model turn.
+                    // Finish the old judge operation before opening the user turn.
+                    await active.finished;
+                    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);
+                    if (command.run.messageId)
+                        await this.active.get(command.run.runId)?.emit("MESSAGE_QUEUE_UPDATED", {
+                            messageId: command.run.messageId,
+                            deliveryStatus: "READ",
+                        });
+                    return;
+                }
+                if (!command.run.messageId)
+                    throw new Error("CODING_RUN_MESSAGE_ID_MISSING");
+                await active.observed.messageQueue.submit(command.run.messageId, command.run.action, command.run.contentMarkdown ?? "", images.length ? images : undefined);
+                await active.emit("MESSAGE_QUEUE_UPDATED", {
+                    messageId: command.run.messageId,
+                    deliveryStatus: "QUEUED",
+                });
             }
             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);
+                if (command.run.messageId)
+                    await this.active.get(command.run.runId)?.emit("MESSAGE_QUEUE_UPDATED", {
+                        messageId: command.run.messageId,
+                        deliveryStatus: "READ",
+                    });
             }
         }
         else if (command.run.action === "STOP") {
@@ -89,34 +161,55 @@ export class CodingRunManager {
                     throw new Error("CODING_RUN_TURN_MISMATCH");
                 active.stopping = true;
                 active.observed.stopping = true;
+                await active.subagents?.stop();
                 await active.session.abort();
+                await active.emit("AUTO_CONTINUATION_CHANGED", {
+                    phase: active.input.phase,
+                    autoContinueEnabled: false,
+                    reason: "USER_STOP",
+                    source: "HOST_HANDLED",
+                });
                 await active.emit.flush();
-                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", {});
+                await active.emit("EXECUTION_DECIDED", {
+                    phase: active.input.phase,
+                    decision: "SKIP",
+                    reason: "STOP_REQUESTED",
+                    stopReason: "USER_STOPPED",
+                });
+                await active.emit("RUN_STOPPED", { phase: active.input.phase, reason: "USER_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", {});
+                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", {
+                    phase: state?.phase,
+                    reason: "USER_STOPPED",
+                    reminderDecision: "NO_REMINDER",
+                });
             }
         }
         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);
         }
+        if (command.run.messageId &&
+            ["START", "RESUME", "STEER", "FOLLOW_UP"].includes(command.run.action)) {
+            const active = this.active.get(command.run.runId);
+            if (active &&
+                (command.run.action === "RESUME" ||
+                    command.run.action === "START" ||
+                    !active.observed.messageQueue))
+                await active.emit("MESSAGE_QUEUE_UPDATED", {
+                    messageId: command.run.messageId,
+                    deliveryStatus: "READ",
+                });
+        }
     }
-    async start(client, host, runId, turnId, input, resume, resumePrompt, images = []) {
+    async start(client, host, runId, turnId, input, resume, resumePrompt, images = [], continuation) {
         const active = this.active.get(runId);
         if (active) {
             if (active.turnId === turnId)
                 return;
-            if (!active.observed.terminalReached)
+            if (!active.observed.terminalReached && !active.stopping)
                 throw new Error("CODING_RUN_TURN_MISMATCH");
             await active.finished;
             if (this.active.get(runId) === active)
@@ -135,9 +228,19 @@ export class CodingRunManager {
             Object.keys(storedState.phaseSessions).length &&
             storedState.harness !== "pi")
             throw new Error("PRIOR_HARNESS_SESSION_UNSUPPORTED：请新建执行，历史文件和工作目录已保留。");
-        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)}`;
+            project.devBranch ||=
+                storedState?.mrContext?.projects.find((p) => p.id === project.id)?.devBranch ||
+                    `aip/${input.workItem.key}`;
+        const cwd = await prepareProjects(local.repositoryCache, runRoot, input.workItem.key, input.projects, Boolean(storedState?.prepared));
+        const preparationBaselines = storedState?.preparationBaselines ?? {};
+        if (input.phase === "PREPARATION" && !storedState?.prepared) {
+            for (const project of input.projects)
+                preparationBaselines[project.id] ??= (await execFileAsync("git", ["rev-parse", "HEAD"], {
+                    cwd: join(runRoot, safeName(project.name)),
+                })).stdout.trim();
+            await writeSecureJson(stateFile, { ...storedState, preparationBaselines });
+        }
         if (!storedState?.prepared || input.inputConflict)
             await initializeDeliveryFiles(runRoot, input, Boolean(storedState?.prepared));
         const deliveryInputHash = createHash("sha256")
@@ -147,7 +250,7 @@ export class CodingRunManager {
             input.technicalDesign?.content,
         ]))
             .digest("hex");
-        const childSessions = storedState?.childSessions ?? {};
+        const delegations = storedState?.delegations ?? {};
         let pendingDelivery = storedState?.phase !== input.phase ||
             resumePrompt ||
             images.length > 0 ||
@@ -166,8 +269,7 @@ export class CodingRunManager {
         let sessionRef = phaseSessions[sessionPhase];
         let lastEventSequence = storedState?.lastEventSequence ?? 0;
         const observed = {
-            pendingQuestion: storedState?.phase === input.phase ? (storedState.pendingQuestion ?? "") : "",
-            memberResults: new Map(),
+            userIntervened: input.autoContinueEnabled === false,
             activeTasks: new Map(),
             stopping: false,
             terminalReached: false,
@@ -182,12 +284,12 @@ export class CodingRunManager {
                 primaryProjectId: input.primaryProjectId,
             },
             prepared: true,
+            preparationBaselines,
             phaseSessions,
             sessionRef,
             harness: "pi",
             lastEventSequence,
-            pendingQuestion: observed.pendingQuestion,
-            childSessions,
+            delegations,
             pendingDelivery,
             deliveryInputHash,
         });
@@ -197,15 +299,15 @@ export class CodingRunManager {
             return persistState();
         }, redact);
         if (input.phase === "PREPARATION") {
+            if (!storedState?.prepared)
+                await publishReviewMaterials(runRoot, input);
             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(),
+                    baselineCommit: preparationBaselines[p.id] ?? p.baselineCommit,
                     directory: join(runRoot, safeName(p.name)),
                     branch: (await execFileAsync("git", ["branch", "--show-current"], {
                         cwd: join(runRoot, safeName(p.name)),
@@ -214,10 +316,10 @@ export class CodingRunManager {
             });
             return;
         }
-        const terminal = terminalTools(client, host, runId, turnId, runRoot, input, observed, redact, async (batch) => {
+        const terminal = terminalTools(client, host, runId, turnId, runRoot, input, observed, async (batch) => {
             pendingDelivery = batch;
             await persistState();
-        }, () => pendingDelivery, (question) => emit("QUESTION_UPDATED", { question: redact(question) }), () => emit.flush());
+        }, () => pendingDelivery, () => emit.flush());
         if (!this.pi.resolveRuntimeModel)
             throw new Error("MODEL_RUNTIME_UNAVAILABLE");
         const resolved = await this.pi.resolveRuntimeModel(input.providerId, input.modelId, {
@@ -235,119 +337,41 @@ export class CodingRunManager {
             member: "supervisor",
         };
         const availableAgents = stageEmployeeIds(input);
-        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 memberExtension = (api) => {
-            if (!availableAgents.length)
-                return;
-            api.registerTool({
-                name: "subagent",
-                label: "派发研发团队",
-                description: `向实际绑定员工分派子任务，返回真实子会话结果。可用员工：${availableAgents
-                    .map((id) => `${id}：${input.teamEmployees?.[id]?.name ?? id}；${input.teamEmployees?.[id]?.description ?? ""}`)
-                    .join("\n")}。`,
-                parameters: Type.Object({
-                    agent: availableAgents.length === 1
-                        ? Type.Literal(availableAgents[0])
-                        : Type.Union(availableAgents.map((name) => Type.Literal(name))),
-                    task: Type.String({ minLength: 1 }),
-                }),
-                async execute(callId, params, signal, onUpdate) {
-                    const member = String(params.agent);
-                    if (!availableAgents.includes(member))
-                        throw new Error("DEVELOPMENT_TEAM_MEMBER_INVALID");
-                    if (observed.stopping || signal?.aborted)
-                        throw new Error("SUBAGENT_STOPPED");
-                    observed.activeTasks.set(callId, member);
-                    childTasks.set(member, callId);
-                    observed.memberResults.delete(member);
-                    childUpdates.set(member, (text) => onUpdate?.({ content: [{ type: "text", text }], details: { agent: member } }));
-                    const key = `${input.phase}:${member}`;
-                    let child = childInstances.get(member);
-                    if (!child) {
-                        const childBinding = { ...binding, member };
-                        const childLive = liveEmployee(client, runId, childBinding, await client.employeeConfig(runId, { ...childBinding, purpose: "LOAD" }), runRoot, true, false, input.phase, () => observed.memberResults.has(member));
-                        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);
-                                    observed.memberResults.set(member, { ...result, revisions });
-                                    queueMicrotask(() => child?.agent.abort());
-                                    return toolResult("结果已记录，向主管返回结论。");
-                                },
-                            });
-                        };
-                        const opened = await openPiSession({
-                            cwd,
-                            sessionDir: local.piSessions,
-                            agentDir: local.piAgent,
-                            existingId: childSessions[key],
-                            modelRuntime: resolved.runtime,
-                            model: resolved.model,
-                            thinkingLevel: input.thinkingLevel,
-                            extensions: [childLive.extension, resultExtension],
-                            systemPrompt: "当前为团队子成员会话，员工配置由平台下发。",
-                            runId,
-                        });
-                        childLive.attach(opened.session);
-                        child = opened.session;
-                        childSessions[key] = opened.sessionId;
-                        childInstances.set(member, child);
-                        subscribeSession(child, (kind, payload) => {
-                            if (kind === "TEXT_DELTA")
-                                childUpdates.get(member)?.(String(payload.text ?? ""));
-                            return emit(kind, {
-                                ...payload,
-                                phase: input.phase,
-                                agentId: member,
-                                parentActivityKey: childTasks.get(member),
-                                sessionId: opened.sessionId,
-                            });
-                        }, observed, redact);
-                        await persistState();
-                    }
-                    await emit("SUBAGENT_UPDATED", {
-                        phase: input.phase,
-                        task: params.task,
-                        activityKey: callId,
-                        agentId: member,
-                        sessionRef: childSessions[key],
-                        summary: "独立子会话已就绪",
-                    });
-                    const abort = () => {
-                        child?.agent.abort();
-                    };
-                    signal?.addEventListener("abort", abort, { once: true });
-                    try {
-                        signal?.throwIfAborted();
-                        await child.prompt(`${initialPrompt(input, runRoot, false)}\n\n本次主管分派给 ${member} 的任务：${params.task}\n只完成自身职责，最后调用 submit_member_result；主管负责其他成员协调和最终交付。`);
-                        await child.waitForIdle();
-                        if (signal?.aborted || observed.stopping)
-                            throw new Error("SUBAGENT_STOPPED");
-                        const result = observed.memberResults.get(member);
-                        if (!result)
-                            throw new Error("SUBAGENT_RESULT_MISSING");
-                        return {
-                            content: [{ type: "text", text: JSON.stringify(result) }],
-                            details: { agent: member, status: result.status },
-                        };
-                    }
-                    finally {
-                        childUpdates.delete(member);
-                        signal?.removeEventListener("abort", abort);
-                    }
+        const live = liveEmployee(client, runId, binding, await client.employeeConfig(runId, { ...binding, purpose: "LOAD" }), runRoot, Boolean(input.team), input.executionPurpose === "RELEASE", input.phase, () => observed.terminalReached, executionInstructions, () => {
+            observed.terminalClosed = true;
+        });
+        const delegation = input.executionPurpose === "RELEASE"
+            ? undefined
+            : await createCodingSubagents({
+                client,
+                config: {
+                    runId,
+                    turnId,
+                    hostId: host.hostId,
+                    generation: host.generation,
+                    runRoot,
+                    providerId: input.providerId,
+                    modelId: input.modelId,
+                    phase: input.phase,
+                },
+                cwd,
+                directory: join(local.runState, runId, "subagents", input.phase),
+                team: Boolean(input.team),
+                agents: availableAgents.map((id) => ({
+                    id,
+                    name: input.teamEmployees?.[id]?.name ?? id,
+                    description: input.teamEmployees?.[id]?.description ?? "",
+                })),
+                records: delegations,
+                emit,
+                persist: persistState,
+                started(activityKey, agentId) {
+                    observed.activeTasks.set(activityKey, agentId);
+                },
+                async completed(activityKey) {
+                    observed.activeTasks.delete(activityKey);
                 },
             });
-        };
         const opened = await openPiSession({
             cwd,
             sessionDir: local.piSessions,
@@ -356,7 +380,7 @@ export class CodingRunManager {
             modelRuntime: resolved.runtime,
             model: resolved.model,
             thinkingLevel: input.thinkingLevel,
-            extensions: [...(availableAgents.length ? [memberExtension] : []), terminal, live.extension],
+            extensions: [...(delegation ? [delegation.extension] : []), terminal, live.extension],
             systemPrompt: input.team
                 ? "当前为团队主负责人会话，员工配置由平台下发。"
                 : "当前为工单主会话，员工配置由平台下发。",
@@ -365,6 +389,7 @@ export class CodingRunManager {
         live.attach(opened.session);
         const session = opened.session;
         sessionRef = opened.sessionId;
+        observed.messageQueue = new PiMessageQueue(session);
         subscribeSession(session, (kind, payload) => {
             const activityKey = String(payload.activityKey ?? "");
             if (kind === "SUBAGENT_STARTED")
@@ -386,29 +411,62 @@ export class CodingRunManager {
             emit,
             stopping: false,
             observed,
+            ...(delegation ? { subagents: delegation } : {}),
         };
         this.active.set(runId, activeRun);
         phaseSessions[sessionPhase] = sessionRef;
         await persistState();
         await emit("RUN_STARTED", { sessionRef, phase: input.phase });
-        if (resumePrompt || images.length > 0) {
+        if (!continuation &&
+            (input.autoContinueEnabled === false || (!resume && input.autoContinueEnabled === true))) {
+            await emit("AUTO_CONTINUATION_CHANGED", {
+                phase: input.phase,
+                autoContinueEnabled: input.autoContinueEnabled === true,
+                reason: input.autoContinueEnabled === true ? "SYSTEM_STAGE" : "USER_MESSAGE",
+                source: "HOST_HANDLED",
+            });
+        }
+        if (!continuation && (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)
+        const conversationFingerprint = await workspaceFingerprint(runRoot, input);
+        const prompt = continuation
+            ? resumePrompt
+            : `${initialPrompt(input, runRoot)}\n\n${executionInstructions()}${resumePrompt ? `\n\n用户本次消息：${resumePrompt}` : resume && !resumePrompt ? "\n\n继续当前会话未完成的工作，先读取最新文件和交接结果。" : ""}`;
+        activeRun.finished = driveToTerminal(session, prompt, observed, client, host, runId, turnId, emit, input.phase, images, async () => {
+            await emit("CONVERSATION_COMPLETED", {
+                workspaceChanged: conversationFingerprint !== (await workspaceFingerprint(runRoot, input)),
+            });
+        }, continuation)
             .catch(async (error) => {
             if (activeRun.stopping)
                 return;
+            await emit("EXECUTION_DECIDED", {
+                phase: input.phase,
+                decision: "SKIP",
+                reason: "MODEL_ERROR",
+                stopReason: "error",
+            });
             await emit("RUN_FAILED", {
-                code: error instanceof Error ? error.message.slice(0, 200) : "PI_RUN_FAILED",
+                phase: input.phase,
+                code: error instanceof Error && /^[A-Z][A-Z0-9_]+$/u.test(error.message)
+                    ? error.message.slice(0, 200)
+                    : "PI_RUN_FAILED",
+                message: redact(error instanceof Error ? error.message : String(error)),
             });
         })
             .finally(async () => {
             await emit.flush();
-            for (const child of childInstances.values())
-                child.dispose();
-            session.dispose();
+            try {
+                await delegation?.stop();
+                await delegation?.flush();
+            }
+            finally {
+                await delegation?.dispose();
+                await session.extensionRunner?.emit({ type: "session_shutdown", reason: "quit" });
+                session.dispose();
+            }
             if (this.active.get(runId) === activeRun)
                 this.active.delete(runId);
         });
@@ -461,7 +519,9 @@ function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistS
     let sequence = initialSequence;
     let queue = Promise.resolve();
     const emit = (kind, payload) => {
-        queue = queue.then(async () => {
+        queue = queue
+            .catch(() => { })
+            .then(async () => {
             const event = {
                 eventId: crypto.randomUUID(),
                 sequence: sequence + 1,
@@ -484,11 +544,16 @@ function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistS
                 catch (error) {
                     if (error instanceof PlatformClientError &&
                         error.status === 409 &&
-                        error.code === "CODING_EVENT_TURN_STALE")
+                        error.code === "CODING_EVENT_TURN_STALE") {
+                        if (["EXECUTION_STARTED", "EXECUTION_PAUSED", "CONVERSATION_COMPLETED"].includes(kind))
+                            throw error;
                         return;
+                    }
                     process.stderr.write(`[local-coding-host] 事件上报失败：${redact(error instanceof Error ? error.message : String(error))}\n`);
                     if (attempt === EVENT_APPEND_MAX_ATTEMPTS) {
                         process.stderr.write(`[local-coding-host] 事件上报放弃：${event.kind} sequence=${event.sequence} attempts=${attempt}\n`);
+                        if (["EXECUTION_STARTED", "EXECUTION_PAUSED", "CONVERSATION_COMPLETED"].includes(kind))
+                            throw error;
                         return;
                     }
                     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -558,6 +623,7 @@ async function openPiSession(options) {
         resourceLoader: loader,
         sessionManager,
     });
+    await session.bindExtensions({ mode: "print" });
     session.setAutoCompactionEnabled(true);
     return { session, sessionId };
 }
@@ -588,17 +654,22 @@ function subscribeSession(session, emit, observed, redact) {
             void emit(update.kind, update.payload);
     };
     session.subscribe((event) => {
-        if (event.type === "message_start" && event.message.role === "assistant") {
+        if (event.type === "agent_start") {
+            if (observed.messageQueue)
+                void emit("MESSAGE_QUEUE_UPDATED", { mainAgentRunning: true });
+        }
+        else if (event.type === "agent_settled") {
+            if (observed.messageQueue)
+                void emit("MESSAGE_QUEUE_UPDATED", { mainAgentRunning: false });
+        }
+        else if (event.type === "message_start" && event.message.role === "assistant") {
             messageId = crypto.randomUUID();
             void emit("MESSAGE_STARTED", { messageId });
         }
         else if (event.type === "message_start" && event.message.role === "user") {
-            const text = textFromMessage(event.message.content);
-            if (observed.pendingSteerText !== undefined &&
-                (!observed.pendingSteerText || text.includes(observed.pendingSteerText))) {
-                delete observed.pendingSteerText;
-                void emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
-            }
+            const id = observed.messageQueue?.consumed(event.message);
+            if (id)
+                void emit("MESSAGE_QUEUE_UPDATED", { messageId: id, deliveryStatus: "READ" });
         }
         else if (event.type === "agent_end") {
             observed.nativeWillRetry = event.willRetry === true;
@@ -619,65 +690,38 @@ function subscribeSession(session, emit, observed, redact) {
         }
         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 ?? ""),
-                    summary: String(event.args?.task ?? "团队子任务开始"),
-                    task: String(event.args?.task ?? ""),
-                }
-                : {
-                    activityKey: event.toolCallId,
-                    toolName: event.toolName,
-                    summary: `执行 ${event.toolName}`,
-                });
+            if (event.toolName === "subagent")
+                return;
+            void emit("TOOL_STARTED", {
+                activityKey: event.toolCallId,
+                toolName: event.toolName,
+                summary: `执行 ${event.toolName}`,
+            });
         }
         else if (event.type === "tool_execution_update") {
+            if (event.toolName === "subagent")
+                return;
             pendingToolUpdates.set(event.toolCallId, {
-                kind: event.toolName === "subagent" ? "SUBAGENT_UPDATED" : "TOOL_UPDATED",
-                payload: event.toolName === "subagent"
-                    ? {
-                        activityKey: event.toolCallId,
-                        agentId: String(event.args?.agent ?? observed.activeTasks.get(event.toolCallId) ?? ""),
-                        currentAction: redact(textFromResult(event.partialResult)),
-                    }
-                    : {
-                        activityKey: event.toolCallId,
-                        toolName: event.toolName,
-                        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);
-            const member = observed.activeTasks.get(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 ??
-                        member ??
-                        ""),
-                    summary: redact(textFromResult(event.result)),
-                }
-                : {
-                    activityKey: event.toolCallId,
-                    toolName: event.toolName,
-                    isError: event.isError === true,
-                    summary: redact(textFromResult(event.result)),
-                });
+                return;
+            flushToolUpdate(event.toolCallId);
+            void emit("TOOL_COMPLETED", {
+                activityKey: event.toolCallId,
+                toolName: event.toolName,
+                isError: event.isError === true,
+                summary: redact(textFromResult(event.result)),
+            });
         }
         else if (event.type === "bash_execution_update" && event.delta) {
             const activityKey = event.id ?? "bash";
@@ -750,60 +794,119 @@ function textFromResult(value) {
         return "";
     return textFromMessage(value.content);
 }
-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 (observed.lastModelStopReason === "error" && observed.nativeWillRetry !== true) {
-            const code = observed.lastModelError?.split("\n")[0]?.slice(0, 200) || "MODEL_REQUEST_FAILED";
-            await client.reportCodingTerminal(runId, {
-                hostId: host.hostId,
-                generation: host.generation,
-                turnId,
-                kind: "FAILED",
-                summary: observed.lastModelError ?? code,
-                knownIssues: "",
-                failureCode: code,
-                projectFacts: [],
-                testFacts: [],
-            });
-            observed.terminalReached = true;
-            await emit("RUN_FAILED", { code });
+async function driveToTerminal(session, initial, observed, client, host, runId, turnId, emit, phase, images = [], completeConversation = async () => { }, continuation) {
+    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 (observed.stopping)
+        return;
+    if (continuation && observed.userIntervened)
+        return;
+    const execution = images.length > 0 ? session.prompt(initial, { images }) : session.prompt(initial);
+    // Observe a synchronous rejection while the invocation fact is persisted.
+    const outcome = execution.then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+    if (continuation) {
+        await emit("EXECUTION_CONTINUED", {
+            phase,
+            ...continuation,
+            prompt: initial,
+            deliveryStatus: "SUBMITTED",
+        });
+    }
+    const result = await outcome;
+    if (!result.ok)
+        throw result.error;
+    await session.waitForIdle();
+    observed.awaitingDecision = true;
+    if (observed.stopping)
+        return;
+    const stopReason = observed.terminalClosed
+        ? "TERMINAL_CLOSED"
+        : (observed.lastModelStopReason ?? "idle");
+    const endFact = { phase, stopReason, nativeStopReason: observed.lastModelStopReason ?? null };
+    if (observed.terminalReached) {
+        await emit("EXECUTION_DECIDED", {
+            ...endFact,
+            decision: "SKIP",
+            reason: "TERMINAL_ACCEPTED",
+            model: null,
+        });
+        return;
+    }
+    if (observed.lastModelStopReason === "aborted" ||
+        (observed.lastModelStopReason === "error" && observed.nativeWillRetry !== true)) {
+        const code = observed.lastModelError?.split("\n")[0]?.slice(0, 200) ||
+            (observed.lastModelStopReason === "aborted" ? "PI_MODEL_ABORTED" : "MODEL_REQUEST_FAILED");
+        await emit("EXECUTION_DECIDED", {
+            ...endFact,
+            decision: "SKIP",
+            reason: "MODEL_ERROR",
+            model: null,
+        });
+        if (observed.stopping)
             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,
+            ...host,
             turnId,
             kind: "FAILED",
-            summary: observed.lastDeliveryError ?? "Agent 多次结束但没有形成明确终态",
+            summary: observed.lastModelError ?? code,
             knownIssues: "",
-            failureCode: observed.lastDeliveryError?.split("\n")[0]?.slice(0, 200) ?? "PI_TERMINAL_TOOL_NOT_CALLED",
+            failureCode: code,
             projectFacts: [],
             testFacts: [],
         });
         observed.terminalReached = true;
-        await emit("RUN_FAILED", { code: "PI_TERMINAL_TOOL_NOT_CALLED" });
+        await emit("RUN_FAILED", { phase, code, message: observed.lastModelError ?? code });
+        return;
     }
+    // Judge reads durable messages. It queues automatic work through the same command
+    // claim boundary that gives user messages and stop priority.
+    await emit.flush();
+    if (observed.stopping)
+        return;
+    let decision;
+    try {
+        decision = await client.evaluateContinuation(runId, {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            stopReason,
+            ...(observed.lastDeliveryError
+                ? { lastDeliveryError: observed.lastDeliveryError.slice(0, 2000) }
+                : {}),
+        });
+    }
+    catch (error) {
+        if (observed.stopping)
+            return;
+        await emit("EXECUTION_DECIDED", {
+            ...endFact,
+            decision: "SKIP",
+            reason: "JUDGE_REQUEST_FAILED",
+            model: null,
+            explanation: error instanceof Error ? error.message : String(error),
+        });
+        if (observed.handingOffInput)
+            return;
+        await completeConversation();
+        observed.terminalReached = true;
+        return;
+    }
+    if (observed.stopping)
+        return;
+    await emit("EXECUTION_DECIDED", { ...endFact, ...decision });
+    // The platform has queued the continuation; never execute the returned prompt
+    // directly, because a user can cancel it before the host claims the command.
+    if (decision.decision === "CONTINUE")
+        return;
+    if (observed.stopping || observed.handingOffInput)
+        return;
+    await completeConversation();
+    observed.terminalReached = true;
 }
-function terminalTools(client, host, runId, turnId, runRoot, input, observed, redact, persistBatch, pendingBatch, emitQuestion, flushEvents) {
+function terminalTools(client, host, runId, turnId, runRoot, input, observed, persistBatch, pendingBatch, flushEvents) {
     const definitions = [];
     const add = (definition) => {
         definitions.push(definition);
@@ -836,6 +939,8 @@ function terminalTools(client, host, runId, turnId, runRoot, input, observed, re
             : Type.Object({}),
         async execute(_toolCallId, rawParams) {
             try {
+                if (observed.activeTasks.size > 0)
+                    throw new Error("SUBAGENT_TASKS_RUNNING：子任务尚未结束，请等待结果后再提交阶段交付。");
                 if (input.executionPurpose === "RELEASE") {
                     const params = rawParams;
                     if (!params?.checklistSummary?.trim())
@@ -898,6 +1003,8 @@ function terminalTools(client, host, runId, turnId, runRoot, input, observed, re
                     ? Object.keys(DELIVERY_FILES).filter((slot) => STAGE_DELIVERY_PROTOCOLS.DEVELOPMENT.requiredFiles.includes(DELIVERY_FILES[slot]))
                     : undefined);
                 const projectFacts = await collectProjectFacts(runRoot, input.projects, input.workItem.key, input.primaryProjectId);
+                if (input.phase === "DEVELOPMENT" && input.qualityReview?.enabled)
+                    await verifyReviewBranches(runRoot, input.projects, projectFacts);
                 const batch = {
                     hostId: host.hostId,
                     generation: host.generation,
@@ -925,18 +1032,6 @@ function terminalTools(client, host, runId, turnId, runRoot, input, observed, re
             }
         },
     });
-    add({
-        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")
         add({
             name: "request_code_changes",
@@ -959,36 +1054,6 @@ function terminalTools(client, host, runId, turnId, runRoot, input, observed, re
                 return toolResult("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
             },
         });
-    add({
-        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("阻塞已报告。");
-        },
-    });
     return (api) => {
         for (const definition of definitions)
             api.registerTool({
@@ -1003,7 +1068,7 @@ function terminalTools(client, host, runId, turnId, runRoot, input, observed, re
             });
     };
 }
-export async function prepareProjects(cacheRoot, runRoot, runId, projects, resume) {
+export async function prepareProjects(cacheRoot, runRoot, workItemKey, projects, resume) {
     await mkdir(cacheRoot, { recursive: true, mode: 0o700 });
     for (const project of projects) {
         const mirror = join(cacheRoot, `${project.id}.git`);
@@ -1047,7 +1112,7 @@ export async function prepareProjects(cacheRoot, runRoot, runId, projects, resum
             });
         }
         const target = join(runRoot, safeName(project.name));
-        const expectedBranch = project.devBranch || `aip/${runId}/${project.id.slice(0, 8)}`;
+        const expectedBranch = project.devBranch || `aip/${workItemKey}`;
         const existingWorktree = await exists(target);
         if (!existingWorktree) {
             if (resume)
@@ -1107,22 +1172,40 @@ async function canonicalRepository(value) {
     }
     return value.replace(/\/$/u, "");
 }
+function executionInstructions() {
+    return "按当前任务和用户最新要求工作：自主选择工具，读取、修改、编译、测试和验证，完成阶段目标后调用提交工具。咨询、解释和有限操作按用户范围处理，不自动扩张为旧阶段任务。需要用户决定或外部信息时，用自然语言说明具体问题和已完成工作，不虚构答案、测试或交付成功。错误依据真实反馈修正；结果未知的有副作用操作先核实，不盲目重放。普通回复不等于交付，提交校验失败需要检查和修正，业务门禁仍须遵守。";
+}
+async function workspaceFingerprint(runRoot, input) {
+    return JSON.stringify(await Promise.all(input.projects.map(async (project) => {
+        const cwd = join(runRoot, safeName(project.name));
+        const [head, branch, tree] = await Promise.all([
+            execFileAsync("git", ["rev-parse", "HEAD"], { cwd }),
+            execFileAsync("git", ["symbolic-ref", "--short", "-q", "HEAD"], { cwd }),
+            worktreeTreeHash(cwd),
+        ]);
+        return [project.id, head.stdout.trim(), branch.stdout.trim(), tree];
+    })));
+}
 export function initialPrompt(input, runRoot, responsible = true) {
     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。平台查询状态，不负责创建。仅说明或更新文档不退回研发；不执行实际发布、知识整理、关单。`;
+        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，返回开发→测试→人工确认，不能在此阶段擅自修改后放行。清单有缺口时自然语言说明具体问题，需要用户补充时直接提问，不能宣称核实完成。核实完成后提交清单文档改动，再调用 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");
     const phase = input.phase === "DEVELOPMENT" ? "DEVELOPMENT" : "INTEGRATION";
+    const phaseLabel = phase === "DEVELOPMENT" ? "开发与自审" : "系统测试，当前已进入系统测试，不是开发阶段";
     const protocol = STAGE_DELIVERY_PROTOCOLS[phase];
     const delivery = input.stageDeliverySnapshots?.[phase];
     if (responsible && !delivery)
         throw new Error("STAGE_DELIVERY_CONFIGURATION_MISSING");
-    const context = `当前阶段：${phase}。工单 ${input.workItem.key}：${input.workItem.title}。项目：\n${projects}\n输入材料：${directory}/prd.md${input.technicalDesign ? `、${directory}/design.md` : ""}。先读取输入材料；项目如有 AGENTS.md 或 CLAUDE.md，读取这些项目指令，按其中引用按需读取本项目框架指令和 Skill。项目材料不授予额外工具或资源权限。${input.inputConflict ? `正式输入已变化：读取 ${directory}/prd.platform.md 和适用的 design.platform.md，对照合并到 prd.md/design.md；本地副本未被覆盖，对照文件不收集。` : ""}`;
+    const context = `当前阶段：${phase}（${phaseLabel}）。工单 ${input.workItem.key}：${input.workItem.title}。项目：\n${projects}\n输入材料：${directory}/prd.md${input.technicalDesign ? `、${directory}/design.md` : ""}。先读取输入材料；项目如有 AGENTS.md 或 CLAUDE.md，读取这些项目指令，按其中引用按需读取本项目框架指令和 Skill。项目材料不授予额外工具或资源权限。${input.inputConflict ? `正式输入已变化：读取 ${directory}/prd.platform.md 和适用的 design.platform.md，对照合并到 prd.md/design.md；本地副本未被覆盖，对照文件不收集。` : ""}`;
     if (!responsible)
         return context;
-    return `${context}\n阶段交付要求（${delivery.source} revision ${delivery.revision}）：\n${delivery.prompt}\n平台固定协议：\n${protocol.instructions}\n必交文件：${protocol.requiredFiles.join("、")}。条件文件：${input.technicalDesign ? protocol.conditionalFiles.join("、") || "无" : "无"}。可选文件：${protocol.optionalFiles.join("、") || "无"}。\n最终收件目录：${directory}。当前完成工具：${protocol.tool}。`;
+    const reviewGitRequirement = phase === "DEVELOPMENT" && input.qualityReview?.enabled
+        ? `\n本轮启用平台代码质量审查。调用 complete_development 前，必须提交每个项目的全部本轮改动，并在对应项目目录使用普通 Git 将当前 HEAD 推送到平台已分配的开发分支（${input.projects.map((project) => `${project.name}: ${project.devBranch}`).join("；")}）。只允许推送这些开发分支；不得推送 main、test 或基准分支，不得 force push，不创建 MR。推送后再调用 complete_development；该工具只读核对远端精确分支 SHA 与上报 HEAD 一致，不会代替你推送。`
+        : "";
+    return `${context}\n阶段交付要求（${delivery.source} revision ${delivery.revision}）：\n${delivery.prompt}\n平台固定协议：\n${protocol.instructions}\n必交文件：${protocol.requiredFiles.join("、")}。条件文件：${input.technicalDesign ? protocol.conditionalFiles.join("、") || "无" : "无"}。可选文件：${protocol.optionalFiles.join("、") || "无"}。\n最终收件目录：${directory}。当前完成工具：${protocol.tool}。${reviewGitRequirement}`;
 }
 async function uploadBatch(client, runId, batch) {
     for (let attempt = 0;; attempt++) {
@@ -1173,6 +1256,29 @@ async function collectProjectFacts(runRoot, projects, key, primaryProjectId) {
         };
     }));
 }
+async function verifyReviewBranches(runRoot, projects, projectFacts) {
+    for (const project of projects) {
+        const fact = projectFacts.find((item) => item.projectId === project.id);
+        if (!fact || fact.branch !== project.devBranch)
+            throw new Error(`AIP_REVIEW_BRANCH_MISMATCH:${project.name}：请切换到已分配开发分支 ${project.devBranch} 后重新提交。`);
+        const ref = `refs/heads/${project.devBranch}`;
+        let remoteHead;
+        try {
+            const { stdout } = await execFileAsync("git", ["ls-remote", "--exit-code", "origin", ref], {
+                cwd: join(runRoot, safeName(project.name)),
+            });
+            remoteHead = stdout.trim().split(/\s+/u)[0];
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === 2))
+                throw new Error(`AIP_REVIEW_REMOTE_CHECK_FAILED:${project.name}：无法核验远端，请检查网络或权限后重试。`);
+        }
+        if (!remoteHead)
+            throw new Error(`AIP_REVIEW_REMOTE_BRANCH_MISSING:${project.name}：请将当前 HEAD 推送到 origin 的 ${project.devBranch} 后重试。`);
+        if (remoteHead !== fact.commitSha)
+            throw new Error(`AIP_REVIEW_REMOTE_HEAD_MISMATCH:${project.name}：远端 ${project.devBranch} 与当前 HEAD 不一致，请推送当前 HEAD 后重试。`);
+    }
+}
 async function captureProjectRevisions(runRoot, projects, key, primaryProjectId) {
     return collectProjectFacts(runRoot, projects, key, primaryProjectId);
 }