@armadra/agent 0.7.3 → 0.7.4

package/dist/session/manager.js

@@ -7,17 +7,19 @@
  * - `open(file)`：读文件（修复末尾半行）、校验版本、加锁；叶子 = 文件中最后一条条目，
  *   若其后还有 `leaf` 行（`/tree` 换叶子落盘，第三波 A7）则取最后一条 leaf 行。
  * - `setLeaf(id)`：已落盘时追加一行 `leaf{id, timestamp}`；延迟会话在 `flush()` 时补写。
- * - `fork(entryId)`：复制 root → entryId 的分支到新文件（头的 parentSession 指回本文件），
- *   不复制 leaf 行。
+ * - `fork(entryId, { head })`：复制 root → entryId 的分支到新文件（头的 parentSession 指回本文件），
+ *   不复制 leaf 行；给了 `head` 时它成为新根条目，复制的首条重挂到它下面（fork 子会话的 ama.task）；
+ *   `cwd` 缺省同本会话（[ME-A] 隔离的 fork 子会话传 worktree）。
  * - `close()`：释放锁；之后的 append 抛错。
  */
 import { randomBytes, randomUUID } from "node:crypto";
-import { statSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { internSessionImages } from "../ai/image-intern.js";
 import { AmaError } from "../errors.js";
 import { AMA_VERSION } from "../version.js";
+import { listSessionItems } from "./list.js";
 import { migrateSessionLines } from "./migrate.js";
-import { acquireLock, appendLines, isSubagentSession, isSubagentSessionFile, listSessionFiles, readSessionLines, sessionDirForCwd, sessionFileName, writeNewSessionFile, } from "./store.js";
+import { acquireLock, appendLines, isSubagentSessionFile, listSessionFiles, readSessionLines, sessionDirForCwd, sessionFileName, writeNewSessionFile, } from "./store.js";
 import { buildTree, indexEntries, pathToRoot } from "./tree.js";
 import { SESSION_FORMAT_VERSION } from "./types.js";
 function newEntryId(taken) {
@@ -79,6 +81,7 @@ export class SessionManager {
         try {
             const { lines } = readSessionLines(file, { repair: true });
             const { header, entries, leafId } = migrateSessionLines(lines, file);
+            internSessionImages(entries); // D5：同一图片的 base64 只留一份；JSONL 不变
             return new SessionManager(header, entries, { kind: "file", file, lock }, options.now ?? (() => new Date()), leafId);
         }
         catch (error) {
@@ -93,48 +96,7 @@ export class SessionManager {
     }
     /** 只读列出目录下的会话（最新在前）；损坏的文件跳过。 */
     static list(dir) {
-        const items = [];
-        for (const file of listSessionFiles(dir)) {
-            try {
-                const { header, entries } = migrateSessionLines(readSessionLines(file).lines, file);
-                let name;
-                let firstPrompt;
-                let messageCount = 0;
-                for (const entry of entries) {
-                    if (entry.type === "session_info" && entry.name !== undefined)
-                        name = entry.name;
-                    if (entry.type !== "message" || entry.message.role === "system")
-                        continue;
-                    messageCount++;
-                    if (firstPrompt === undefined && entry.message.role === "user") {
-                        const { content } = entry.message;
-                        firstPrompt =
-                            typeof content === "string"
-                                ? content
-                                : content.map((block) => (block.type === "text" ? block.text : "")).join("");
-                    }
-                }
-                const item = {
-                    id: header.id,
-                    file,
-                    cwd: header.cwd,
-                    createdAt: header.timestamp,
-                    modifiedAt: statSync(file).mtime.toISOString(),
-                    messageCount,
-                };
-                if (name !== undefined)
-                    item.name = name;
-                if (isSubagentSession(header, entries[0]))
-                    item.subagent = true;
-                if (firstPrompt !== undefined)
-                    item.firstPrompt = firstPrompt.slice(0, 200);
-                items.push(item);
-            }
-            catch {
-                // 损坏 / 不可读：列表里跳过（sessions show 会给出具体错误）
-            }
-        }
-        return items;
+        return listSessionItems(dir);
     }
     // -------------------------------------------------------------------------
     // SessionManagerApi
@@ -206,16 +168,27 @@ export class SessionManager {
     setName(name) {
         this.append({ type: "session_info", name });
     }
-    fork(entryId) {
+    fork(entryId, forkOptions = {}) {
         if (!this.index.has(entryId)) {
             throw new AmaError("invalid_arguments", `no such session entry: ${entryId}`);
         }
         const copied = this.branch(entryId).map((entry) => structuredClone(entry));
+        if (forkOptions.head !== undefined) {
+            const head = {
+                ...forkOptions.head,
+                id: newEntryId(indexEntries(copied)),
+                parentId: null,
+                timestamp: this.now().toISOString(),
+            };
+            if (copied[0] !== undefined)
+                copied[0].parentId = head.id;
+            copied.unshift(head);
+        }
         const options = { now: this.now };
         const parentFile = this.file();
         if (parentFile !== undefined)
             options.parentSession = parentFile;
-        const header = SessionManager.newHeader(this.cwd, options, this.now());
+        const header = SessionManager.newHeader(forkOptions.cwd ?? this.cwd, options, this.now());
         let storage;
         if (this.storage.kind === "memory")
             storage = { kind: "memory" };

package/dist/session/migrate.d.ts

@@ -7,7 +7,8 @@
  * - 缺头 / 头损坏 / 条目缺 id → 拒绝，不猜测、不重写文件。
  * - [W3-C1b] `leaf` 行（`/tree` 位置，第三波 A7）不是条目：不进 entries；最后一条 leaf 行若在
  *   最后一条条目之后，作为 `leafId` 返回（之后又追加了条目则作废）。id 须为字符串或 null。
- * 将来格式升级时在这里加「旧版本 → 当前」的内存迁移（文件只追加，不回写）。
+ * 将来格式升级时在这里加「旧版本 → 当前」的内存迁移（文件只追加，不回写）；`list.ts` 不经本函数、
+ * 自己按 v1 规则流式统计，升级格式时要同时改它（docs/memory-plan.md R6）。
  */
 import type { SessionEntry, SessionHeader, SessionLine } from "./types.js";
 export interface MigratedSession {

package/dist/session/migrate.js

@@ -7,7 +7,8 @@
  * - 缺头 / 头损坏 / 条目缺 id → 拒绝，不猜测、不重写文件。
  * - [W3-C1b] `leaf` 行（`/tree` 位置，第三波 A7）不是条目：不进 entries；最后一条 leaf 行若在
  *   最后一条条目之后，作为 `leafId` 返回（之后又追加了条目则作废）。id 须为字符串或 null。
- * 将来格式升级时在这里加「旧版本 → 当前」的内存迁移（文件只追加，不回写）。
+ * 将来格式升级时在这里加「旧版本 → 当前」的内存迁移（文件只追加，不回写）；`list.ts` 不经本函数、
+ * 自己按 v1 规则流式统计，升级格式时要同时改它（docs/memory-plan.md R6）。
  */
 import { AmaError } from "../errors.js";
 import { SESSION_FORMAT_VERSION } from "./types.js";

package/dist/session/projection.d.ts

@@ -5,8 +5,11 @@
  *   `firstKeptEntryId` 到 compaction 之间的非 system 条目，再放 compaction 之后的条目。
  * - `buildProjection(branch)`：对上一步的条目套用 `context_edit`（同一目标在活动分支上最新一条赢；
  *   `null` 剔除，字符串只换内容、保留角色与元数据），并把每个条目映射为 `AgentMessage`。
- *   有 compaction 时，compaction 之前的全部 system 消息折成一条完整的 system 检查点放在最前
- *   （会话条目里不另存检查点，重放即可得到）。
+ *   有 compaction 时（[ME-B] D4「开头只写一次」）：检查点只重放**对话开始前**（首条非 system
+ *   条目之前）的 system 消息，与压缩前请求的开头逐字节相同；此后到 compaction 之间的补丁合并成一条
+ *   合成补丁放在摘要之后，由 normalizeContext 渲染为尾部提醒。合成补丁的 `toolsAdded` 按首次出现
+ *   的顺序、用首次发送的声明，工具表与压缩前一致；多次压缩递归成立（都从原始条目重放）。
+ *   会话条目里不另存检查点与合成补丁，重放即可得到。
  * - `buildContext(branch)`：投影消息 + 路径上最近的模型 / 思考级别选择。
  */
 import type { Message, ModelRef, ModelThinkingLevel, SystemMessage, ToolDecl } from "../ai/types.js";
@@ -42,9 +45,19 @@ export interface SystemState {
     sections: Record<string, string>;
     tools: ToolDecl[];
 }
-/** 依次应用转录里的 system 消息（首条全量，之后是补丁）；没有 system 消息 → undefined。 */
+/**
+ * 依次应用转录里的 system 消息（首条全量，之后是补丁）；没有 system 消息 → undefined。
+ * 工具「保留原位、只换内容」（与 normalizeContext 一致）；同一条里先加后删（`diffSystem` 的补丁两者
+ * 不相交，只有压缩的合成补丁会对同名既加又删：声明过、现已移除）。
+ */
 export declare function replaySystem(messages: Iterable<AgentMessage | Message>): SystemState | undefined;
 /** 把重放结果写成一条完整的 system 消息。 */
 export declare function systemCheckpoint(state: SystemState, timestamp: number): SystemMessage;
+/**
+ * 压缩的合成补丁：`head`（对话开始前的状态）→ 之后全部补丁重放的结果。节按差异给；工具先列对话中
+ * 首次出现的新名字（首次发送的声明，normalizeContext 冻结的就是它），再列内容有更新的（只更新重放
+ * 状态，不改请求工具表）；移除 = 声明过而现在不在。无差异 → undefined。
+ */
+export declare function synthesizeSystemPatch(head: SystemState, later: readonly SystemMessage[], timestamp: number): SystemMessage | undefined;
 export declare function buildProjection(branch: readonly SessionEntry[]): Projection;
 export declare function buildContext(branch: readonly SessionEntry[]): ProjectedContext;

package/dist/session/projection.js

@@ -5,8 +5,11 @@
  *   `firstKeptEntryId` 到 compaction 之间的非 system 条目，再放 compaction 之后的条目。
  * - `buildProjection(branch)`：对上一步的条目套用 `context_edit`（同一目标在活动分支上最新一条赢；
  *   `null` 剔除，字符串只换内容、保留角色与元数据），并把每个条目映射为 `AgentMessage`。
- *   有 compaction 时，compaction 之前的全部 system 消息折成一条完整的 system 检查点放在最前
- *   （会话条目里不另存检查点，重放即可得到）。
+ *   有 compaction 时（[ME-B] D4「开头只写一次」）：检查点只重放**对话开始前**（首条非 system
+ *   条目之前）的 system 消息，与压缩前请求的开头逐字节相同；此后到 compaction 之间的补丁合并成一条
+ *   合成补丁放在摘要之后，由 normalizeContext 渲染为尾部提醒。合成补丁的 `toolsAdded` 按首次出现
+ *   的顺序、用首次发送的声明，工具表与压缩前一致；多次压缩递归成立（都从原始条目重放）。
+ *   会话条目里不另存检查点与合成补丁，重放即可得到。
  * - `buildContext(branch)`：投影消息 + 路径上最近的模型 / 思考级别选择。
  */
 function parseTime(iso) {
@@ -98,7 +101,11 @@ export function applyReplacement(message, text) {
             return message;
     }
 }
-/** 依次应用转录里的 system 消息（首条全量，之后是补丁）；没有 system 消息 → undefined。 */
+/**
+ * 依次应用转录里的 system 消息（首条全量，之后是补丁）；没有 system 消息 → undefined。
+ * 工具「保留原位、只换内容」（与 normalizeContext 一致）；同一条里先加后删（`diffSystem` 的补丁两者
+ * 不相交，只有压缩的合成补丁会对同名既加又删：声明过、现已移除）。
+ */
 export function replaySystem(messages) {
     let found = false;
     const sections = new Map();
@@ -113,12 +120,10 @@ export function replaySystem(messages) {
             else
                 sections.set(name, text);
         }
+        for (const tool of message.toolsAdded ?? [])
+            tools.set(tool.name, tool);
         for (const name of message.toolsRemoved ?? [])
             tools.delete(name);
-        for (const tool of message.toolsAdded ?? []) {
-            tools.delete(tool.name);
-            tools.set(tool.name, tool);
-        }
     }
     if (!found)
         return undefined;
@@ -131,39 +136,101 @@ export function systemCheckpoint(state, timestamp) {
         message.toolsAdded = state.tools.map((tool) => ({ ...tool }));
     return message;
 }
+function sameDecl(a, b) {
+    return (a.description === b.description && JSON.stringify(a.parameters) === JSON.stringify(b.parameters));
+}
+/**
+ * 压缩的合成补丁：`head`（对话开始前的状态）→ 之后全部补丁重放的结果。节按差异给；工具先列对话中
+ * 首次出现的新名字（首次发送的声明，normalizeContext 冻结的就是它），再列内容有更新的（只更新重放
+ * 状态，不改请求工具表）；移除 = 声明过而现在不在。无差异 → undefined。
+ */
+export function synthesizeSystemPatch(head, later, timestamp) {
+    const full = replaySystem([systemCheckpoint(head, timestamp), ...later]) ?? head;
+    const sections = {};
+    for (const [name, text] of Object.entries(full.sections))
+        if (head.sections[name] !== text)
+            sections[name] = text;
+    for (const name of Object.keys(head.sections))
+        if (!(name in full.sections))
+            sections[name] = null;
+    const sent = new Map(head.tools.map((tool) => [tool.name, tool]));
+    const added = [];
+    for (const message of later)
+        for (const tool of message.toolsAdded ?? []) {
+            if (sent.has(tool.name))
+                continue;
+            sent.set(tool.name, tool);
+            added.push(tool);
+        }
+    const now = new Map(full.tools.map((tool) => [tool.name, tool]));
+    for (const [name, tool] of sent) {
+        const current = now.get(name);
+        if (current !== undefined && !sameDecl(current, tool))
+            added.push(current);
+    }
+    const removed = [...sent.keys()].filter((name) => !now.has(name));
+    if (Object.keys(sections).length === 0 && added.length === 0 && removed.length === 0)
+        return undefined;
+    const patch = { role: "system", sections, timestamp };
+    if (added.length > 0)
+        patch.toolsAdded = added.map((tool) => ({ ...tool }));
+    if (removed.length > 0)
+        patch.toolsRemoved = removed;
+    return patch;
+}
 // ---------------------------------------------------------------------------
 // 投影
 // ---------------------------------------------------------------------------
+/** 对话开始：首条进上下文且不是 system 的条目（custom_message 算；custom / usage 等不算）。 */
+function startsConversation(entry) {
+    const message = entryToMessage(entry);
+    return message !== undefined && message.role !== "system";
+}
+function systemMessagesOf(entries) {
+    const out = [];
+    for (const entry of entries)
+        if (entry.type === "message" && entry.message.role === "system")
+            out.push(entry.message);
+    return out;
+}
+/** 压缩之前的 system 状态：开头检查点（对话开始前）+ 合成补丁（之后的全部补丁）。 */
+function compactedSystem(before, timestamp) {
+    let headEnd = before.findIndex(startsConversation);
+    if (headEnd < 0)
+        headEnd = before.length;
+    const head = replaySystem(systemMessagesOf(before.slice(0, headEnd)));
+    const later = systemMessagesOf(before.slice(headEnd));
+    const out = {};
+    if (head !== undefined)
+        out.checkpoint = systemCheckpoint(head, timestamp);
+    if (later.length === 0)
+        return out;
+    const patch = synthesizeSystemPatch(head ?? { sections: {}, tools: [] }, later, timestamp);
+    if (patch !== undefined)
+        out.patch = patch;
+    return out;
+}
 export function buildProjection(branch) {
     const edits = collectContextEdits(branch);
     const at = latestCompactionIndex(branch);
     const compaction = at >= 0 ? branch[at] : undefined;
     const items = [];
-    if (compaction !== undefined) {
-        const before = [];
-        for (const entry of branch.slice(0, at)) {
-            if (entry.type === "message" && entry.message.role === "system")
-                before.push(entry.message);
-        }
-        const state = replaySystem(before);
-        if (state !== undefined) {
-            items.push({
-                entry: compaction,
-                message: systemCheckpoint(state, parseTime(compaction.timestamp)),
-            });
-        }
-    }
+    const system = compaction === undefined
+        ? {}
+        : compactedSystem(branch.slice(0, at), parseTime(compaction.timestamp));
+    if (compaction !== undefined && system.checkpoint !== undefined)
+        items.push({ entry: compaction, message: system.checkpoint });
     for (const entry of buildContextEntries(branch)) {
         let message = entryToMessage(entry);
-        if (message === undefined)
-            continue;
-        const edit = edits.get(entry.id);
-        if (edit !== undefined) {
-            if (edit.replacement === null)
-                continue;
-            message = applyReplacement(message, edit.replacement);
+        if (message !== undefined) {
+            const edit = edits.get(entry.id);
+            if (edit === undefined)
+                items.push({ entry, message });
+            else if (edit.replacement !== null)
+                items.push({ entry, message: applyReplacement(message, edit.replacement) });
         }
-        items.push({ entry, message });
+        if (entry === compaction && system.patch !== undefined)
+            items.push({ entry: compaction, message: system.patch });
     }
     return { items, messages: items.map((item) => item.message), compaction };
 }

package/dist/session/scan.d.ts

@@ -3,7 +3,7 @@
  *
  * 与 store.ts / manager.ts 的区别：这里**从不加锁、不修复、不写文件**——正在运行的会话也能读。
  * - `sessionFilesInScope`：按 cwd（只看它的编码子目录）或全部子目录（跳过 `.trash`）列文件，最新在前；
- * - `forEachLine`：按行回调（不先 split 出整个数组）；
+ * - `forEachLine`：按块读盘、按行回调（不读全文、不 split）；提前返回即停止读盘；
  * - `lineType`：ama 写入的行以 `{"type":"…"` 开头（manager 的 append 把 type 放在第一个键），
  *   据此不解析就能跳过不需要的行；其它程序写的行退回 JSON.parse；
  * - `readSessionReadOnly`：头 + 条目 + 叶子（同 migrate.ts 的规则），末尾半行忽略、中间坏行抛错。
@@ -18,9 +18,9 @@ export declare function sessionFilesInScope(root: string, cwd?: string): string[
 export declare function findSessionFileReadOnly(root: string, id: string, cwd?: string): string;
 /**
  * 逐行回调（不含行尾 `\n` / `\r`，跳过空行）；`last` 表示文件最后一行且没有换行结尾
- * （可能是写入中途的半行）。回调返回 false 提前结束。
+ * （可能是写入中途的半行）。回调返回 false 提前结束——按块读盘（line-reader.ts），停下即不再读。
  */
-export declare function forEachLine(file: string, visit: (line: string, index: number, last: boolean) => boolean | void): void;
+export declare function forEachLine(file: string, visit: (line: string, index: number, last: boolean) => boolean | void, chunkBytes?: number): void;
 /** ama 写的行：不解析就取出 type（与消息的 role，若紧随其后）；不是这种形状时 undefined。 */
 export declare function lineType(line: string): {
     type: string;

package/dist/session/scan.js

@@ -3,14 +3,15 @@
  *
  * 与 store.ts / manager.ts 的区别：这里**从不加锁、不修复、不写文件**——正在运行的会话也能读。
  * - `sessionFilesInScope`：按 cwd（只看它的编码子目录）或全部子目录（跳过 `.trash`）列文件，最新在前；
- * - `forEachLine`：按行回调（不先 split 出整个数组）；
+ * - `forEachLine`：按块读盘、按行回调（不读全文、不 split）；提前返回即停止读盘；
  * - `lineType`：ama 写入的行以 `{"type":"…"` 开头（manager 的 append 把 type 放在第一个键），
  *   据此不解析就能跳过不需要的行；其它程序写的行退回 JSON.parse；
  * - `readSessionReadOnly`：头 + 条目 + 叶子（同 migrate.ts 的规则），末尾半行忽略、中间坏行抛错。
  */
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import { AmaError } from "../errors.js";
+import { forEachLineSync } from "./line-reader.js";
 import { migrateSessionLines } from "./migrate.js";
 import { SESSION_FILE_SUFFIX, TRASH_DIR_NAME, listSessionFiles, sessionDirForCwd, sessionIdFromFileName, } from "./store.js";
 import { msg } from "../i18n/index.js";
@@ -68,26 +69,16 @@ export function findSessionFileReadOnly(root, id, cwd) {
 }
 /**
  * 逐行回调（不含行尾 `\n` / `\r`，跳过空行）；`last` 表示文件最后一行且没有换行结尾
- * （可能是写入中途的半行）。回调返回 false 提前结束。
+ * （可能是写入中途的半行）。回调返回 false 提前结束——按块读盘（line-reader.ts），停下即不再读。
  */
-export function forEachLine(file, visit) {
-    const text = readFileSync(file, "utf8");
-    let start = 0;
+export function forEachLine(file, visit, chunkBytes) {
     let index = 0;
-    while (start < text.length) {
-        let end = text.indexOf("\n", start);
-        const last = end === -1;
-        if (last)
-            end = text.length;
-        let line = text.slice(start, end);
-        if (line.endsWith("\r"))
-            line = line.slice(0, -1);
-        start = end + 1;
+    forEachLineSync(file, (buf, _physical, last) => {
+        const line = buf.toString("utf8");
         if (line.trim() === "")
-            continue;
-        if (visit(line, index++, last) === false)
             return;
-    }
+        return visit(line, index++, last);
+    }, chunkBytes);
 }
 const TYPE_PREFIX = '{"type":"';
 /** ama 写的行：不解析就取出 type（与消息的 role，若紧随其后）；不是这种形状时 undefined。 */

package/dist/session/store.d.ts

@@ -23,8 +23,11 @@ export interface ReadResult {
     /** 末尾半行被截掉时为 true。 */
     repairedTail: boolean;
 }
+/** 空白行（同旧口径 `trim() === ""`）：ASCII 空白直接判定，遇到非 ASCII 字节才解码再 trim。 */
+export declare function isBlankLine(line: Buffer): boolean;
 /**
  * 读并解析 JSONL。`repair: true` 时把末尾半行从文件里截掉（只截最后一行，且只在它无法解析时）。
+ * 按块逐行读（line-reader.ts，docs/memory-plan.md §2.4）：不生成全文字符串与 split 数组。
  */
 export declare function readSessionLines(file: string, options?: {
     repair?: boolean;

package/dist/session/store.js

@@ -10,6 +10,7 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, readSync, rmSync, statSync, truncateSync, writeFileSync, writeSync, } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { AmaError } from "../errors.js";
+import { forEachLineSync } from "./line-reader.js";
 export const SESSION_FILE_SUFFIX = ".jsonl";
 export const TRASH_DIR_NAME = ".trash";
 export const TRASH_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
@@ -33,46 +34,51 @@ export function sessionIdFromFileName(file) {
     const at = stem.indexOf("_");
     return at < 0 ? undefined : stem.slice(at + 1);
 }
+/** 空白行（同旧口径 `trim() === ""`）：ASCII 空白直接判定，遇到非 ASCII 字节才解码再 trim。 */
+export function isBlankLine(line) {
+    for (const byte of line) {
+        if (byte === 0x20 || (byte >= 0x09 && byte <= 0x0d))
+            continue;
+        return byte >= 0x80 && line.toString("utf8").trim() === "";
+    }
+    return true;
+}
 /**
  * 读并解析 JSONL。`repair: true` 时把末尾半行从文件里截掉（只截最后一行，且只在它无法解析时）。
+ * 按块逐行读（line-reader.ts，docs/memory-plan.md §2.4）：不生成全文字符串与 split 数组。
  */
 export function readSessionLines(file, options = {}) {
-    let text;
-    try {
-        text = readFileSync(file, "utf8");
-    }
-    catch (error) {
-        throw new AmaError("session_not_found", `cannot read session file ${file}`, { cause: error });
-    }
-    const rawLines = text.split("\n");
-    const endsWithNewline = text.endsWith("\n");
-    if (endsWithNewline)
-        rawLines.pop();
     const lines = [];
     let repairedTail = false;
-    for (let i = 0; i < rawLines.length; i++) {
-        const raw = (rawLines[i] ?? "").replace(/\r$/, "");
-        if (raw.trim() === "")
-            continue;
-        try {
-            lines.push(JSON.parse(raw));
-        }
-        catch (error) {
-            const isLast = i === rawLines.length - 1;
-            if (isLast && !endsWithNewline) {
-                repairedTail = true;
-                if (options.repair === true) {
-                    const keep = Buffer.byteLength(rawLines.slice(0, i).join("\n"), "utf8") + (i > 0 ? 1 : 0);
-                    truncateSync(file, keep);
+    let unterminated = false;
+    try {
+        forEachLineSync(file, (buf, index, last, offset) => {
+            if (last)
+                unterminated = true;
+            if (isBlankLine(buf))
+                return;
+            try {
+                lines.push(JSON.parse(buf.toString("utf8")));
+            }
+            catch (error) {
+                if (last) {
+                    repairedTail = true;
+                    if (options.repair === true)
+                        truncateSync(file, offset);
+                    return false;
                 }
-                break;
+                throw new AmaError("session_corrupt", `${file}:${index + 1}: invalid JSON line`, {
+                    cause: error,
+                });
             }
-            throw new AmaError("session_corrupt", `${file}:${i + 1}: invalid JSON line`, {
-                cause: error,
-            });
-        }
+        });
+    }
+    catch (error) {
+        if (error instanceof AmaError)
+            throw error;
+        throw new AmaError("session_not_found", `cannot read session file ${file}`, { cause: error });
     }
-    if (!repairedTail && !endsWithNewline && text.length > 0 && options.repair === true) {
+    if (!repairedTail && unterminated && options.repair === true) {
         // 最后一行完整但缺 LF：补上，保证后续追加另起一行。
         appendRaw(file, "\n");
     }

package/dist/session/types.d.ts

@@ -199,7 +199,12 @@ export interface SessionManagerApi {
     getTree(): SessionTreeNode[];
     name(): string | undefined;
     setName(name: string): void;
-    /** 复制 root → entryId 的分支到新文件（parentSession 指回）。 */
-    fork(entryId: string): SessionManagerApi;
+    /**
+     * 复制 root → entryId 的分支到新文件（parentSession 指回）；`head` 作为新根条目，复制的首条重挂到
+     * 它下面（[ME-C0] fork 子会话的 `custom{ama.task}` 标记）。
+     */
+    fork(entryId: string, options?: {
+        head?: SessionEntryInput;
+    }): SessionManagerApi;
 }
 export {};

package/dist/tools/bash.d.ts

@@ -3,7 +3,7 @@
  *
  * - `spawn(shell, args, { detached: !win, stdio: [ignore, pipe, pipe] })`，stdout / stderr 合流；
  * - 超时（缺省 120 s，上限 600 s）与 abort 都走 `killProcessTree`：SIGTERM → 2 s → SIGKILL；
- * - 滚动尾部节流后经 `ctx.onUpdate` 流出；超限（2000 行 / 50 KB）尾截断并落全文；
+ * - 滚动尾部节流后经 `ctx.onUpdate` 流出；超限（2000 行 / 50 KB 与会话结果上限减余量取小）尾截断并落全文；
  * - 结构化结果 `{ output, exit_code, truncated, full_output_path?, wall_time_seconds }`；
  *   信号退出 `128 + signo`；非零退出码 → isError；
  * - 注入 `AMA_*` 环境变量（shell.ts）。shell 退出后不等仍占着管道的后台进程。

package/dist/tools/bash.js

@@ -3,7 +3,7 @@
  *
  * - `spawn(shell, args, { detached: !win, stdio: [ignore, pipe, pipe] })`，stdout / stderr 合流；
  * - 超时（缺省 120 s，上限 600 s）与 abort 都走 `killProcessTree`：SIGTERM → 2 s → SIGKILL；
- * - 滚动尾部节流后经 `ctx.onUpdate` 流出；超限（2000 行 / 50 KB）尾截断并落全文；
+ * - 滚动尾部节流后经 `ctx.onUpdate` 流出；超限（2000 行 / 50 KB 与会话结果上限减余量取小）尾截断并落全文；
  * - 结构化结果 `{ output, exit_code, truncated, full_output_path?, wall_time_seconds }`；
  *   信号退出 `128 + signo`；非零退出码 → isError；
  * - 注入 `AMA_*` 环境变量（shell.ts）。shell 退出后不等仍占着管道的后台进程。
@@ -21,7 +21,7 @@ import { resolvePath } from "./paths.js";
 import { buildShellArgs, buildToolEnv, resolveShell } from "./shell.js";
 import { exitCodeOf, isGroupAlive, killProcessTree, trackProcessGroup, untrackProcessGroup, } from "./process-tree.js";
 import { OutputAccumulator } from "./output-accumulator.js";
-import { formatSize, resolveOutputDir, safeFileName } from "./truncate.js";
+import { formatSize, resolveOutputDir, safeFileName, toolOutputBytes } from "./truncate.js";
 import { jobsForSession } from "./background-jobs.js";
 import { looksLikeSandboxDenial, runsSandboxed, sandboxDenialHint, wrapBashCommand, } from "../sandbox/bash.js";
 export const DEFAULT_BASH_TIMEOUT_MS = 120_000;
@@ -128,6 +128,7 @@ export async function executeBash(input, ctx, options = {}) {
         return startBackground(command, { cwd, env, shell, isWindows, sandbox }, ctx, options);
     const started = Date.now();
     const acc = new OutputAccumulator({
+        maxBytes: toolOutputBytes(ctx.maxResultChars),
         spillPath: () => join(resolveOutputDir(ctx.outputDir), safeFileName(`bash-${ctx.toolCallId}.log`)),
     });
     let child;
@@ -345,8 +346,8 @@ export function createBashTool(options = {}) {
     return {
         name: "bash",
         label: "Bash",
-        description: "Run a shell command; stdout+stderr combined, keeps the last 2000 lines / 50 KB (full " +
-            `output saved). Timeout ${DEFAULT_BASH_TIMEOUT_MS / 1000} s, max ${MAX_BASH_TIMEOUT_MS / 1000} s. ` +
+        description: "Run a shell command; stdout+stderr combined, keeps the tail (full output saved to a " +
+            `file). Timeout ${DEFAULT_BASH_TIMEOUT_MS / 1000} s, max ${MAX_BASH_TIMEOUT_MS / 1000} s. ` +
             "background:true gives a job id for {job, action}." +
             sandboxDescription(options.sandbox),
         parameters: {

package/dist/tools/glob.d.ts

@@ -5,7 +5,7 @@
  * 以 `!` 开头的模式是排除。不含 `/` 的模式匹配**文件名**（任意深度），含 `/` 的匹配相对搜索根的
  * 路径。点文件同样参与匹配（`.git` 由遍历层排除）。Windows 上大小写不敏感。
  *
- * 工具：遍历尊重 `.gitignore` / `.ignore`，按 mtime 倒序，缺省上限 1000。
+ * 工具：遍历尊重 `.gitignore` / `.ignore`，按 mtime 倒序，缺省上限 200（[ME-D] P2-2，原 1000）。
  */
 import type { ToolContext, ToolDefinition, ToolResult } from "./types.js";
 export interface GlobBodyOptions {
@@ -32,7 +32,7 @@ export interface GlobInput {
     path?: string;
     limit?: number;
 }
-export declare const DEFAULT_GLOB_LIMIT = 1000;
+export declare const DEFAULT_GLOB_LIMIT = 200;
 export interface GlobMatchFile {
     abs: string;
     rel: string;

package/dist/tools/glob.js

@@ -5,7 +5,7 @@
  * 以 `!` 开头的模式是排除。不含 `/` 的模式匹配**文件名**（任意深度），含 `/` 的匹配相对搜索根的
  * 路径。点文件同样参与匹配（`.git` 由遍历层排除）。Windows 上大小写不敏感。
  *
- * 工具：遍历尊重 `.gitignore` / `.ignore`，按 mtime 倒序，缺省上限 1000。
+ * 工具：遍历尊重 `.gitignore` / `.ignore`，按 mtime 倒序，缺省上限 200（[ME-D] P2-2，原 1000）。
  */
 import { stat } from "node:fs/promises";
 import { displayPath, resolvePath } from "./paths.js";
@@ -145,7 +145,7 @@ export class GlobMatcher {
         return included && !this.exclude.some((g) => GlobMatcher.hit(g, rel));
     }
 }
-export const DEFAULT_GLOB_LIMIT = 1000;
+export const DEFAULT_GLOB_LIMIT = 200;
 /** 收集匹配文件并按 mtime 倒序（同 mtime 按路径）。 */
 export async function globFiles(root, pattern, signal) {
     const matcher = new GlobMatcher(pattern);

package/dist/tools/grep.js

@@ -13,7 +13,7 @@ import { displayPath, resolvePath } from "./paths.js";
 import { walk } from "./ignore.js";
 import { GlobMatcher } from "./glob.js";
 import { isBinary } from "./read.js";
-import { DEFAULT_MAX_BYTES, truncateHead, truncateLine } from "./truncate.js";
+import { formatSize, toolOutputBytes, truncateHead, truncateLine } from "./truncate.js";
 export const DEFAULT_GREP_LIMIT = 100;
 export const GREP_MAX_FILE_BYTES = 2 * 1024 * 1024;
 export const GREP_CONCURRENCY = 16;
@@ -141,16 +141,14 @@ export async function executeGrep(input, ctx) {
     if (matches === 0)
         return { content: "No matches found", details: { matches: 0, files: 0 } };
     const joined = blocks.join(context > 0 ? "\n--\n" : "\n");
-    const cut = truncateHead(joined, {
-        maxLines: Number.MAX_SAFE_INTEGER,
-        maxBytes: DEFAULT_MAX_BYTES,
-    });
+    const maxBytes = toolOutputBytes(ctx.maxResultChars);
+    const cut = truncateHead(joined, { maxLines: Number.MAX_SAFE_INTEGER, maxBytes });
     let content = cut.content;
     if (limited) {
         content += `\n\n[Stopped at ${limit} matches. Narrow the search or raise limit.]`;
     }
     else if (cut.truncated) {
-        content += "\n\n[Output truncated at 50 KB. Narrow the search.]";
+        content += `\n\n[Output truncated at ${formatSize(maxBytes)}. Narrow the search.]`;
     }
     return {
         content,