@bf-meishijian/aip 0.0.4 → 0.0.5

package/dist/coding-run-manager.js

@@ -2,9 +2,8 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdir, mkdtemp, open, realpath, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { DELIVERY_FILES, STAGE_DELIVERY_PROTOCOLS, stageEmployeeIds } from "./stage-delivery.js";
 import { createAgentSession, DefaultResourceLoader, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { collectDeliveryFiles, deliveryDirectory, initializeDeliveryFiles, } from "./delivery-files.js";
@@ -13,7 +12,9 @@ import { prepareMergeRequest, registerMergeRequest, } from "./merge-requests.js"
 import { paths } from "./paths.js";
 import { PlatformClientError } from "./platform-client.js";
 import { readJson, writeSecureJson } from "./secure-json.js";
+import { DELIVERY_FILES, STAGE_DELIVERY_PROTOCOLS, stageEmployeeIds } from "./stage-delivery.js";
 const execFileAsync = promisify(execFile);
+const EVENT_APPEND_MAX_ATTEMPTS = 8;
 export class CodingRunManager {
     pi;
     active = new Map();
@@ -66,14 +67,14 @@ export class CodingRunManager {
                 active = undefined;
             }
             if (active) {
-                if (images.length > 0 && !active.session.model?.input.includes("image"))
+                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 ?? "");
-                await active.emit("MESSAGE_QUEUE_UPDATED", { deliveryStatus: "READ" });
             }
             else {
                 if (!command.run.runInput)
@@ -89,6 +90,7 @@ export class CodingRunManager {
                 active.stopping = true;
                 active.observed.stopping = true;
                 await active.session.abort();
+                await active.emit.flush();
                 for (const [activityKey, agentId] of active.observed.activeTasks) {
                     await active.emit("SUBAGENT_STOPPED", {
                         activityKey,
@@ -127,10 +129,12 @@ export class CodingRunManager {
         const local = paths();
         const runRoot = join(local.runWorktrees, runId);
         await mkdir(runRoot, { recursive: true, mode: 0o700 });
-        await mkdir(local.piSessions, { recursive: true, mode: 0o700 });
-        await mkdir(local.piAgent, { recursive: true, mode: 0o700 });
         const stateFile = join(local.runState, `${runId}.json`);
         const storedState = await readJson(stateFile);
+        if (storedState?.phaseSessions &&
+            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)}`;
@@ -159,7 +163,7 @@ export class CodingRunManager {
                 : undefined;
         const phaseSessions = storedState?.phaseSessions ?? {};
         const sessionPhase = input.executionPurpose === "RELEASE" ? "DEVELOPMENT" : input.phase;
-        let sessionFileRef = phaseSessions[sessionPhase];
+        let sessionRef = phaseSessions[sessionPhase];
         let lastEventSequence = storedState?.lastEventSequence ?? 0;
         const observed = {
             pendingQuestion: storedState?.phase === input.phase ? (storedState.pendingQuestion ?? "") : "",
@@ -179,7 +183,8 @@ export class CodingRunManager {
             },
             prepared: true,
             phaseSessions,
-            sessionFile: sessionFileRef,
+            sessionRef,
+            harness: "pi",
             lastEventSequence,
             pendingQuestion: observed.pendingQuestion,
             childSessions,
@@ -209,12 +214,12 @@ export class CodingRunManager {
             });
             return;
         }
-        const terminal = terminalExtension(client, host, runId, turnId, runRoot, input, observed, redact, async (batch) => {
+        const terminal = terminalTools(client, host, runId, turnId, runRoot, input, observed, redact, async (batch) => {
             pendingDelivery = batch;
             await persistState();
         }, () => pendingDelivery, (question) => emit("QUESTION_UPDATED", { question: redact(question) }), () => emit.flush());
         if (!this.pi.resolveRuntimeModel)
-            throw new Error("PI_RUNTIME_UNAVAILABLE");
+            throw new Error("MODEL_RUNTIME_UNAVAILABLE");
         const resolved = await this.pi.resolveRuntimeModel(input.providerId, input.modelId, {
             runId,
             turnId,
@@ -234,120 +239,106 @@ export class CodingRunManager {
         const childInstances = new Map();
         const childUpdates = new Map();
         const childTasks = new Map();
-        const team = (api) => {
+        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")}。`,
+                description: `向实际绑定员工分派子任务，返回真实子会话结果。可用员工：${availableAgents
+                    .map((id) => `${id}：${input.teamEmployees?.[id]?.name ?? id}；${input.teamEmployees?.[id]?.description ?? ""}`)
+                    .join("\n")}。`,
                 parameters: Type.Object({
-                    agent: Type.Union(availableAgents.map((name) => Type.Literal(name))),
+                    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 = params.agent;
+                    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);
-                    const childBinding = { ...binding, member };
+                    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);
-                    observed.memberResults.delete(params.agent);
-                    childUpdates.set(member, (text) => onUpdate?.({ content: [{ type: "text", text }], details: { agent: params.agent } }));
                     if (!child) {
-                        const childLive = liveEmployee(client, runId, childBinding, await client.employeeConfig(runId, { ...childBinding, purpose: "LOAD" }), runRoot, true, false, input.phase);
-                        const resultExtension = (pi) => pi.registerTool({
-                            name: "submit_member_result",
-                            label: "提交成员结果",
-                            description: "如实记录本次子任务的结果，未解决的问题必须 FAIL。仅向主管汇报，不确认最终交付。",
-                            parameters: Type.Object({
-                                status: Type.Union([Type.Literal("PASS"), Type.Literal("FAIL")]),
-                                summary: Type.String({ minLength: 1 }),
-                            }),
-                            async execute(_id, result) {
-                                const revisions = (await captureProjectRevisions(runRoot, input.projects, input.workItem.key, input.primaryProjectId)).filter((r) => Boolean(r));
-                                observed.memberResults.set(params.agent, {
-                                    status: result.status,
-                                    summary: result.summary,
-                                    revisions,
-                                });
-                                return toolResult("结果已记录，向主管返回结论。");
-                            },
-                        });
-                        const childLoader = new DefaultResourceLoader({
-                            cwd,
-                            agentDir: local.piAgent,
-                            noExtensions: true,
-                            noSkills: true,
-                            noPromptTemplates: true,
-                            noThemes: true,
-                            noContextFiles: true,
-                            extensionFactories: [childLive.extension, resultExtension],
-                            systemPrompt: "当前为团队子成员会话，员工配置由平台下发。",
-                        });
-                        await childLoader.reload();
-                        const file = childSessions[`${input.phase}:${member}`];
-                        const childManager = file
-                            ? SessionManager.open(join(local.piSessions, file), local.piSessions, cwd)
-                            : SessionManager.create(cwd, local.piSessions);
-                        const created = await createAgentSession({
+                        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,
-                            resourceLoader: childLoader,
-                            sessionManager: childManager,
+                            extensions: [childLive.extension, resultExtension],
+                            systemPrompt: "当前为团队子成员会话，员工配置由平台下发。",
+                            runId,
                         });
-                        child = created.session;
-                        childLive.attach(child);
+                        childLive.attach(opened.session);
+                        child = opened.session;
+                        childSessions[key] = opened.sessionId;
                         childInstances.set(member, child);
-                        const childFile = childManager.getSessionFile();
-                        if (!childFile)
-                            throw new Error("CHILD_SESSION_FILE_MISSING");
-                        childSessions[`${input.phase}:${member}`] = basename(childFile);
-                        await persistState();
-                        subscribeSession(child, async (kind, payload) => {
-                            if (kind === "MESSAGE_STARTED")
-                                return;
-                            if (kind === "TEXT_DELTA") {
+                        subscribeSession(child, (kind, payload) => {
+                            if (kind === "TEXT_DELTA")
                                 childUpdates.get(member)?.(String(payload.text ?? ""));
-                                return;
-                            }
-                            await emit(kind, {
+                            return emit(kind, {
                                 ...payload,
-                                agentId: params.agent,
                                 phase: input.phase,
+                                agentId: member,
                                 parentActivityKey: childTasks.get(member),
-                                sessionId: childSessions[`${input.phase}:${member}`],
+                                sessionId: opened.sessionId,
                             });
                         }, observed, redact);
+                        await persistState();
                     }
                     await emit("SUBAGENT_UPDATED", {
                         phase: input.phase,
                         task: params.task,
                         activityKey: callId,
-                        agentId: params.agent,
-                        sessionFileRef: childSessions[`${input.phase}:${member}`],
+                        agentId: member,
+                        sessionRef: childSessions[key],
                         summary: "独立子会话已就绪",
                     });
                     const abort = () => {
-                        void child?.abort();
+                        child?.agent.abort();
                     };
                     signal?.addEventListener("abort", abort, { once: true });
                     try {
-                        await child.prompt(`${initialPrompt(input, runRoot, false)}\n\n本次主管分派给 ${params.agent} 的任务：${params.task}\n只完成自身职责，最后调用 submit_member_result；主管负责其他成员协调和最终交付。`);
+                        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(params.agent);
+                        const result = observed.memberResults.get(member);
                         if (!result)
                             throw new Error("SUBAGENT_RESULT_MISSING");
                         return {
                             content: [{ type: "text", text: JSON.stringify(result) }],
-                            details: {
-                                agent: params.agent,
-                                status: result.status,
-                                sessionFileRef: childSessions[`${input.phase}:${member}`],
-                            },
+                            details: { agent: member, status: result.status },
                         };
                     }
                     finally {
@@ -357,66 +348,49 @@ export class CodingRunManager {
                 },
             });
         };
-        const loader = new DefaultResourceLoader({
+        const opened = await openPiSession({
             cwd,
+            sessionDir: local.piSessions,
             agentDir: local.piAgent,
-            extensionFactories: [...(availableAgents.length ? [team] : []), terminal, live.extension],
-            noSkills: true,
-            noExtensions: true,
-            noPromptTemplates: true,
-            noThemes: true,
-            noContextFiles: true,
+            existingId: sessionRef,
+            modelRuntime: resolved.runtime,
+            model: resolved.model,
+            thinkingLevel: input.thinkingLevel,
+            extensions: [...(availableAgents.length ? [memberExtension] : []), terminal, live.extension],
             systemPrompt: input.team
                 ? "当前为团队主负责人会话，员工配置由平台下发。"
                 : "当前为工单主会话，员工配置由平台下发。",
+            runId,
         });
-        await loader.reload();
-        const existingSession = phaseSessions[sessionPhase]
-            ? join(local.piSessions, phaseSessions[sessionPhase])
-            : null;
-        let sessionManager;
-        if (existingSession) {
-            sessionManager = SessionManager.open(existingSession, local.piSessions, cwd);
-        }
-        else {
-            sessionManager = SessionManager.create(cwd, local.piSessions);
-            const allocatedSessionFile = sessionManager.getSessionFile();
-            if (!allocatedSessionFile)
-                throw new Error("PI_SESSION_FILE_MISSING");
-            const placeholder = await open(allocatedSessionFile, "wx", 0o600);
-            await placeholder.close();
-            sessionManager.setSessionFile(allocatedSessionFile);
-            sessionManager.appendCustomEntry("aip-run-binding", {
-                runId,
+        live.attach(opened.session);
+        const session = opened.session;
+        sessionRef = opened.sessionId;
+        subscribeSession(session, (kind, payload) => {
+            const activityKey = String(payload.activityKey ?? "");
+            if (kind === "SUBAGENT_STARTED")
+                observed.activeTasks.set(activityKey, String(payload.agentId));
+            if (["SUBAGENT_COMPLETED", "SUBAGENT_FAILED", "SUBAGENT_STOPPED"].includes(kind))
+                observed.activeTasks.delete(activityKey);
+            return emit(kind, {
+                ...payload,
+                phase: input.phase,
+                agentId: payload.agentId ?? "supervisor",
+                sessionId: sessionRef,
             });
-        }
-        const sessionFile = sessionManager.getSessionFile();
-        if (!sessionFile)
-            throw new Error("PI_SESSION_FILE_MISSING");
-        if (!(await exists(sessionFile)))
-            throw new Error("PI_SESSION_FILE_NOT_PERSISTED");
-        const { session } = await createAgentSession({
-            cwd,
-            agentDir: local.piAgent,
-            modelRuntime: resolved.runtime,
-            model: resolved.model,
-            thinkingLevel: input.thinkingLevel,
-            resourceLoader: loader,
-            sessionManager,
-        });
-        live.attach(session);
-        const activeRun = { session, input, turnId, emit, stopping: false, observed };
+        }, observed, redact);
+        const activeRun = {
+            session,
+            supportsImages: resolved.model.input?.includes("image") === true,
+            input,
+            turnId,
+            emit,
+            stopping: false,
+            observed,
+        };
         this.active.set(runId, activeRun);
-        subscribeSession(session, (kind, payload) => emit(kind, {
-            ...payload,
-            phase: input.phase,
-            agentId: payload.agentId ?? "supervisor",
-            sessionId: sessionFileRef,
-        }), observed, redact);
-        sessionFileRef = basename(sessionFile);
-        phaseSessions[sessionPhase] = sessionFileRef;
+        phaseSessions[sessionPhase] = sessionRef;
         await persistState();
-        await emit("RUN_STARTED", { sessionFileRef, phase: input.phase });
+        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" });
@@ -432,13 +406,16 @@ export class CodingRunManager {
         })
             .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);
         });
     }
     async synthetic(client, host, runId, turnId, input) {
         const emit = eventEmitter(client, host, runId, turnId);
-        await emit("RUN_STARTED", { sessionFileRef: `${runId}.jsonl` });
+        await emit("RUN_STARTED", { sessionRef: `synthetic:${runId}` });
         const member = stageEmployeeIds(input)[0];
         if (member)
             await emit("SUBAGENT_STARTED", {
@@ -484,29 +461,39 @@ function eventEmitter(client, host, runId, turnId, initialSequence = 0, persistS
     let sequence = initialSequence;
     let queue = Promise.resolve();
     const emit = (kind, payload) => {
-        sequence += 1;
-        const event = {
-            eventId: crypto.randomUUID(),
-            sequence,
-            turnId,
-            kind,
-            payload: kind === "PREPARATION_COMPLETED" ? payload : redactPayload(payload, redact),
-            createdAt: new Date().toISOString(),
-        };
-        queue = queue
-            .then(() => client.appendCodingEvents(runId, {
-            hostId: host.hostId,
-            generation: host.generation,
-            events: [event],
-        }))
-            .then(() => persistSequence?.(event.sequence))
-            .then(() => undefined)
-            .catch((error) => {
-            if (error instanceof PlatformClientError &&
-                error.status === 409 &&
-                error.code === "CODING_EVENT_TURN_STALE")
-                return;
-            throw error;
+        queue = queue.then(async () => {
+            const event = {
+                eventId: crypto.randomUUID(),
+                sequence: sequence + 1,
+                turnId,
+                kind,
+                payload: kind === "PREPARATION_COMPLETED" ? payload : redactPayload(payload, redact),
+                createdAt: new Date().toISOString(),
+            };
+            for (let attempt = 1; attempt <= EVENT_APPEND_MAX_ATTEMPTS; attempt++) {
+                try {
+                    await client.appendCodingEvents(runId, {
+                        hostId: host.hostId,
+                        generation: host.generation,
+                        events: [event],
+                    });
+                    sequence = event.sequence;
+                    await persistSequence?.(event.sequence);
+                    return;
+                }
+                catch (error) {
+                    if (error instanceof PlatformClientError &&
+                        error.status === 409 &&
+                        error.code === "CODING_EVENT_TURN_STALE")
+                        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`);
+                        return;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 0));
+                }
+            }
         });
         return queue;
     };
@@ -524,227 +511,55 @@ function redactPayloadValue(value, redact) {
         return redactPayload(value, redact);
     return value;
 }
-async function driveToTerminal(session, initial, observed, client, host, runId, turnId, emit, release, phase, images = []) {
-    let prompt = initial;
-    for (let attempt = 0; attempt <= 2; attempt += 1) {
-        if (!session.model?.input.includes("image") &&
-            session.messages?.some((message) => "content" in message &&
-                Array.isArray(message.content) &&
-                message.content.some((block) => block.type === "image")))
-            throw new Error("MODEL_IMAGES_UNSUPPORTED");
-        if (attempt === 0 && images.length > 0)
-            await session.prompt(prompt, { images });
-        else
-            await session.prompt(prompt);
-        await session.waitForIdle();
-        if (observed.stopping || observed.terminalReached || observed.pendingQuestion)
-            return;
-        if (attempt < 2) {
-            prompt = release
-                ? `请调用 submit_pull_requests 完成提 PR；最近错误：${observed.lastDeliveryError ?? "尚未提交"}。`
-                : `你尚未成功交付。自主补齐必需产物后调用 ${phase === "DEVELOPMENT" ? "complete_development" : "submit_delivery"}。最近提交结果：${observed.lastDeliveryError ?? "尚未提交"}。缺文件就在当前会话补齐，传输故障不要重写报告。无法继续时说明真实原因，需要沟通可记录待回应问题。`;
-            continue;
-        }
-        await client.reportCodingTerminal(runId, {
-            hostId: host.hostId,
-            generation: host.generation,
-            turnId,
-            kind: "FAILED",
-            summary: observed.lastDeliveryError ?? "Agent 多次结束但没有形成明确终态",
-            knownIssues: "",
-            failureCode: observed.lastDeliveryError?.split("\n")[0]?.slice(0, 200) ?? "PI_TERMINAL_TOOL_NOT_CALLED",
-            projectFacts: [],
-            testFacts: [],
-        });
-        observed.terminalReached = true;
-        await emit("RUN_FAILED", { code: "PI_TERMINAL_TOOL_NOT_CALLED" });
+async function openPiSession(options) {
+    await mkdir(options.sessionDir, { recursive: true, mode: 0o700 });
+    await mkdir(options.agentDir, { recursive: true, mode: 0o700 });
+    let sessionManager;
+    if (options.existingId) {
+        const listed = await SessionManager.list(options.cwd, options.sessionDir);
+        const match = listed.find((item) => item.id === options.existingId);
+        if (!match)
+            throw new Error("PI_SESSION_NOT_FOUND：请新建执行，历史文件已保留。");
+        sessionManager = SessionManager.open(match.path, options.sessionDir, options.cwd);
     }
-}
-function terminalExtension(client, host, runId, turnId, runRoot, input, observed, redact, persistBatch, pendingBatch, emitQuestion, flushEvents) {
-    return (pi) => {
-        pi.registerTool({
-            name: input.executionPurpose === "RELEASE"
-                ? "submit_pull_requests"
-                : input.phase === "DEVELOPMENT"
-                    ? "complete_development"
-                    : "submit_delivery",
-            label: "提交交付",
-            description: input.executionPurpose === "RELEASE"
-                ? "核实上线清单并提交分支后，使用 Runtime GitLab 身份创建或复用 MR 并登记工单。"
-                : "读取并校验本阶段最终交付文件，上传成功后完成当前阶段。",
-            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;
-                }
-            },
-        });
-        pi.registerTool({
-            name: "update_question",
-            label: "更新待回应问题",
-            description: "仅记录当前执行必须由人决定的业务问题，不把一般建议变为审批；真正解决后传空字符串清除。普通聊天继续使用 steer，不停止 Run。",
-            parameters: Type.Object({ question: Type.String() }),
-            async execute(_id, params) {
-                // The caller binding supplies technical identity; the model only owns the question text.
-                observed.pendingQuestion = params.question.trim();
-                await emitQuestion(params.question);
-                return toolResult(params.question);
-            },
-        });
-        if (input.executionPurpose === "RELEASE")
-            pi.registerTool({
-                name: "request_code_changes",
-                label: "返回开发修改",
-                description: "用户明确要求修改应用代码时，将工单返回开发，再测试和人工确认；仅讨论或文档修改不要调用。",
-                parameters: Type.Object({
-                    reason: Type.String({ description: "用户要求修改的内容及原因" }),
-                }),
-                async execute(_id, params) {
-                    await client.request(`/api/v1/coding-runs/${runId}/return-to-development`, {
-                        method: "POST",
-                        body: JSON.stringify({
-                            hostId: host.hostId,
-                            generation: host.generation,
-                            turnId,
-                            reason: params.reason,
-                        }),
-                    });
-                    observed.terminalReached = true;
-                    return toolResult("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
-                },
-            });
-        pi.registerTool({
-            name: "report_blocker",
-            label: "报告阻塞",
-            description: "仅在认证、权限、仓库、外部环境或输入冲突真实阻塞时报告。",
-            parameters: Type.Object({
-                category: Type.Union([
-                    Type.Literal("AUTHENTICATION"),
-                    Type.Literal("PERMISSION"),
-                    Type.Literal("REPOSITORY"),
-                    Type.Literal("EXTERNAL_ENVIRONMENT"),
-                    Type.Literal("INPUT_CONFLICT"),
-                ]),
-                summary: Type.String(),
-            }),
-            async execute(_id, params) {
-                await client.reportCodingTerminal(runId, {
-                    hostId: host.hostId,
-                    generation: host.generation,
-                    turnId,
-                    kind: "BLOCKED",
-                    summary: redact(params.summary),
-                    knownIssues: "",
-                    blockerCategory: params.category,
-                    projectFacts: [],
-                    testFacts: [],
-                });
-                observed.terminalReached = true;
-                return toolResult("阻塞已报告。");
-            },
-        });
-    };
+    else {
+        sessionManager = SessionManager.create(options.cwd, options.sessionDir);
+        const allocated = sessionManager.getSessionFile();
+        if (!allocated)
+            throw new Error("PI_SESSION_FILE_MISSING");
+        await mkdir(dirname(allocated), { recursive: true, mode: 0o700 });
+        const placeholder = await open(allocated, "wx", 0o600);
+        await placeholder.close();
+        sessionManager.setSessionFile(allocated);
+        sessionManager.appendCustomEntry("aip-run-binding", { runId: options.runId });
+    }
+    const sessionId = sessionManager.getSessionId();
+    const sessionFile = sessionManager.getSessionFile();
+    if (!sessionFile || !(await exists(sessionFile)))
+        throw new Error("PI_SESSION_FILE_NOT_PERSISTED");
+    const loader = new DefaultResourceLoader({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        extensionFactories: options.extensions,
+        noSkills: true,
+        noExtensions: true,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: true,
+        systemPrompt: options.systemPrompt,
+    });
+    await loader.reload();
+    const { session } = await createAgentSession({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        modelRuntime: options.modelRuntime,
+        model: options.model,
+        thinkingLevel: options.thinkingLevel,
+        resourceLoader: loader,
+        sessionManager,
+    });
+    session.setAutoCompactionEnabled(true);
+    return { session, sessionId };
 }
 function subscribeSession(session, emit, observed, redact) {
     let messageId = crypto.randomUUID();
@@ -777,6 +592,22 @@ function subscribeSession(session, emit, observed, redact) {
             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" });
+            }
+        }
+        else if (event.type === "agent_end") {
+            observed.nativeWillRetry = event.willRetry === true;
+        }
+        else if (event.type === "auto_retry_end") {
+            observed.nativeWillRetry = false;
+            if (event.success === false && event.finalError)
+                observed.lastModelError = event.finalError;
+        }
         else if (event.type === "message_update" &&
             event.assistantMessageEvent.type === "text_delta" &&
             event.assistantMessageEvent.delta) {
@@ -794,7 +625,7 @@ function subscribeSession(session, emit, observed, redact) {
             void emit(subagent ? "SUBAGENT_STARTED" : "TOOL_STARTED", subagent
                 ? {
                     activityKey: event.toolCallId,
-                    agentId: String(event.args?.agent ?? observed.activeTasks.get(event.toolCallId) ?? ""),
+                    agentId: String(event.args?.agent ?? ""),
                     summary: String(event.args?.task ?? "团队子任务开始"),
                     task: String(event.args?.task ?? ""),
                 }
@@ -805,23 +636,20 @@ function subscribeSession(session, emit, observed, redact) {
                 });
         }
         else if (event.type === "tool_execution_update") {
-            pendingToolUpdates.set(event.toolCallId, event.toolName === "subagent"
-                ? {
-                    kind: "SUBAGENT_UPDATED",
-                    payload: {
+            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)),
-                    },
-                }
-                : {
-                    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));
         }
@@ -851,14 +679,330 @@ function subscribeSession(session, emit, observed, redact) {
                     summary: redact(textFromResult(event.result)),
                 });
         }
+        else if (event.type === "bash_execution_update" && event.delta) {
+            const activityKey = event.id ?? "bash";
+            pendingToolUpdates.set(activityKey, {
+                kind: "TOOL_UPDATED",
+                payload: {
+                    activityKey,
+                    toolName: "bash",
+                    currentAction: redact(event.delta),
+                },
+            });
+            if (!toolUpdateTimers.has(activityKey))
+                toolUpdateTimers.set(activityKey, setTimeout(() => flushToolUpdate(activityKey), 200));
+        }
+        else if (event.type === "compaction_start") {
+            flushText();
+            void emit("TOOL_STARTED", {
+                activityKey: `compaction:${event.reason}`,
+                toolName: "compaction",
+                summary: `上下文压缩（${event.reason}）`,
+            });
+        }
+        else if (event.type === "compaction_end") {
+            void emit("TOOL_COMPLETED", {
+                activityKey: `compaction:${event.reason}`,
+                toolName: "compaction",
+                isError: event.aborted === true || Boolean(event.errorMessage),
+                summary: redact(event.result?.summary ??
+                    event.errorMessage ??
+                    (event.aborted ? "压缩已取消" : "压缩完成")),
+            });
+        }
         else if (event.type === "message_end" && event.message.role === "assistant") {
             flushText();
+            if ("stopReason" in event.message && event.message.stopReason)
+                observed.lastModelStopReason = String(event.message.stopReason);
+            if ("errorMessage" in event.message && event.message.errorMessage)
+                observed.lastModelError = String(event.message.errorMessage);
             const content = textFromMessage(event.message.content);
-            if (content)
-                void emit("MESSAGE_COMPLETED", { contentMarkdown: redact(content), messageId });
+            const usage = event.message.usage;
+            const payload = {
+                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())
+                void emit("MESSAGE_COMPLETED", payload);
         }
     });
 }
+function textFromMessage(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : "")
+        .join("");
+}
+function textFromResult(value) {
+    if (!value || typeof value !== "object")
+        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 });
+            return;
+        }
+        if (attempt < 2) {
+            prompt = release
+                ? `请调用 submit_pull_requests 完成提 PR；最近错误：${observed.lastDeliveryError ?? "尚未提交"}。`
+                : `你尚未成功交付。自主补齐必需产物后调用 ${phase === "DEVELOPMENT" ? "complete_development" : "submit_delivery"}。最近提交结果：${observed.lastDeliveryError ?? "尚未提交"}。缺文件就在当前会话补齐，传输故障不要重写报告。无法继续时说明真实原因，需要沟通可记录待回应问题。`;
+            continue;
+        }
+        await client.reportCodingTerminal(runId, {
+            hostId: host.hostId,
+            generation: host.generation,
+            turnId,
+            kind: "FAILED",
+            summary: observed.lastDeliveryError ?? "Agent 多次结束但没有形成明确终态",
+            knownIssues: "",
+            failureCode: observed.lastDeliveryError?.split("\n")[0]?.slice(0, 200) ?? "PI_TERMINAL_TOOL_NOT_CALLED",
+            projectFacts: [],
+            testFacts: [],
+        });
+        observed.terminalReached = true;
+        await emit("RUN_FAILED", { code: "PI_TERMINAL_TOOL_NOT_CALLED" });
+    }
+}
+function 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("已返回开发，等待下一执行接手续改，完成后进入测试与人工确认。");
+            },
+        });
+    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);
+                },
+            });
+    };
+}
 export async function prepareProjects(cacheRoot, runRoot, runId, projects, resume) {
     await mkdir(cacheRoot, { recursive: true, mode: 0o700 });
     for (const project of projects) {
@@ -995,24 +1139,6 @@ async function uploadBatch(client, runId, batch) {
         }
     }
 }
-function textFromMessage(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .filter((part) => Boolean(part &&
-        typeof part === "object" &&
-        part.type === "text" &&
-        typeof part.text === "string"))
-        .map((part) => part.text)
-        .join("\n");
-}
-function textFromResult(value) {
-    if (!value || typeof value !== "object")
-        return "";
-    return textFromMessage(value.content).slice(0, 4000);
-}
 function toolResult(text) {
     return { content: [{ type: "text", text }], details: {} };
 }