@bf-meishijian/aip 0.0.5 → 0.0.7

package/dist/coding-run-manager.js

@@ -1,18 +1,24 @@
 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 { mkdir, open, realpath, stat } from "node:fs/promises";
 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 { deliveryTools } from "./delivery-tools.js";
+import { inspectHandoffWorkspace, synchronizeLocalIntake, synchronizeRemoteWorkspace, } from "./local-handoff-workspace.js";
+import { localModelUsage } from "./local-model-usage.js";
+import { collectProjectFacts, worktreeTreeHash } from "./project-facts.js";
+import { isProviderLoginRequired } from "./provider-auth-error.js";
+export { worktreeTreeHash } from "./project-facts.js";
+import { createCodingSubagents } from "./coding-subagents.js";
+import { commandMaterialReader, 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";
+import { stageEmployeeIds } from "./stage-delivery.js";
 const execFileAsync = promisify(execFile);
 const EVENT_APPEND_MAX_ATTEMPTS = 8;
 export class CodingRunManager {
@@ -25,8 +31,63 @@ export class CodingRunManager {
         return this.active.size > 0;
     }
     async execute(client, host, command) {
+        const readMaterial = commandMaterialReader((source) => client.commandMaterial(command.id, {
+            hostId: host.hostId,
+            generation: host.generation,
+            contentHash: source.contentHash,
+        }));
         if (!command.run)
             throw new Error("CODING_RUN_COMMAND_INVALID");
+        if (command.run.action === "STOP" && command.run.runInput?.discussionTurn) {
+            const discussion = this.active.get(`${command.run.runId}:discussion`);
+            if (discussion && discussion.turnId === command.run.turnId) {
+                discussion.stopping = true;
+                discussion.observed.stopping = true;
+                await discussion.subagents?.stop();
+                await discussion.session.abort();
+                await discussion.emit("RUN_STOPPED", { phase: "DEVELOPMENT" });
+            }
+            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, async (sequence) => {
+                    const current = await readJson(stateFile);
+                    if (current)
+                        await writeSecureJson(stateFile, { ...current, lastEventSequence: sequence });
+                }, undefined, true)("RUN_STOPPED", { phase: "DEVELOPMENT" });
+            }
+            return;
+        }
+        if (command.run.action === "REVIEW_REPORT") {
+            const report = command.run.reviewReport;
+            if (!report || !command.run.runInput)
+                throw new Error("REVIEW_REPORT_INPUT_MISSING");
+            const input = command.run.runInput;
+            const runRoot = join(paths().runWorktrees, command.run.runId);
+            if (input.transferContinuation) {
+                const notes = await inspectPriorTransferWorkspaces(paths().runWorktrees, input.transferWorkspaces?.priorRunIds ?? [], input.projects);
+                if (notes.length) {
+                    const state = await readJson(join(paths().runState, `${command.run.runId}.json`));
+                    await eventEmitter(client, host, command.run.runId, command.run.turnId, state?.lastEventSequence ?? 0)("MESSAGE_COMPLETED", { contentMarkdown: `旧工作区检查：\n${notes.join("\n")}` });
+                }
+                await mkdir(runRoot, { recursive: true, mode: 0o700 });
+                await prepareProjects(paths().repositoryCache, runRoot, input.workItem.key, input.projects, false, true, input.transferWorkspaces?.uninitializedProjectIds);
+            }
+            const files = await materializeReviewReport(runRoot, input, report.files, readMaterial);
+            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 +102,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)
@@ -48,11 +110,32 @@ export class CodingRunManager {
             }
             throw error;
         }
+        if (command.run.runInput?.discussionTurn) {
+            await this.start(readMaterial, client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, images);
+            const discussion = this.active.get(`${command.run.runId}:discussion`);
+            if (discussion && command.run.messageId)
+                await discussion.emit("MESSAGE_QUEUE_UPDATED", {
+                    messageId: command.run.messageId,
+                    deliveryStatus: "READ",
+                });
+            return;
+        }
         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);
+            await this.start(readMaterial, client, host, command.run.runId, command.run.turnId, input, false, command.run.contentMarkdown, images);
+        }
+        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(readMaterial, client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, [], command.run.continuation);
         }
-        else if (command.run.action === "STEER") {
+        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,25 +144,65 @@ 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);
                 active = undefined;
             }
             if (active) {
+                if (command.run.runInput)
+                    active.input.handoff = command.run.runInput.handoff ?? null;
                 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(readMaterial, 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);
+                await this.start(readMaterial, 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,45 +212,95 @@ 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",
+                    workspaceChanges: await Promise.all(active.input.projects.map(async (project) => ({
+                        projectId: project.id,
+                        ...(await inspectHandoffWorkspace(join(active.runRoot, safeName(project.name)))),
+                    }))),
+                });
             }
             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",
+                    workspaceChanges: state?.mrContext?.projects
+                        ? await Promise.all(state.mrContext.projects.map(async (project) => ({
+                            projectId: project.id,
+                            ...(await inspectHandoffWorkspace(join(paths().runWorktrees, command.run.runId, safeName(project.name)))),
+                        })))
+                        : [],
+                });
             }
         }
         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);
+            await this.start(readMaterial, 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 = []) {
-        const active = this.active.get(runId);
+    async start(readMaterial, client, host, runId, turnId, input, resume, resumePrompt, images = [], continuation) {
+        if (!input.discussionTurn && input.phase === "DEVELOPMENT") {
+            const discussion = this.active.get(`${runId}:discussion`);
+            if (discussion) {
+                discussion.stopping = true;
+                discussion.observed.stopping = true;
+                await discussion.subagents?.stop();
+                await discussion.session.abort();
+                await discussion.emit("RUN_STOPPED", { phase: "DEVELOPMENT" });
+                await discussion.finished;
+            }
+        }
+        const activeKey = input.discussionTurn ? `${runId}:discussion` : runId;
+        const active = this.active.get(activeKey);
         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)
-                this.active.delete(runId);
+            if (this.active.get(activeKey) === active)
+                this.active.delete(activeKey);
         }
-        if (process.env.AIP_TEST_PI === "1") {
+        if (process.env.AIP_TEST_PI === "1" && !input.discussionTurn) {
             await this.synthetic(client, host, runId, turnId, input);
             return;
         }
         const local = paths();
-        const runRoot = join(local.runWorktrees, runId);
+        const developmentRoot = join(local.runWorktrees, runId);
+        const deploymentSession = input.phase === "DEPLOYMENT" && input.executionPurpose !== "RELEASE";
+        const runRoot = deploymentSession
+            ? join(local.root, "workspaces", "deployments", runId)
+            : developmentRoot;
         await mkdir(runRoot, { recursive: true, mode: 0o700 });
         const stateFile = join(local.runState, `${runId}.json`);
         const storedState = await readJson(stateFile);
@@ -135,20 +308,56 @@ 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)}`;
-        if (!storedState?.prepared || input.inputConflict)
-            await initializeDeliveryFiles(runRoot, input, Boolean(storedState?.prepared));
+            project.devBranch ||=
+                storedState?.mrContext?.projects.find((p) => p.id === project.id)?.devBranch ||
+                    `aip/${input.workItem.key}`;
+        const transferNotes = input.transferContinuation && !storedState?.prepared
+            ? await inspectPriorTransferWorkspaces(local.runWorktrees, input.transferWorkspaces?.priorRunIds ?? [], input.projects)
+            : [];
+        const cwd = input.discussionTurn
+            ? input.projects.length === 1
+                ? join(runRoot, safeName(input.projects[0].name))
+                : runRoot
+            : deploymentSession
+                ? await prepareDeploymentProjects(runRoot, input.projects, input.deploymentConfiguration)
+                : await prepareProjects(local.repositoryCache, runRoot, input.workItem.key, input.projects, Boolean(storedState?.prepared), input.transferContinuation === true, input.transferWorkspaces?.uninitializedProjectIds);
+        let appliedLocalIntake = storedState?.appliedLocalIntake;
+        if (!input.discussionTurn && input.localIntake && appliedLocalIntake !== input.localIntake.id) {
+            for (const project of input.projects) {
+                const accepted = input.localIntake.projects.find((fact) => fact.projectId === project.id);
+                if (!accepted || accepted.branch !== project.devBranch)
+                    throw new Error("LOCAL_INTAKE_PROJECT_MISMATCH");
+                await synchronizeLocalIntake(join(developmentRoot, safeName(project.name)), accepted.commitSha);
+            }
+            appliedLocalIntake = input.localIntake.id;
+            await writeSecureJson(stateFile, { ...storedState, appliedLocalIntake });
+        }
+        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 });
+        }
+        await initializeDeliveryFiles(runRoot, input, Boolean(storedState?.prepared), readMaterial);
         const deliveryInputHash = createHash("sha256")
             .update(JSON.stringify([
             input.primaryProjectId,
-            input.requirement.body_markdown,
-            input.technicalDesign?.content,
+            input.requirement.source.contentHash,
+            input.technicalDesign?.source.contentHash,
         ]))
             .digest("hex");
-        const childSessions = storedState?.childSessions ?? {};
-        let pendingDelivery = storedState?.phase !== input.phase ||
+        const newDeploymentRequest = deploymentSession &&
+            Boolean(input.deploymentRequestId) &&
+            input.deploymentRequestId !== storedState?.deploymentRequestId;
+        const deploymentRequestId = deploymentSession
+            ? input.deploymentRequestId
+            : storedState?.deploymentRequestId;
+        const delegations = storedState?.delegations ?? {};
+        let pendingDelivery = newDeploymentRequest ||
+            storedState?.phase !== input.phase ||
             resumePrompt ||
             images.length > 0 ||
             (storedState?.deliveryInputHash && storedState.deliveryInputHash !== deliveryInputHash)
@@ -163,39 +372,54 @@ export class CodingRunManager {
                 : undefined;
         const phaseSessions = storedState?.phaseSessions ?? {};
         const sessionPhase = input.executionPurpose === "RELEASE" ? "DEVELOPMENT" : input.phase;
-        let sessionRef = phaseSessions[sessionPhase];
+        let sessionRef = newDeploymentRequest ? undefined : 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,
         };
-        const persistState = () => writeSecureJson(stateFile, {
-            phase: input.phase,
-            mrContext: {
-                runId,
-                turnId,
-                workItem: input.workItem,
-                projects: input.projects,
-                primaryProjectId: input.primaryProjectId,
-            },
-            prepared: true,
-            phaseSessions,
-            sessionRef,
-            harness: "pi",
-            lastEventSequence,
-            pendingQuestion: observed.pendingQuestion,
-            childSessions,
-            pendingDelivery,
-            deliveryInputHash,
-        });
+        const persistState = () => input.discussionTurn
+            ? Promise.resolve()
+            : writeSecureJson(stateFile, {
+                phase: input.phase,
+                appliedLocalIntake,
+                mrContext: {
+                    runId,
+                    turnId,
+                    workItem: input.workItem,
+                    projects: input.projects,
+                    primaryProjectId: input.primaryProjectId,
+                },
+                prepared: true,
+                preparationBaselines,
+                phaseSessions,
+                deploymentRequestId,
+                sessionRef,
+                harness: "pi",
+                lastEventSequence,
+                delegations,
+                pendingDelivery,
+                deliveryInputHash,
+            });
         const redact = (value) => redactHostText(value, [runRoot, local.root]);
-        const emit = eventEmitter(client, host, runId, turnId, lastEventSequence, (sequence) => {
-            lastEventSequence = sequence;
-            return persistState();
-        }, redact);
+        const emit = eventEmitter(client, host, runId, turnId, lastEventSequence, input.discussionTurn
+            ? async (sequence) => {
+                const current = await readJson(stateFile);
+                if (current)
+                    await writeSecureJson(stateFile, { ...current, lastEventSequence: sequence });
+            }
+            : (sequence) => {
+                lastEventSequence = sequence;
+                return persistState();
+            }, redact, Boolean(input.discussionTurn));
+        if (transferNotes.length)
+            await emit("MESSAGE_COMPLETED", {
+                contentMarkdown: `旧工作区检查：\n${transferNotes.join("\n")}`,
+            });
+        if (!storedState?.prepared)
+            await publishReviewMaterials(runRoot, input, readMaterial);
         if (input.phase === "PREPARATION") {
             await persistState();
             await emit("PREPARATION_COMPLETED", {
@@ -203,9 +427,7 @@ export class CodingRunManager {
                 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 +436,20 @@ export class CodingRunManager {
             });
             return;
         }
-        const terminal = terminalTools(client, host, runId, turnId, runRoot, input, observed, redact, async (batch) => {
+        const binding = {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            member: "supervisor",
+        };
+        const initialEmployeeConfig = await client.employeeConfig(runId, {
+            ...binding,
+            purpose: "LOAD",
+        });
+        const terminal = deliveryTools(client, host, runId, turnId, developmentRoot, input, observed, async (batch) => {
             pendingDelivery = batch;
             await persistState();
-        }, () => pendingDelivery, (question) => emit("QUESTION_UPDATED", { question: redact(question) }), () => emit.flush());
+        }, () => pendingDelivery, () => emit.flush(), initialEmployeeConfig.toolDefinitions);
         if (!this.pi.resolveRuntimeModel)
             throw new Error("MODEL_RUNTIME_UNAVAILABLE");
         const resolved = await this.pi.resolveRuntimeModel(input.providerId, input.modelId, {
@@ -228,126 +460,43 @@ export class CodingRunManager {
         });
         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 = 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, initialEmployeeConfig, runRoot, Boolean(input.team), input.executionPurpose === "RELEASE", input.phase, () => observed.terminalReached, () => executionInstructions(input, runRoot), () => {
+            observed.terminalClosed = true;
+        });
+        const delegation = input.executionPurpose === "RELEASE"
+            ? undefined
+            : await createCodingSubagents({
+                client,
+                toolDefinitions: initialEmployeeConfig.toolDefinitions,
+                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 +505,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 +514,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")
@@ -379,6 +529,7 @@ export class CodingRunManager {
             });
         }, observed, redact);
         const activeRun = {
+            runRoot,
             session,
             supportsImages: resolved.model.input?.includes("image") === true,
             input,
@@ -386,31 +537,96 @@ 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) {
-            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "QUEUED" });
-            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
+        const disposeRun = async () => {
+            try {
+                try {
+                    await delegation?.stop();
+                    await delegation?.flush();
+                }
+                finally {
+                    await delegation?.dispose();
+                    await session.extensionRunner?.emit({ type: "session_shutdown", reason: "quit" });
+                }
+            }
+            finally {
+                session.dispose();
+                if (this.active.get(activeKey) === activeRun)
+                    this.active.delete(activeKey);
+            }
+        };
+        this.active.set(activeKey, activeRun);
+        let conversationFingerprint;
+        let prompt;
+        try {
+            phaseSessions[sessionPhase] = sessionRef;
+            await persistState();
+            await emit("RUN_STARTED", { sessionRef, phase: input.phase });
+            if (!input.discussionTurn &&
+                !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 (!input.discussionTurn && !continuation && (resumePrompt || images.length > 0)) {
+                await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "QUEUED" });
+                await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
+            }
+            conversationFingerprint = await workspaceFingerprint(runRoot, input);
+            prompt = continuation
+                ? resumePrompt
+                : `${initialPrompt(input, runRoot, true, developmentRoot)}${transferNotes.length ? `\n\n旧工作区检查：\n${transferNotes.join("\n")}` : ""}${resumePrompt ? `\n\n用户本次消息：${resumePrompt}` : resume && !resumePrompt ? "\n\n继续当前会话未完成的工作，先读取最新文件和交接结果。" : ""}`;
+        }
+        catch (error) {
+            await disposeRun();
+            throw error;
         }
-        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 discussion = async () => {
+            await session.prompt(prompt, images.length ? { images } : undefined);
+            await session.waitForIdle();
+            if (!observed.stopping)
+                await emit("CONVERSATION_COMPLETED", {
+                    phase: "DEVELOPMENT",
+                    workspaceChanged: conversationFingerprint !== (await workspaceFingerprint(runRoot, input)),
+                });
+        };
+        activeRun.finished = (input.discussionTurn
+            ? discussion()
+            : 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;
+            if (!input.discussionTurn)
+                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();
-            if (this.active.get(runId) === activeRun)
-                this.active.delete(runId);
+            try {
+                await emit.flush();
+            }
+            finally {
+                await disposeRun();
+            }
         });
     }
     async synthetic(client, host, runId, turnId, input) {
@@ -446,25 +662,33 @@ export class CodingRunManager {
                 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(),
-            })),
+            testFacts: [],
         });
     }
 }
-function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistSequence, redact = (value) => redactHostText(value)) {
-    let sequence = initialSequence;
-    let queue = Promise.resolve();
+const eventStreams = new WeakMap();
+function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistSequence, redact = (value) => redactHostText(value), preservePersist = false) {
+    let streams = eventStreams.get(client);
+    if (!streams) {
+        streams = new Map();
+        eventStreams.set(client, streams);
+    }
+    let stream = streams.get(runId);
+    if (!stream) {
+        stream = { sequence: initialSequence, queue: Promise.resolve() };
+        streams.set(runId, stream);
+    }
+    stream.sequence = Math.max(stream.sequence, initialSequence);
+    if (persistSequence && (!preservePersist || !stream.persist))
+        stream.persist = persistSequence;
+    const state = stream;
     const emit = (kind, payload) => {
-        queue = queue.then(async () => {
+        state.queue = state.queue
+            .catch(() => { })
+            .then(async () => {
             const event = {
                 eventId: crypto.randomUUID(),
-                sequence: sequence + 1,
+                sequence: state.sequence + 1,
                 turnId,
                 kind,
                 payload: kind === "PREPARATION_COMPLETED" ? payload : redactPayload(payload, redact),
@@ -477,27 +701,32 @@ function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistS
                         generation: host.generation,
                         events: [event],
                     });
-                    sequence = event.sequence;
-                    await persistSequence?.(event.sequence);
+                    state.sequence = event.sequence;
+                    await state.persist?.(event.sequence);
                     return;
                 }
                 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));
                 }
             }
         });
-        return queue;
+        return state.queue;
     };
-    return Object.assign(emit, { flush: () => queue });
+    return Object.assign(emit, { flush: () => state.queue });
 }
 function redactPayload(value, redact) {
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactPayloadValue(item, redact)]));
@@ -511,7 +740,7 @@ function redactPayloadValue(value, redact) {
         return redactPayload(value, redact);
     return value;
 }
-async function openPiSession(options) {
+export async function openPiSession(options) {
     await mkdir(options.sessionDir, { recursive: true, mode: 0o700 });
     await mkdir(options.agentDir, { recursive: true, mode: 0o700 });
     let sessionManager;
@@ -558,10 +787,49 @@ async function openPiSession(options) {
         resourceLoader: loader,
         sessionManager,
     });
+    const savedModel = sessionManager.buildSessionContext().model;
+    if (options.model &&
+        (savedModel?.provider !== options.model.provider || savedModel?.modelId !== options.model.id)) {
+        try {
+            // SDK 的显式 model 决定本轮调用，已有会话的模型变更仍通过原生接口落盘。
+            await session.setModel(options.model);
+        }
+        catch (error) {
+            session.dispose();
+            throw error;
+        }
+    }
+    // SDK 的显式 thinkingLevel 不更新已有会话元数据，补记本轮实际档位。
+    if (sessionManager.buildSessionContext().thinkingLevel !== session.thinkingLevel) {
+        sessionManager.appendThinkingLevelChange(session.thinkingLevel);
+    }
+    await session.bindExtensions({ mode: "print" });
     session.setAutoCompactionEnabled(true);
     return { session, sessionId };
 }
 function subscribeSession(session, emit, observed, redact) {
+    const publishContext = (compacting = false) => {
+        const model = session.model;
+        if (!model)
+            return;
+        const usage = session.getContextUsage();
+        if (!usage)
+            return;
+        const settings = session.settingsManager.getCompactionSettings(model);
+        void emit("CONTEXT_UPDATED", {
+            contextUsage: {
+                modelId: `${model.provider}/${model.id}`,
+                contextWindow: usage.contextWindow,
+                tokens: compacting ? null : usage.tokens,
+                status: compacting ? "COMPACTING" : usage.tokens === null ? "UNKNOWN" : "READY",
+                source: "ESTIMATE",
+                compressionThreshold: settings.enabled
+                    ? Math.max(1, usage.contextWindow - settings.reserveTokens)
+                    : null,
+            },
+        });
+    };
+    publishContext();
     let messageId = crypto.randomUUID();
     let pendingText = "";
     let textFlushTimer;
@@ -588,17 +856,24 @@ 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") {
+            publishContext();
+            if (observed.messageQueue)
+                void emit("MESSAGE_QUEUE_UPDATED", { mainAgentRunning: true });
+        }
+        else if (event.type === "agent_settled") {
+            publishContext();
+            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 +894,39 @@ 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);
+            publishContext();
             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";
@@ -693,6 +942,7 @@ function subscribeSession(session, emit, observed, redact) {
                 toolUpdateTimers.set(activityKey, setTimeout(() => flushToolUpdate(activityKey), 200));
         }
         else if (event.type === "compaction_start") {
+            publishContext(true);
             flushText();
             void emit("TOOL_STARTED", {
                 activityKey: `compaction:${event.reason}`,
@@ -701,6 +951,7 @@ function subscribeSession(session, emit, observed, redact) {
             });
         }
         else if (event.type === "compaction_end") {
+            publishContext();
             void emit("TOOL_COMPLETED", {
                 activityKey: `compaction:${event.reason}`,
                 toolName: "compaction",
@@ -711,6 +962,7 @@ function subscribeSession(session, emit, observed, redact) {
             });
         }
         else if (event.type === "message_end" && event.message.role === "assistant") {
+            publishContext();
             flushText();
             if ("stopReason" in event.message && event.message.stopReason)
                 observed.lastModelStopReason = String(event.message.stopReason);
@@ -722,16 +974,8 @@ function subscribeSession(session, emit, observed, redact) {
                 contentMarkdown: redact(content),
                 messageId,
             };
-            if (usage) {
-                payload.usage = {
-                    input: usage.input,
-                    output: usage.output,
-                    cacheRead: usage.cacheRead,
-                    cacheWrite: usage.cacheWrite,
-                    totalTokens: usage.totalTokens,
-                };
-            }
-            if (content.trim())
+            Object.assign(payload, localModelUsage(event.message, session.model));
+            if (content.trim() || usage)
                 void emit("MESSAGE_COMPLETED", payload);
         }
     });
@@ -750,260 +994,154 @@ 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 (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: observed.deploymentCheckPaused ? "DEPLOYMENT_CHECK_PAUSED" : "TERMINAL_ACCEPTED",
+            model: null,
+        });
+        return;
+    }
+    if (observed.lastModelStopReason === "aborted" ||
+        (observed.lastModelStopReason === "error" && observed.nativeWillRetry !== true)) {
+        const loginRequired = isProviderLoginRequired(observed.lastModelError);
+        const code = loginRequired
+            ? "PROVIDER_LOGIN_REQUIRED"
+            : observed.lastModelError?.split("\n")[0]?.slice(0, 200) ||
+                (observed.lastModelStopReason === "aborted" ? "PI_MODEL_ABORTED" : "MODEL_REQUEST_FAILED");
+        const message = loginRequired
+            ? "模型服务登录已失效，请到本地开发环境重新登录对应订阅后重试。"
+            : (observed.lastModelError ?? code);
+        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,
             turnId,
             kind: "FAILED",
-            summary: observed.lastDeliveryError ?? "Agent 多次结束但没有形成明确终态",
+            summary: message,
             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 });
+        return;
     }
-}
-function terminalTools(client, host, runId, turnId, runRoot, input, observed, redact, persistBatch, pendingBatch, emitQuestion, flushEvents) {
-    const definitions = [];
-    const add = (definition) => {
-        definitions.push(definition);
-    };
-    add({
-        name: input.executionPurpose === "RELEASE"
-            ? "submit_pull_requests"
-            : input.phase === "DEVELOPMENT"
-                ? "complete_development"
-                : "submit_delivery",
-        label: "提交交付",
-        description: input.executionPurpose === "RELEASE"
-            ? "核实上线清单并提交分支后，使用 Runtime GitLab 身份创建或复用 MR 并登记工单。"
-            : "读取并校验本阶段最终交付文件，上传成功后完成当前阶段。",
-        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"
-                    ? 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);
-                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;
-            }
-        },
-    });
-    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",
-            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("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
-            },
+    // 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) }
+                : {}),
         });
-    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({
-                name: definition.name,
-                label: definition.label,
-                description: definition.description,
-                parameters: definition.parameters,
-                async execute(id, args, signal) {
-                    signal?.throwIfAborted();
-                    return definition.execute(id, args);
-                },
+    }
+    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;
+}
+export async function prepareDeploymentProjects(runRoot, projects, configuration) {
+    await mkdir(runRoot, { recursive: true, mode: 0o700 });
+    for (const project of projects) {
+        const target = join(runRoot, safeName(project.name));
+        const branch = configuration?.projects.find((p) => p.projectId === project.id)?.testBranch ??
+            project.testBranch;
+        if (!branch)
+            throw new Error("DEPLOYMENT_TEST_BRANCH_REQUIRED");
+        if (!(await exists(target))) {
+            await execFileAsync("git", [
+                "clone",
+                "--branch",
+                branch,
+                "--",
+                project.repositoryUrl,
+                target,
+            ]).catch(() => {
+                throw new Error("DEPLOYMENT_REPOSITORY_PREPARE_FAILED");
             });
-    };
+        }
+        // Reuse the interrupted deployment as-is; the employee resolves its Git state.
+        const [{ stdout: origin }, { stdout: common }] = await Promise.all([
+            execFileAsync("git", ["config", "--get", "remote.origin.url"], { cwd: target }),
+            execFileAsync("git", ["rev-parse", "--git-common-dir"], { cwd: target }),
+        ]);
+        if ((await canonicalRepository(origin.trim())) !==
+            (await canonicalRepository(project.repositoryUrl)))
+            throw new Error("CODING_REPOSITORY_ORIGIN_MISMATCH");
+        if ((await realpath(resolve(target, common.trim()))) !== (await realpath(join(target, ".git"))))
+            throw new Error("DEPLOYMENT_REPOSITORY_NOT_ISOLATED");
+    }
+    return projects.length === 1 ? join(runRoot, safeName(projects[0].name)) : runRoot;
 }
-export async function prepareProjects(cacheRoot, runRoot, runId, projects, resume) {
+export async function prepareProjects(cacheRoot, runRoot, workItemKey, projects, resume, verifyRemote = false, uninitializedProjectIds = []) {
     await mkdir(cacheRoot, { recursive: true, mode: 0o700 });
     for (const project of projects) {
         const mirror = join(cacheRoot, `${project.id}.git`);
@@ -1023,8 +1161,8 @@ export async function prepareProjects(cacheRoot, runRoot, runId, projects, resum
                 (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.
+        if (!resume || verifyRemote) {
+            // Never fetch into local branch refs: stopped worktrees may contain unpublished commits.
             await execFileAsync("git", [
                 "--git-dir",
                 mirror,
@@ -1033,44 +1171,81 @@ export async function prepareProjects(cacheRoot, runRoot, runId, projects, resum
                 "remote.origin.fetch",
                 "+refs/heads/*:refs/remotes/origin/*",
             ]);
-            await execFileAsync("git", ["--git-dir", mirror, "fetch", "origin"]).catch(() => {
+            await execFileAsync("git", ["--git-dir", mirror, "fetch", "--prune", "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 expectedBranch = project.devBranch || `aip/${workItemKey}`;
         const existingWorktree = await exists(target);
         if (!existingWorktree) {
             if (resume)
                 throw new Error("CODING_RUN_WORKTREE_MISSING");
-            await execFileAsync("git", [
+            const remoteExists = await execFileAsync("git", [
                 "--git-dir",
                 mirror,
-                "worktree",
-                "add",
-                "-b",
-                expectedBranch,
-                target,
-                `refs/remotes/origin/${project.baselineBranch}`,
-            ]).catch(() => {
-                throw new Error("CODING_WORKTREE_CREATE_FAILED");
-            });
+                "show-ref",
+                "--verify",
+                "--quiet",
+                `refs/remotes/origin/${expectedBranch}`,
+            ]).then(() => true, () => false);
+            const localExists = await execFileAsync("git", [
+                "--git-dir",
+                mirror,
+                "show-ref",
+                "--verify",
+                "--quiet",
+                `refs/heads/${expectedBranch}`,
+            ]).then(() => true, () => false);
+            if (remoteExists) {
+                // A new execution owns its branch ref; an old execution keeps its worktree untouched.
+                await execFileAsync("git", [
+                    "clone",
+                    "--single-branch",
+                    "--branch",
+                    expectedBranch,
+                    project.repositoryUrl,
+                    target,
+                ]).catch(() => {
+                    throw new Error("CODING_REPOSITORY_ACCESS_FAILED");
+                });
+            }
+            else {
+                if (localExists || (verifyRemote && !uninitializedProjectIds.includes(project.id)))
+                    throw new Error(localExists
+                        ? "CODING_BRANCH_NOT_PUBLISHED：本机工单分支尚未推送，请检查并同步后再继续。"
+                        : "CODING_BRANCH_INITIALIZATION_UNCONFIRMED：远端尚无工单分支，原工作区初始化状态未确认，请检查后再继续。");
+                await execFileAsync("git", [
+                    "--git-dir",
+                    mirror,
+                    "cat-file",
+                    "-e",
+                    `refs/remotes/origin/${project.baselineBranch}`,
+                ]).catch(() => {
+                    throw new Error("CODING_BASELINE_BRANCH_UNAVAILABLE");
+                });
+                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);
+        await validateWorktree(mirror, target, expectedBranch, resume || existingWorktree, project.repositoryUrl);
+        if (existingWorktree && verifyRemote)
+            await synchronizeRemoteWorkspace(target, expectedBranch);
     }
     const onlyProject = projects.length === 1 ? projects[0] : null;
     return onlyProject ? join(runRoot, safeName(onlyProject.name)) : runRoot;
 }
-async function validateWorktree(mirror, target, expectedBranch, resume) {
+async function validateWorktree(mirror, target, expectedBranch, resume, repositoryUrl) {
     const facts = await Promise.all([
         execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: target }),
         execFileAsync("git", ["rev-parse", "--git-common-dir"], { cwd: target }),
@@ -1086,8 +1261,15 @@ async function validateWorktree(mirror, target, expectedBranch, resume) {
         realpath(commonPath.startsWith("/") ? commonPath : resolve(target, commonPath)),
         realpath(mirror),
     ]);
-    if (actualCommon !== expectedCommon)
-        throw new Error("CODING_WORKTREE_OWNERSHIP_INVALID");
+    if (actualCommon !== expectedCommon) {
+        if (actualCommon !== (await realpath(join(target, ".git"))))
+            throw new Error("CODING_WORKTREE_OWNERSHIP_INVALID");
+        const { stdout: origin } = await execFileAsync("git", ["remote", "get-url", "origin"], {
+            cwd: target,
+        });
+        if ((await canonicalRepository(origin.trim())) !== (await canonicalRepository(repositoryUrl)))
+            throw new Error("CODING_REPOSITORY_ORIGIN_MISMATCH");
+    }
     if (branch.trim() !== expectedBranch)
         throw new Error("CODING_WORKTREE_BRANCH_MISMATCH");
     if (resume)
@@ -1107,40 +1289,50 @@ async function canonicalRepository(value) {
     }
     return value.replace(/\/$/u, "");
 }
-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。平台查询状态，不负责创建。仅说明或更新文档不退回研发；不执行实际发布、知识整理、关单。`;
+function executionInstructions(input, runRoot) {
+    // 环境事实与授权单独呈现，业务方法由平台 nodeRules 提供。
+    return `本轮执行上下文：\n${JSON.stringify({
+        phase: input.phase,
+        executionPurpose: input.executionPurpose ?? null,
+        discussionOnly: input.conversationContext?.discussionOnly ?? false,
+        deploymentConfiguration: input.deploymentConfiguration ?? null,
+        testHandoff: input.testHandoff
+            ? {
+                summary: input.testHandoff.summary,
+                ...(input.testHandoff.files
+                    ? {
+                        files: input.testHandoff.files.map(({ source, baseSource, materialPath, baseMaterialPath, ...metadata }) => ({
+                            ...metadata,
+                            materialPath: join(deliveryDirectory(runRoot, input), materialPath),
+                            ...(baseMaterialPath
+                                ? {
+                                    baseMaterialPath: join(deliveryDirectory(runRoot, input), baseMaterialPath),
+                                }
+                                : {}),
+                        })),
+                    }
+                    : {}),
+            }
+            : null,
+    }, null, 2)}`;
+}
+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, materialRoot = runRoot) {
+    const directory = deliveryDirectory(materialRoot, input);
     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 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；本地副本未被覆盖，对照文件不收集。` : ""}`;
-    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}。`;
-}
-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 toolResult(text) {
-    return { content: [{ type: "text", text }], details: {} };
+    return `工单：${input.workItem.key} ${input.workItem.title}。\n当前阶段：${input.executionPurpose === "RELEASE" ? "RELEASE" : input.phase}。\n项目：\n${projects}\n输入材料：${input.materialPreparation.inputPaths.map((path) => join(directory, path)).join("、")}。\n交付目录：${directory}。${input.inputConflict ? "正式输入材料已更新。" : ""}\n${executionInstructions(input, materialRoot)}`;
 }
 function safeName(value) {
     return basename(value).replace(/[^a-zA-Z0-9._-]/gu, "-") || "project";
@@ -1154,64 +1346,9 @@ async function exists(path) {
         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))
@@ -1227,4 +1364,84 @@ export function redactHostText(value, roots = []) {
         .replace(/\b[A-Za-z]:\\(?:[^\s'"`<>]+\\?)+/gu, "[本地路径]");
     return redacted.slice(0, 100_000);
 }
+/** 检查失败命令自己的已知工作区，不从空准备结果推测初始化状态。 */
+export async function inspectWorkspaceInitialization(runId, input) {
+    const local = paths();
+    return Promise.all(input.projects.map(async (project) => {
+        let status = "UNKNOWN";
+        try {
+            const target = join(local.runWorktrees, runId, safeName(project.name));
+            const mirror = join(local.repositoryCache, `${project.id}.git`);
+            const present = async (path) => {
+                try {
+                    await stat(path);
+                    return true;
+                }
+                catch (error) {
+                    if (error.code === "ENOENT")
+                        return false;
+                    throw error;
+                }
+            };
+            if (await present(target)) {
+                const branch = (await execFileAsync("git", ["branch", "--show-current"], { cwd: target })).stdout.trim();
+                await execFileAsync("git", ["rev-parse", "--verify", "HEAD^{commit}"], { cwd: target });
+                if (branch === (project.devBranch || `aip/${input.workItem.key}`))
+                    status = "INITIALIZED";
+            }
+            else if (!(await present(mirror)))
+                status = "NOT_INITIALIZED";
+            else {
+                const refs = await execFileAsync("git", [
+                    "--git-dir",
+                    mirror,
+                    "for-each-ref",
+                    "--format=%(refname)",
+                    `refs/heads/${project.devBranch || `aip/${input.workItem.key}`}`,
+                ]);
+                status = refs.stdout.trim() ? "INITIALIZED" : "NOT_INITIALIZED";
+            }
+        }
+        catch {
+            /* 不可访问或损坏的缓存不能证明没有旧成果。 */
+        }
+        return { projectId: project.id, status };
+    }));
+}
+export async function inspectPriorTransferWorkspaces(root, runIds, projects) {
+    const notes = [];
+    for (const id of runIds) {
+        if (!/^[0-9a-f-]{36}$/iu.test(id))
+            throw new Error("CODING_PRIOR_RUN_ID_INVALID");
+        for (const project of projects) {
+            const cwd = join(root, id, safeName(project.name));
+            try {
+                try {
+                    await stat(cwd);
+                }
+                catch (error) {
+                    if (error.code === "ENOENT")
+                        continue;
+                    throw error;
+                }
+                const origin = (await execFileAsync("git", ["config", "--get", "remote.origin.url"], { cwd })).stdout.trim();
+                const branch = (await execFileAsync("git", ["branch", "--show-current"], { cwd })).stdout.trim();
+                if ((await canonicalRepository(origin)) !==
+                    (await canonicalRepository(project.repositoryUrl)) ||
+                    branch !== project.devBranch)
+                    throw new Error("WORKSPACE_IDENTITY_MISMATCH");
+                await execFileAsync("git", ["fetch", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`], { cwd });
+                const counts = (await execFileAsync("git", ["rev-list", "--left-right", "--count", `HEAD...refs/remotes/origin/${branch}`], { cwd })).stdout
+                    .trim()
+                    .split(/\s+/u);
+                const dirty = Boolean((await execFileAsync("git", ["status", "--porcelain"], { cwd })).stdout.trim());
+                notes.push(`${project.name}，旧执行 ${id}：${dirty ? "有未提交修改" : "无未提交修改"}，本地领先 ${counts[0]}、远端领先 ${counts[1]}${Number(counts[0]) && Number(counts[1]) ? "（已分叉）" : ""}。旧现场保留在 ${cwd}；本次使用独立工作区，请核对需要保留的修改。`);
+            }
+            catch {
+                notes.push(`${project.name}，旧执行 ${id}：无法确认旧现场与远端差异，旧现场未改动，请检查 ${cwd}。`);
+            }
+        }
+    }
+    return notes;
+}
 //# sourceMappingURL=coding-run-manager.js.map