@bf-meishijian/aip 0.0.6 → 0.0.8

package/dist/coding-run-manager.js

@@ -1,21 +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 { 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 { collectDeliveryFiles, deliveryDirectory, initializeDeliveryFiles, publishReviewMaterials, } from "./delivery-files.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 {
@@ -28,13 +31,49 @@ 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 files = await materializeReviewReport(join(paths().runWorktrees, command.run.runId), command.run.runInput, report.files);
+            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,
@@ -71,9 +110,19 @@ 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);
@@ -84,7 +133,7 @@ export class CodingRunManager {
             }
             if (!command.run.runInput || !command.run.contentMarkdown || !command.run.continuation)
                 throw new Error("CODING_RUN_CONTINUATION_MISSING");
-            await this.start(client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, [], command.run.continuation);
+            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" || command.run.action === "FOLLOW_UP") {
             let active = this.active.get(command.run.runId);
@@ -108,6 +157,8 @@ export class CodingRunManager {
                 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.userIntervened = true;
@@ -127,7 +178,7 @@ export class CodingRunManager {
                     await active.finished;
                     if (!command.run.runInput)
                         throw new Error("CODING_RUN_INPUT_MISSING");
-                    await this.start(client, host, command.run.runId, command.run.turnId, command.run.runInput, true, command.run.contentMarkdown, images);
+                    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,
@@ -146,7 +197,7 @@ export class CodingRunManager {
             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,
@@ -176,7 +227,14 @@ export class CodingRunManager {
                     reason: "STOP_REQUESTED",
                     stopReason: "USER_STOPPED",
                 });
-                await active.emit("RUN_STOPPED", { phase: active.input.phase, reason: "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`);
@@ -185,11 +243,17 @@ export class CodingRunManager {
                     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)) {
@@ -204,23 +268,39 @@ export class CodingRunManager {
                 });
         }
     }
-    async start(client, host, runId, turnId, input, resume, resumePrompt, images = [], continuation) {
-        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 && !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);
@@ -232,7 +312,27 @@ export class CodingRunManager {
             project.devBranch ||=
                 storedState?.mrContext?.projects.find((p) => p.id === project.id)?.devBranch ||
                     `aip/${input.workItem.key}`;
-        const cwd = await prepareProjects(local.repositoryCache, runRoot, input.workItem.key, input.projects, Boolean(storedState?.prepared));
+        const 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)
@@ -241,17 +341,23 @@ export class CodingRunManager {
                 })).stdout.trim();
             await writeSecureJson(stateFile, { ...storedState, preparationBaselines });
         }
-        if (!storedState?.prepared || input.inputConflict)
-            await initializeDeliveryFiles(runRoot, input, Boolean(storedState?.prepared));
+        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 newDeploymentRequest = deploymentSession &&
+            Boolean(input.deploymentRequestId) &&
+            input.deploymentRequestId !== storedState?.deploymentRequestId;
+        const deploymentRequestId = deploymentSession
+            ? input.deploymentRequestId
+            : storedState?.deploymentRequestId;
         const delegations = storedState?.delegations ?? {};
-        let pendingDelivery = storedState?.phase !== input.phase ||
+        let pendingDelivery = newDeploymentRequest ||
+            storedState?.phase !== input.phase ||
             resumePrompt ||
             images.length > 0 ||
             (storedState?.deliveryInputHash && storedState.deliveryInputHash !== deliveryInputHash)
@@ -266,7 +372,7 @@ 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 = {
             userIntervened: input.autoContinueEnabled === false,
@@ -274,33 +380,47 @@ export class CodingRunManager {
             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,
-            preparationBaselines,
-            phaseSessions,
-            sessionRef,
-            harness: "pi",
-            lastEventSequence,
-            delegations,
-            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") {
-            if (!storedState?.prepared)
-                await publishReviewMaterials(runRoot, input);
             await persistState();
             await emit("PREPARATION_COMPLETED", {
                 primaryProjectId: input.primaryProjectId,
@@ -316,10 +436,20 @@ export class CodingRunManager {
             });
             return;
         }
-        const terminal = terminalTools(client, host, runId, turnId, runRoot, input, observed, 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, () => 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, {
@@ -330,20 +460,15 @@ 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, Boolean(input.team), input.executionPurpose === "RELEASE", input.phase, () => observed.terminalReached, executionInstructions, () => {
+        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,
@@ -404,6 +529,7 @@ export class CodingRunManager {
             });
         }, observed, redact);
         const activeRun = {
+            runRoot,
             session,
             supportsImages: resolved.model.input?.includes("image") === true,
             input,
@@ -413,41 +539,79 @@ export class CodingRunManager {
             observed,
             ...(delegation ? { subagents: delegation } : {}),
         };
-        this.active.set(runId, activeRun);
-        phaseSessions[sessionPhase] = sessionRef;
-        await persistState();
-        await emit("RUN_STARTED", { sessionRef, phase: input.phase });
-        if (!continuation &&
-            (input.autoContinueEnabled === false || (!resume && input.autoContinueEnabled === true))) {
-            await emit("AUTO_CONTINUATION_CHANGED", {
-                phase: input.phase,
-                autoContinueEnabled: input.autoContinueEnabled === true,
-                reason: input.autoContinueEnabled === true ? "SYSTEM_STAGE" : "USER_MESSAGE",
-                source: "HOST_HANDLED",
-            });
+        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继续当前会话未完成的工作，先读取最新文件和交接结果。" : ""}`;
         }
-        if (!continuation && (resumePrompt || images.length > 0)) {
-            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "QUEUED" });
-            await emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
+        catch (error) {
+            await disposeRun();
+            throw error;
         }
-        const conversationFingerprint = await workspaceFingerprint(runRoot, input);
-        const prompt = continuation
-            ? resumePrompt
-            : `${initialPrompt(input, runRoot)}\n\n${executionInstructions()}${resumePrompt ? `\n\n用户本次消息：${resumePrompt}` : resume && !resumePrompt ? "\n\n继续当前会话未完成的工作，先读取最新文件和交接结果。" : ""}`;
-        activeRun.finished = driveToTerminal(session, prompt, observed, client, host, runId, turnId, emit, input.phase, images, async () => {
-            await emit("CONVERSATION_COMPLETED", {
-                workspaceChanged: conversationFingerprint !== (await workspaceFingerprint(runRoot, input)),
-            });
-        }, continuation)
+        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;
-            await emit("EXECUTION_DECIDED", {
-                phase: input.phase,
-                decision: "SKIP",
-                reason: "MODEL_ERROR",
-                stopReason: "error",
-            });
+            if (!input.discussionTurn)
+                await emit("EXECUTION_DECIDED", {
+                    phase: input.phase,
+                    decision: "SKIP",
+                    reason: "MODEL_ERROR",
+                    stopReason: "error",
+                });
             await emit("RUN_FAILED", {
                 phase: input.phase,
                 code: error instanceof Error && /^[A-Z][A-Z0-9_]+$/u.test(error.message)
@@ -457,18 +621,12 @@ export class CodingRunManager {
             });
         })
             .finally(async () => {
-            await emit.flush();
             try {
-                await delegation?.stop();
-                await delegation?.flush();
+                await emit.flush();
             }
             finally {
-                await delegation?.dispose();
-                await session.extensionRunner?.emit({ type: "session_shutdown", reason: "quit" });
-                session.dispose();
+                await disposeRun();
             }
-            if (this.active.get(runId) === activeRun)
-                this.active.delete(runId);
         });
     }
     async synthetic(client, host, runId, turnId, input) {
@@ -504,27 +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
+        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),
@@ -537,8 +701,8 @@ 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) {
@@ -560,9 +724,9 @@ function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistS
                 }
             }
         });
-        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)]));
@@ -576,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;
@@ -623,11 +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;
@@ -655,10 +857,12 @@ function subscribeSession(session, emit, observed, redact) {
     };
     session.subscribe((event) => {
         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 });
         }
@@ -713,6 +917,7 @@ function subscribeSession(session, emit, observed, redact) {
                 toolUpdateTimers.set(event.toolCallId, setTimeout(() => flushToolUpdate(event.toolCallId), 200));
         }
         else if (event.type === "tool_execution_end") {
+            publishContext();
             if (event.toolName === "subagent")
                 return;
             flushToolUpdate(event.toolCallId);
@@ -737,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}`,
@@ -745,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",
@@ -755,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);
@@ -766,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);
         }
     });
@@ -795,11 +995,6 @@ function textFromResult(value) {
     return textFromMessage(value.content);
 }
 async function driveToTerminal(session, initial, observed, client, host, runId, turnId, emit, phase, images = [], completeConversation = async () => { }, continuation) {
-    if (!session.model?.input.includes("image") &&
-        session.messages?.some((message) => "content" in message &&
-            Array.isArray(message.content) &&
-            message.content.some((block) => block.type === "image")))
-        throw new Error("MODEL_IMAGES_UNSUPPORTED");
     if (observed.stopping)
         return;
     if (continuation && observed.userIntervened)
@@ -830,15 +1025,21 @@ async function driveToTerminal(session, initial, observed, client, host, runId,
         await emit("EXECUTION_DECIDED", {
             ...endFact,
             decision: "SKIP",
-            reason: "TERMINAL_ACCEPTED",
+            reason: observed.deploymentCheckPaused ? "DEPLOYMENT_CHECK_PAUSED" : "TERMINAL_ACCEPTED",
             model: null,
         });
         return;
     }
     if (observed.lastModelStopReason === "aborted" ||
         (observed.lastModelStopReason === "error" && observed.nativeWillRetry !== true)) {
-        const code = observed.lastModelError?.split("\n")[0]?.slice(0, 200) ||
-            (observed.lastModelStopReason === "aborted" ? "PI_MODEL_ABORTED" : "MODEL_REQUEST_FAILED");
+        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",
@@ -848,17 +1049,18 @@ async function driveToTerminal(session, initial, observed, client, host, runId,
         if (observed.stopping)
             return;
         await client.reportCodingTerminal(runId, {
-            ...host,
+            hostId: host.hostId,
+            generation: host.generation,
             turnId,
             kind: "FAILED",
-            summary: observed.lastModelError ?? code,
+            summary: message,
             knownIssues: "",
             failureCode: code,
             projectFacts: [],
             testFacts: [],
         });
         observed.terminalReached = true;
-        await emit("RUN_FAILED", { phase, code, message: observed.lastModelError ?? code });
+        await emit("RUN_FAILED", { phase, code, message });
         return;
     }
     // Judge reads durable messages. It queues automatic work through the same command
@@ -906,169 +1108,40 @@ async function driveToTerminal(session, initial, observed, client, host, runId,
     await completeConversation();
     observed.terminalReached = true;
 }
-function terminalTools(client, host, runId, turnId, runRoot, input, observed, persistBatch, pendingBatch, 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 (observed.activeTasks.size > 0)
-                    throw new Error("SUBAGENT_TASKS_RUNNING：子任务尚未结束，请等待结果后再提交阶段交付。");
-                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);
-                if (input.phase === "DEVELOPMENT" && input.qualityReview?.enabled)
-                    await verifyReviewBranches(runRoot, input.projects, projectFacts);
-                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;
-            }
-        },
-    });
-    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("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
-            },
-        });
-    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);
-                },
+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, workItemKey, 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`);
@@ -1088,8 +1161,8 @@ export async function prepareProjects(cacheRoot, runRoot, workItemKey, projects,
                 (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,
@@ -1098,18 +1171,9 @@ export async function prepareProjects(cacheRoot, runRoot, workItemKey, projects,
                 "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/${workItemKey}`;
@@ -1117,25 +1181,71 @@ export async function prepareProjects(cacheRoot, runRoot, workItemKey, projects,
         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 }),
@@ -1151,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)
@@ -1172,8 +1289,32 @@ async function canonicalRepository(value) {
     }
     return value.replace(/\/$/u, "");
 }
-function executionInstructions() {
-    return "按当前任务和用户最新要求工作：自主选择工具，读取、修改、编译、测试和验证，完成阶段目标后调用提交工具。咨询、解释和有限操作按用户范围处理，不自动扩张为旧阶段任务。需要用户决定或外部信息时，用自然语言说明具体问题和已完成工作，不虚构答案、测试或交付成功。错误依据真实反馈修正；结果未知的有副作用操作先核实，不盲目重放。普通回复不等于交付，提交校验失败需要检查和修正，业务门禁仍须遵守。";
+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) => {
@@ -1186,44 +1327,12 @@ async function workspaceFingerprint(runRoot, input) {
         return [project.id, head.stdout.trim(), branch.stdout.trim(), tree];
     })));
 }
-export function initialPrompt(input, runRoot, responsible = true) {
-    const directory = deliveryDirectory(runRoot, input);
-    if (input.executionPurpose === "RELEASE")
-        return `当前是人工验收通过后的上线准备，恢复原开发会话。工单 ${input.workItem.key}：${input.workItem.title}。项目分支：${input.projects.map((p) => `${p.name} ${p.devBranch} → ${p.baselineBranch}`).join("；")}。共享工作区已由测试会话处理，不能依赖旧会话记忆：先读取最新代码、${directory}/report.md、release_checklist.md、summary.md 和适用的 design.md。以项目源分支和目标分支为依据，不按 commit ID 或 tree hash 校验验收一致性。核实上线清单，明确无需修改或修改摘要；清单覆盖项目与分支、SQL、Apollo、定时任务、Kafka/RabbitMQ资源、监控告警、发布顺序、验证和回滚。以设计为预期、代码核实；没有设计则从代码提取。无法证明的环境事实标明待核实，不涉及说明原因；测试环境部署记录不能代替上线清单。用户明确要求修改应用代码时调用 request_code_changes，返回开发→测试→人工确认，不能在此阶段擅自修改后放行。清单有缺口时自然语言说明具体问题，需要用户补充时直接提问，不能宣称核实完成。核实完成后提交清单文档改动，再调用 submit_pull_requests，传入核实摘要和各项目 MR 标题说明；工具使用 Runtime 的 glab 身份推送、创建或复用 MR 并结构化登记工单。说明覆盖任务目的、本项目改动、测试验收、发布注意、跨项目依赖、风险回滚及材料入口。MR仍打开时复用；关闭后仅在用户明确重提时创建新MR。平台查询状态，不负责创建。仅说明或更新文档不退回研发；不执行实际发布、知识整理、关单。`;
+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 phaseLabel = phase === "DEVELOPMENT" ? "开发与自审" : "系统测试，当前已进入系统测试，不是开发阶段";
-    const protocol = STAGE_DELIVERY_PROTOCOLS[phase];
-    const delivery = input.stageDeliverySnapshots?.[phase];
-    if (responsible && !delivery)
-        throw new Error("STAGE_DELIVERY_CONFIGURATION_MISSING");
-    const context = `当前阶段：${phase}（${phaseLabel}）。工单 ${input.workItem.key}：${input.workItem.title}。项目：\n${projects}\n输入材料：${directory}/prd.md${input.technicalDesign ? `、${directory}/design.md` : ""}。先读取输入材料；项目如有 AGENTS.md 或 CLAUDE.md，读取这些项目指令，按其中引用按需读取本项目框架指令和 Skill。项目材料不授予额外工具或资源权限。${input.inputConflict ? `正式输入已变化：读取 ${directory}/prd.platform.md 和适用的 design.platform.md，对照合并到 prd.md/design.md；本地副本未被覆盖，对照文件不收集。` : ""}`;
-    if (!responsible)
-        return context;
-    const reviewGitRequirement = phase === "DEVELOPMENT" && input.qualityReview?.enabled
-        ? `\n本轮启用平台代码质量审查。调用 complete_development 前，必须提交每个项目的全部本轮改动，并在对应项目目录使用普通 Git 将当前 HEAD 推送到平台已分配的开发分支（${input.projects.map((project) => `${project.name}: ${project.devBranch}`).join("；")}）。只允许推送这些开发分支；不得推送 main、test 或基准分支，不得 force push，不创建 MR。推送后再调用 complete_development；该工具只读核对远端精确分支 SHA 与上报 HEAD 一致，不会代替你推送。`
-        : "";
-    return `${context}\n阶段交付要求（${delivery.source} revision ${delivery.revision}）：\n${delivery.prompt}\n平台固定协议：\n${protocol.instructions}\n必交文件：${protocol.requiredFiles.join("、")}。条件文件：${input.technicalDesign ? protocol.conditionalFiles.join("、") || "无" : "无"}。可选文件：${protocol.optionalFiles.join("、") || "无"}。\n最终收件目录：${directory}。当前完成工具：${protocol.tool}。${reviewGitRequirement}`;
-}
-async function uploadBatch(client, runId, batch) {
-    for (let attempt = 0;; attempt++) {
-        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";
@@ -1237,87 +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 verifyReviewBranches(runRoot, projects, projectFacts) {
-    for (const project of projects) {
-        const fact = projectFacts.find((item) => item.projectId === project.id);
-        if (!fact || fact.branch !== project.devBranch)
-            throw new Error(`AIP_REVIEW_BRANCH_MISMATCH:${project.name}：请切换到已分配开发分支 ${project.devBranch} 后重新提交。`);
-        const ref = `refs/heads/${project.devBranch}`;
-        let remoteHead;
-        try {
-            const { stdout } = await execFileAsync("git", ["ls-remote", "--exit-code", "origin", ref], {
-                cwd: join(runRoot, safeName(project.name)),
-            });
-            remoteHead = stdout.trim().split(/\s+/u)[0];
-        }
-        catch (error) {
-            if (!(error && typeof error === "object" && "code" in error && error.code === 2))
-                throw new Error(`AIP_REVIEW_REMOTE_CHECK_FAILED:${project.name}：无法核验远端，请检查网络或权限后重试。`);
-        }
-        if (!remoteHead)
-            throw new Error(`AIP_REVIEW_REMOTE_BRANCH_MISSING:${project.name}：请将当前 HEAD 推送到 origin 的 ${project.devBranch} 后重试。`);
-        if (remoteHead !== fact.commitSha)
-            throw new Error(`AIP_REVIEW_REMOTE_HEAD_MISMATCH:${project.name}：远端 ${project.devBranch} 与当前 HEAD 不一致，请推送当前 HEAD 后重试。`);
-    }
-}
 async function captureProjectRevisions(runRoot, projects, key, primaryProjectId) {
     return collectProjectFacts(runRoot, projects, key, primaryProjectId);
 }
-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))
@@ -1333,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