@armadra/agent 0.6.8 → 0.7.0

package/dist/modes/acp/acp-sessions.d.ts

@@ -0,0 +1,80 @@
+/**
+ * `ama --mode acp` 的多会话：会话池条目、FIFO 提示队列、`session/list` 的分页与标题（docs/acp-plan.md
+ * D1、D2、D11、§2.1）。[ACP-B]
+ *
+ * - 每个 ACP sessionId 一个常驻会话（{@link PooledSession}），各有自己的事件映射器与权限模式；
+ * - 同一时刻只跑一个回合，其它会话的 `session/prompt` 进 {@link PromptQueue}（FIFO），不再回 busy；
+ * - `session/list`：按 `updatedAt` 降序、`sessionId` 次序分页，cursor 是 `updatedAt|sessionId` 的 base64。
+ */
+import type { ImageBlock } from "../../ai/types.js";
+import type { AgentSessionImpl } from "../../agent/session.js";
+import type { AgentMessage, SessionListItem } from "../../session/types.js";
+import { type AcpPromptResult, type AcpListSessionsResult } from "../../drivers/acp/types.js";
+import type { PermissionMode } from "../../permissions/types.js";
+import type { AcpEventMapper } from "./acp-events.js";
+/** `session/list` 每页条数。 */
+export declare const LIST_PAGE_SIZE = 50;
+/** 列表与 `session_info_update` 的标题上限（字符）。 */
+export declare const TITLE_LIMIT = 80;
+/** 会话池里的一个会话。 */
+export interface PooledSession {
+    readonly id: string;
+    readonly session: AgentSessionImpl;
+    readonly mapper: AcpEventMapper;
+    readonly unsubscribe: () => void;
+    /** 这个会话的权限模式（共享管线只在它是前台时等于它，出队时重放）。 */
+    mode: PermissionMode;
+}
+/** 排队或在跑的一次 `session/prompt`。 */
+export interface PromptJob {
+    readonly sessionId: string;
+    readonly text: string;
+    readonly images: ImageBlock[];
+    /** `session/cancel` / `session/close` / `$/cancel_request` 要求中断。 */
+    cancelRequested: boolean;
+    resolve(result: AcpPromptResult): void;
+    reject(error: unknown): void;
+}
+export declare const ZERO_USAGE: {
+    readonly inputTokens: 0;
+    readonly outputTokens: 0;
+    readonly cachedReadTokens: 0;
+    readonly cachedWriteTokens: 0;
+    readonly totalTokens: 0;
+};
+/** 还没开始就被取消的提示：直接回 cancelled。 */
+export declare function cancelledResult(): AcpPromptResult;
+/**
+ * 全进程一个回合：FIFO，出队时调 `run`。`run` 的结果 / 错误原样交回该提示的调用方。
+ */
+export declare class PromptQueue {
+    private readonly run;
+    private readonly waiting;
+    private current;
+    constructor(run: (job: PromptJob) => Promise<AcpPromptResult>);
+    /** 在跑的提示。 */
+    get running(): PromptJob | undefined;
+    /** 排队中的提示数。 */
+    get size(): number;
+    push(job: PromptJob): void;
+    /** 排队中属于该会话的提示全部回 cancelled 并出队；返回出队条数。 */
+    cancelQueued(sessionId?: string): number;
+    /** 等在跑的那个提示结束（`sessionId` 给了且在跑的不是它 → 立即返回）。 */
+    settled(sessionId?: string): Promise<void>;
+    private drain;
+}
+/**
+ * 标题清洗：去掉嵌入资源块（`<resource …>…</resource>`，被截断没有结尾的也去），取第一个非空行，
+ * 压成一行，≤ {@link TITLE_LIMIT} 字。空 → null。
+ */
+export declare function cleanTitle(raw: string | undefined): string | null;
+/** 会话标题：会话名，否则首条用户提示（清洗后）。 */
+export declare function sessionTitle(name: string | undefined, messages: readonly AgentMessage[]): string | null;
+export declare function encodeCursor(updatedAt: string, sessionId: string): string;
+/** 非法 cursor → invalid params。 */
+export declare function decodeCursor(cursor: unknown): {
+    updatedAt: string;
+    sessionId: string;
+};
+/** 一页会话（`cursor` 缺省从头）。 */
+export declare function pageSessions(items: readonly SessionListItem[], cursor: unknown, pageSize?: number): AcpListSessionsResult;

package/dist/modes/acp/acp-sessions.js

@@ -0,0 +1,157 @@
+/**
+ * `ama --mode acp` 的多会话：会话池条目、FIFO 提示队列、`session/list` 的分页与标题（docs/acp-plan.md
+ * D1、D2、D11、§2.1）。[ACP-B]
+ *
+ * - 每个 ACP sessionId 一个常驻会话（{@link PooledSession}），各有自己的事件映射器与权限模式；
+ * - 同一时刻只跑一个回合，其它会话的 `session/prompt` 进 {@link PromptQueue}（FIFO），不再回 busy；
+ * - `session/list`：按 `updatedAt` 降序、`sessionId` 次序分页，cursor 是 `updatedAt|sessionId` 的 base64。
+ */
+import { RPC_ERRORS, } from "../../drivers/acp/types.js";
+import { RpcError } from "../../drivers/jsonrpc.js";
+import { msg } from "../../i18n/index.js";
+/** `session/list` 每页条数。 */
+export const LIST_PAGE_SIZE = 50;
+/** 列表与 `session_info_update` 的标题上限（字符）。 */
+export const TITLE_LIMIT = 80;
+export const ZERO_USAGE = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedReadTokens: 0,
+    cachedWriteTokens: 0,
+    totalTokens: 0,
+};
+/** 还没开始就被取消的提示：直接回 cancelled。 */
+export function cancelledResult() {
+    return { stopReason: "cancelled", usage: { ...ZERO_USAGE } };
+}
+/**
+ * 全进程一个回合：FIFO，出队时调 `run`。`run` 的结果 / 错误原样交回该提示的调用方。
+ */
+export class PromptQueue {
+    run;
+    waiting = [];
+    current;
+    constructor(run) {
+        this.run = run;
+    }
+    /** 在跑的提示。 */
+    get running() {
+        return this.current?.job;
+    }
+    /** 排队中的提示数。 */
+    get size() {
+        return this.waiting.length;
+    }
+    push(job) {
+        this.waiting.push(job);
+        this.drain();
+    }
+    /** 排队中属于该会话的提示全部回 cancelled 并出队；返回出队条数。 */
+    cancelQueued(sessionId) {
+        let removed = 0;
+        for (let i = this.waiting.length - 1; i >= 0; i--) {
+            const job = this.waiting[i];
+            if (sessionId !== undefined && job.sessionId !== sessionId)
+                continue;
+            this.waiting.splice(i, 1);
+            job.cancelRequested = true;
+            job.resolve(cancelledResult());
+            removed++;
+        }
+        return removed;
+    }
+    /** 等在跑的那个提示结束（`sessionId` 给了且在跑的不是它 → 立即返回）。 */
+    async settled(sessionId) {
+        while (this.current !== undefined) {
+            if (sessionId !== undefined && this.current.job.sessionId !== sessionId)
+                return;
+            await this.current.done;
+        }
+    }
+    drain() {
+        if (this.current !== undefined)
+            return;
+        const job = this.waiting.shift();
+        if (job === undefined)
+            return;
+        const done = this.run(job).then((result) => job.resolve(result), (error) => job.reject(error));
+        this.current = { job, done };
+        void done.finally(() => {
+            this.current = undefined;
+            this.drain();
+        });
+    }
+}
+/**
+ * 标题清洗：去掉嵌入资源块（`<resource …>…</resource>`，被截断没有结尾的也去），取第一个非空行，
+ * 压成一行，≤ {@link TITLE_LIMIT} 字。空 → null。
+ */
+export function cleanTitle(raw) {
+    if (raw === undefined)
+        return null;
+    const stripped = raw.replace(/<resource\b[^>]*>[\s\S]*?(?:<\/resource>|$)/g, "");
+    const line = stripped
+        .split(/\r?\n/)
+        .map((l) => l.replace(/\s+/g, " ").trim())
+        .find((l) => l !== "");
+    if (line === undefined)
+        return null;
+    return line.length > TITLE_LIMIT ? `${line.slice(0, TITLE_LIMIT - 1)}…` : line;
+}
+/** 会话标题：会话名，否则首条用户提示（清洗后）。 */
+export function sessionTitle(name, messages) {
+    if (name !== undefined && name.trim() !== "")
+        return cleanTitle(name);
+    for (const message of messages) {
+        if (!("role" in message) || message.role !== "user")
+            continue;
+        const { content } = message;
+        const text = typeof content === "string"
+            ? content
+            : content.map((block) => (block.type === "text" ? block.text : "")).join("");
+        return cleanTitle(text);
+    }
+    return null;
+}
+export function encodeCursor(updatedAt, sessionId) {
+    return Buffer.from(`${updatedAt}|${sessionId}`, "utf8").toString("base64");
+}
+/** 非法 cursor → invalid params。 */
+export function decodeCursor(cursor) {
+    if (typeof cursor === "string" && cursor !== "") {
+        const text = Buffer.from(cursor, "base64").toString("utf8");
+        const at = text.indexOf("|");
+        if (at > 0 &&
+            at < text.length - 1 &&
+            encodeCursor(text.slice(0, at), text.slice(at + 1)) === cursor)
+            return { updatedAt: text.slice(0, at), sessionId: text.slice(at + 1) };
+    }
+    throw new RpcError(RPC_ERRORS.invalidParams, msg().acp.session.invalidCursor);
+}
+/** 排序键：`updatedAt` 降序，同时刻按 `sessionId` 降序。 */
+function before(a, b) {
+    return a.updatedAt === b.updatedAt ? a.sessionId > b.sessionId : a.updatedAt > b.updatedAt;
+}
+/** 一页会话（`cursor` 缺省从头）。 */
+export function pageSessions(items, cursor, pageSize = LIST_PAGE_SIZE) {
+    const all = items
+        .map((item) => ({
+        sessionId: item.id,
+        cwd: item.cwd,
+        title: cleanTitle(item.name) ?? cleanTitle(item.firstPrompt),
+        updatedAt: item.modifiedAt,
+    }))
+        .sort((a, b) => (before(a, b) ? -1 : 1));
+    let start = 0;
+    if (cursor !== undefined && cursor !== null) {
+        const after = decodeCursor(cursor);
+        start = all.findIndex((s) => before(after, s));
+        if (start < 0)
+            start = all.length;
+    }
+    const sessions = all.slice(start, start + pageSize);
+    const last = all[start + pageSize - 1];
+    return start + pageSize < all.length && last !== undefined
+        ? { sessions, nextCursor: encodeCursor(last.updatedAt, last.sessionId) }
+        : { sessions };
+}

package/dist/modes/acp/acp-tool-text.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `ama --mode acp` 工具调用的展示字段：title / kind / locations、结果文本（前 4 KB）与 diff 内容。
+ * [ACP-C] 从 acp-events.ts 拆出（docs/acp-plan.md §2.3、D5、D6）。
+ *
+ * - codemode 内层调用（带 parentToolCallId）的 title 加前缀 `acp.tools.codemodePrefix`；
+ * - `tool_execution_end` 的 `content` = `[diff?, text]`：diff 来自 `ToolResult.fileChange`（edit / write
+ *   填，超过单侧上限不填），text 为结果前 4 KB；`locations[].line` = `fileChange.firstChangedLine`。
+ */
+import type { AcpToolCallContent, AcpToolCallLocation, AcpToolKind } from "../../drivers/acp/types.js";
+import type { ContentBlock } from "../../ai/types.js";
+import type { ToolResult } from "../../tools/types.js";
+export declare const TOOL_OUTPUT_LIMIT: number;
+export declare function toolKind(name: string): AcpToolKind;
+/** 工具调用标题：`<工具名>: <命令 / 路径 / 模式>`；`nested` 为 codemode 内层调用时加前缀。 */
+export declare function toolTitle(name: string, args: unknown, nested?: boolean): string;
+export declare function toolLocations(args: unknown, cwd: string): AcpToolCallLocation[] | undefined;
+/** 工具结果的前 {@link TOOL_OUTPUT_LIMIT} 字符（超出附截断说明）；非文本块写成 `[type]`。 */
+export declare function resultText(content: string | readonly ContentBlock[]): string;
+/** `tool_execution_end` 的 content 与 locations：`[diff?, text]`，有 fileChange 时位置带首个改动行。 */
+export declare function resultContent(result: ToolResult): {
+    content: AcpToolCallContent[];
+    locations?: AcpToolCallLocation[];
+};

package/dist/modes/acp/acp-tool-text.js

@@ -0,0 +1,83 @@
+/**
+ * `ama --mode acp` 工具调用的展示字段：title / kind / locations、结果文本（前 4 KB）与 diff 内容。
+ * [ACP-C] 从 acp-events.ts 拆出（docs/acp-plan.md §2.3、D5、D6）。
+ *
+ * - codemode 内层调用（带 parentToolCallId）的 title 加前缀 `acp.tools.codemodePrefix`；
+ * - `tool_execution_end` 的 `content` = `[diff?, text]`：diff 来自 `ToolResult.fileChange`（edit / write
+ *   填，超过单侧上限不填），text 为结果前 4 KB；`locations[].line` = `fileChange.firstChangedLine`。
+ */
+import { isAbsolute, resolve } from "node:path";
+import { oneLine } from "../../drivers/turn.js";
+import { msg } from "../../i18n/index.js";
+export const TOOL_OUTPUT_LIMIT = 4 * 1024;
+const KINDS = {
+    read: "read",
+    write: "edit",
+    edit: "edit",
+    bash: "execute",
+    grep: "search",
+    glob: "search",
+    ls: "search",
+    find: "search",
+    web_fetch: "fetch",
+    web_search: "fetch",
+    todo: "think",
+};
+export function toolKind(name) {
+    return KINDS[name] ?? "other";
+}
+function argOf(args, ...keys) {
+    if (args === null || typeof args !== "object")
+        return undefined;
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value !== "")
+            return value;
+    }
+    return undefined;
+}
+/** 工具调用标题：`<工具名>: <命令 / 路径 / 模式>`；`nested` 为 codemode 内层调用时加前缀。 */
+export function toolTitle(name, args, nested = false) {
+    const detail = argOf(args, "command") ??
+        argOf(args, "path", "file_path", "filePath") ??
+        argOf(args, "pattern", "query", "url", "prompt");
+    const title = detail === undefined ? name : `${name}: ${oneLine(detail, 100)}`;
+    return nested ? msg().acp.tools.codemodePrefix(title) : title;
+}
+export function toolLocations(args, cwd) {
+    const path = argOf(args, "path", "file_path", "filePath");
+    if (path === undefined)
+        return undefined;
+    return [{ path: isAbsolute(path) ? path : resolve(cwd, path) }];
+}
+/** 工具结果的前 {@link TOOL_OUTPUT_LIMIT} 字符（超出附截断说明）；非文本块写成 `[type]`。 */
+export function resultText(content) {
+    const text = typeof content === "string"
+        ? content
+        : content.map((b) => (b.type === "text" ? b.text : `[${b.type}]`)).join("");
+    return text.length > TOOL_OUTPUT_LIMIT
+        ? `${text.slice(0, TOOL_OUTPUT_LIMIT)}\n${msg().acp.tools.truncated(text.length)}`
+        : text;
+}
+/** `tool_execution_end` 的 content 与 locations：`[diff?, text]`，有 fileChange 时位置带首个改动行。 */
+export function resultContent(result) {
+    const text = {
+        type: "content",
+        content: { type: "text", text: resultText(result.content) },
+    };
+    const change = result.fileChange;
+    if (change === undefined)
+        return { content: [text] };
+    return {
+        content: [
+            { type: "diff", path: change.path, oldText: change.oldText, newText: change.newText },
+            text,
+        ],
+        locations: [
+            {
+                path: change.path,
+                ...(change.firstChangedLine !== undefined ? { line: change.firstChangedLine } : {}),
+            },
+        ],
+    };
+}

package/dist/modes/print/json-event.d.ts

@@ -2,7 +2,8 @@
  * 线上事件形状（设计 §13.2、src/rpc.ts）：RPC 与 `--output-format stream-json` 共用。[B6]
  *
  * - `message_update` 变成纯增量：去掉累计消息与 `partial`，附最新 `usage`；`done / error`
- *   保留最终 `message`。其余 `SessionEvent` 原样。
+ *   保留最终 `message`。`tool_execution_end` 去掉 `result.fileChange`（[ACP-C0] 改前 / 改后全文只给
+ *   ACP 映射用，不上 RPC / stream-json 线）。其余 `SessionEvent` 原样。
  * - `toJsonLine()`：一行 JSON；Error 序列化为 `{ name, message }`，bigint 转字符串，
  *   U+2028 / U+2029 转义（部分 JSONL 客户端会把它们当换行）；图片 base64 不截断。
  */

package/dist/modes/print/json-event.js

@@ -2,7 +2,8 @@
  * 线上事件形状（设计 §13.2、src/rpc.ts）：RPC 与 `--output-format stream-json` 共用。[B6]
  *
  * - `message_update` 变成纯增量：去掉累计消息与 `partial`，附最新 `usage`；`done / error`
- *   保留最终 `message`。其余 `SessionEvent` 原样。
+ *   保留最终 `message`。`tool_execution_end` 去掉 `result.fileChange`（[ACP-C0] 改前 / 改后全文只给
+ *   ACP 映射用，不上 RPC / stream-json 线）。其余 `SessionEvent` 原样。
  * - `toJsonLine()`：一行 JSON；Error 序列化为 `{ name, message }`，bigint 转字符串，
  *   U+2028 / U+2029 转义（部分 JSONL 客户端会把它们当换行）；图片 base64 不截断。
  */
@@ -13,6 +14,10 @@ export function toWireAssistantEvent(event) {
     return rest;
 }
 export function toWireEvent(event) {
+    if (event.type === "tool_execution_end" && event.result.fileChange !== undefined) {
+        const { fileChange: _fileChange, ...result } = event.result;
+        return { ...event, result };
+    }
     if (event.type !== "message_update")
         return event;
     const wire = {

package/dist/tools/edit.d.ts

@@ -4,9 +4,11 @@
  * - 每处 `oldText` 都在**原文**上匹配，必须唯一（`replaceAll` 例外）且互不重叠；
  * - 先精确匹配；任一处精确匹配失败则整批转入模糊空间（edit-fuzzy.ts），只改写被触及的行；
  * - 不唯一 → 错误里给出现次数与首两处行号；
- * - 保留 BOM 与 CRLF；要求先 read；`details.diff` 是统一 diff（给 TUI）。
+ * - 保留 BOM 与 CRLF；要求先 read；`details.diff` 是统一 diff（给 TUI）；
+ * - `fileChange` 是改前 / 改后的磁盘原文（含 BOM / CRLF，给 ACP 的 diff 内容），任一侧超过
+ *   `FILE_CHANGE_TEXT_LIMIT` 不填；它不进转录（tool-runner 只拷 details）。
  */
-import type { ToolContext, ToolDefinition, ToolResult } from "./types.js";
+import { type FileChange, type ToolContext, type ToolDefinition, type ToolResult } from "./types.js";
 export interface EditOp {
     oldText: string;
     newText: string;
@@ -34,6 +36,8 @@ export interface EditPlan {
 export declare function planEdits(content: string, edits: readonly EditOp[], replaceAll?: boolean): EditPlan;
 /** 统一 diff（LF 文本，3 行上下文）；无差异返回空串。 */
 export declare function unifiedDiff(oldText: string, newText: string, path: string, context?: number): string;
+/** 改前 / 改后全文（[ACP-C] D6）：任一侧超过 {@link FILE_CHANGE_TEXT_LIMIT} 返回 undefined。 */
+export declare function fileChangeOf(path: string, oldText: string | null, newText: string, firstChangedLine?: number): FileChange | undefined;
 /** 检查点：写前备份（docs/rewind-plan.md §2）；钩子按约定不抛，这里再兜一层，不让编辑失败。 */
 export declare function beforeWrite(ctx: ToolContext, abs: string): Promise<void>;
 export declare function executeEdit(input: EditInput, ctx: ToolContext): Promise<ToolResult>;

package/dist/tools/edit.js

@@ -4,9 +4,12 @@
  * - 每处 `oldText` 都在**原文**上匹配，必须唯一（`replaceAll` 例外）且互不重叠；
  * - 先精确匹配；任一处精确匹配失败则整批转入模糊空间（edit-fuzzy.ts），只改写被触及的行；
  * - 不唯一 → 错误里给出现次数与首两处行号；
- * - 保留 BOM 与 CRLF；要求先 read；`details.diff` 是统一 diff（给 TUI）。
+ * - 保留 BOM 与 CRLF；要求先 read；`details.diff` 是统一 diff（给 TUI）；
+ * - `fileChange` 是改前 / 改后的磁盘原文（含 BOM / CRLF，给 ACP 的 diff 内容），任一侧超过
+ *   `FILE_CHANGE_TEXT_LIMIT` 不填；它不进转录（tool-runner 只拷 details）。
  */
 import { readFile, stat, writeFile } from "node:fs/promises";
+import { FILE_CHANGE_TEXT_LIMIT, } from "./types.js";
 import { displayPath, resolvePath } from "./paths.js";
 import { withFileMutex } from "./file-mutex.js";
 import { applyPreservingLines, applyReplacements, detectLineEnding, findAll, lineNumberAt, normalizeForFuzzy, normalizeToLF, restoreLineEndings, splitBom, } from "./edit-fuzzy.js";
@@ -161,6 +164,16 @@ function firstChangedLine(oldText, newText) {
         i++;
     return i + 1;
 }
+/** 改前 / 改后全文（[ACP-C] D6）：任一侧超过 {@link FILE_CHANGE_TEXT_LIMIT} 返回 undefined。 */
+export function fileChangeOf(path, oldText, newText, firstChangedLine) {
+    if (newText.length > FILE_CHANGE_TEXT_LIMIT)
+        return undefined;
+    if (oldText !== null && oldText.length > FILE_CHANGE_TEXT_LIMIT)
+        return undefined;
+    return firstChangedLine === undefined
+        ? { path, oldText, newText }
+        : { path, oldText, newText, firstChangedLine };
+}
 // ---------------------------------------------------------------------------
 // 工具
 // ---------------------------------------------------------------------------
@@ -216,7 +229,11 @@ export async function executeEdit(input, ctx) {
         };
         const note = plan.fuzzy ? " (matched after whitespace/quote normalization)" : "";
         const count = `${plan.replacements} replacement${plan.replacements === 1 ? "" : "s"}`;
-        return { content: `Edited ${shown}: ${count}${note}`, details };
+        const result = { content: `Edited ${shown}: ${count}${note}`, details };
+        const fileChange = fileChangeOf(abs, raw, output, details.firstChangedLine);
+        if (fileChange !== undefined)
+            result.fileChange = fileChange;
+        return result;
     });
 }
 export function createEditTool() {

package/dist/tools/types.d.ts

@@ -66,7 +66,18 @@ export interface ToolResult {
     structured?: unknown;
     /** 整批工具结果都为 true 才提前结束 run。 */
     terminate?: boolean;
+    /** [ACP-C0] 文件改动的改前 / 改后全文（edit / write 填）；只随事件走，不落盘（tool-runner 只拷 details）。 */
+    fileChange?: FileChange;
 }
+/** [ACP-C0] 文件改动：`oldText` 为 null 表示新建；`firstChangedLine` 从 1 起。 */
+export interface FileChange {
+    path: string;
+    oldText: string | null;
+    newText: string;
+    firstChangedLine?: number;
+}
+/** [ACP-C0] `fileChange` 单侧文本上限（字符数），超过就不填。 */
+export declare const FILE_CHANGE_TEXT_LIMIT: number;
 export interface SubagentRequest {
     prompt: string;
     description?: string;

package/dist/tools/types.js

@@ -18,6 +18,8 @@
  *   统一入口 `SubagentRunner / RunnerHandle / SubagentEvent`（ama 子会话、外部 CLI、宿主 runner）；
  *   `ToolContext.tasks` 为任务注册表的只读视图（W5-G 提供）。
  */
+/** [ACP-C0] `fileChange` 单侧文本上限（字符数），超过就不填。 */
+export const FILE_CHANGE_TEXT_LIMIT = 256 * 1024;
 /** 恒等函数，帮助推断输入类型。 */
 export function defineTool(tool) {
     return tool;

package/dist/tools/write.d.ts

@@ -3,6 +3,7 @@
  *
  * 整文件覆盖、自动建父目录；文件已存在且不在 `ctx.readFiles` → 错误「先 read」；若原文件有 BOM
  * 或 CRLF，写回时保留（新内容自带 BOM / CRLF 时不重复加）。`details: { bytes, created }`。
+ * `fileChange`（[ACP-C] D6）：改前 / 改后的磁盘原文，新文件 `oldText: null`；任一侧超过上限不填。
  */
 import type { ToolContext, ToolDefinition, ToolResult } from "./types.js";
 export interface WriteInput {

package/dist/tools/write.js

@@ -3,12 +3,13 @@
  *
  * 整文件覆盖、自动建父目录；文件已存在且不在 `ctx.readFiles` → 错误「先 read」；若原文件有 BOM
  * 或 CRLF，写回时保留（新内容自带 BOM / CRLF 时不重复加）。`details: { bytes, created }`。
+ * `fileChange`（[ACP-C] D6）：改前 / 改后的磁盘原文，新文件 `oldText: null`；任一侧超过上限不填。
  */
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { displayPath, resolvePath } from "./paths.js";
 import { withFileMutex } from "./file-mutex.js";
-import { beforeWrite } from "./edit.js";
+import { beforeWrite, fileChangeOf } from "./edit.js";
 import { BOM, detectLineEnding, normalizeToLF, restoreLineEndings, splitBom, } from "./edit-fuzzy.js";
 async function exists(path) {
     try {
@@ -29,6 +30,17 @@ export function conformToOriginal(original, content) {
     }
     return (bom !== "" || incoming.bom !== "" ? BOM : "") + body;
 }
+/** 首个不同的行（从 1 起，按 LF 归一后比较；内容不变时为末行）；新文件为 1。 */
+function firstLineChanged(original, output) {
+    if (original === null)
+        return 1;
+    const a = normalizeToLF(splitBom(original).text).split("\n");
+    const b = normalizeToLF(splitBom(output).text).split("\n");
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    return Math.min(i + 1, b.length);
+}
 export async function executeWrite(input, ctx) {
     const abs = resolvePath(input.path, ctx.cwd);
     const shown = displayPath(abs, ctx.cwd);
@@ -40,6 +52,7 @@ export async function executeWrite(input, ctx) {
         if (state === "dir")
             return { content: `${shown} is a directory`, isError: true };
         let output = input.content;
+        let original = null;
         if (state === "file") {
             if (!ctx.readFiles.has(abs)) {
                 return {
@@ -47,7 +60,8 @@ export async function executeWrite(input, ctx) {
                     isError: true,
                 };
             }
-            output = conformToOriginal(await readFile(abs, "utf8"), input.content);
+            original = await readFile(abs, "utf8");
+            output = conformToOriginal(original, input.content);
         }
         await beforeWrite(ctx, abs);
         await mkdir(dirname(abs), { recursive: true });
@@ -60,7 +74,11 @@ export async function executeWrite(input, ctx) {
             created: state === false,
         };
         const verb = details.created ? "Created" : "Overwrote";
-        return { content: `${verb} ${shown} (${details.bytes} bytes)`, details };
+        const result = { content: `${verb} ${shown} (${details.bytes} bytes)`, details };
+        const fileChange = fileChangeOf(abs, original, output, firstLineChanged(original, output));
+        if (fileChange !== undefined)
+            result.fileChange = fileChange;
+        return result;
     });
 }
 export function createWriteTool() {