@armadra/agent 0.7.2 → 0.7.4

package/dist/session/list.js

@@ -0,0 +1,150 @@
+/**
+ * 会话列表（`SessionManager.list` 的实现）。[M-C] 按块逐行读（docs/memory-plan.md D6、§2.4）：
+ * 只解析头、第一条条目、`leaf` / `session_info` 行、要取 `firstPrompt` 的那一条 user 消息与末行；
+ * 其余 ama 写的行只看行首的 type / role（`lineTypeOf`），不生成全文字符串、不留条目对象。
+ *
+ * 口径与「`migrateSessionLines(readSessionLines(file).lines)` 再统计」一致：空行跳过、末尾半行忽略、
+ * 头必须是 `type: "session"` / `version === SESSION_FORMAT_VERSION` / id 与 cwd 为字符串、`leaf` 行不算
+ * 条目、重复的头与解析失败的中间行让整个文件跳过。差别只有一处：不解析的 ama 行不再逐条检查
+ * `id`（ama 写入的条目总有 id）；行尾不是 `}` 的（写到一半又被追加的坏行）仍会退回完整解析。
+ * 不经 `migrateSessionLines`——格式升到 v2 时要同时改这里（R6，见 migrate.ts）。
+ */
+import { statSync } from "node:fs";
+import { forEachLineSync, lineTypeOf } from "./line-reader.js";
+import { isBlankLine, isSubagentSession, listSessionFiles } from "./store.js";
+import { SESSION_FORMAT_VERSION } from "./types.js";
+class SkipFile extends Error {
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function endsWithBrace(line) {
+    for (let i = line.length - 1; i >= 0; i--) {
+        const byte = line[i];
+        if (byte === 0x20 || (byte >= 0x09 && byte <= 0x0d))
+            continue;
+        return byte === 0x7d;
+    }
+    return false;
+}
+function promptText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .map((block) => (block.type === "text" ? block.text : ""))
+        .join("");
+}
+/** 统计一条已解析的行（头之后）；不合 v1 规则时抛 SkipFile。 */
+function tallyParsed(tally, line) {
+    if (isObject(line) && line["type"] === "leaf") {
+        const id = line["id"];
+        if (id !== null && typeof id !== "string")
+            throw new SkipFile();
+        return;
+    }
+    if (!isObject(line) || typeof line["id"] !== "string" || typeof line["type"] !== "string") {
+        throw new SkipFile();
+    }
+    if (line["type"] === "session")
+        throw new SkipFile();
+    if (!tally.hasFirst) {
+        tally.hasFirst = true;
+        tally.first = line;
+    }
+    if (line["type"] === "session_info" && line["name"] !== undefined) {
+        tally.name = line["name"];
+    }
+    if (line["type"] !== "message")
+        return;
+    const message = line["message"];
+    if (message.role === "system")
+        return;
+    tally.messageCount++;
+    if (tally.firstPrompt === undefined && message.role === "user") {
+        tally.firstPrompt = promptText(message.content);
+    }
+}
+function parseHeader(line) {
+    if (!isObject(line) || line["type"] !== "session")
+        throw new SkipFile();
+    if (line["version"] !== SESSION_FORMAT_VERSION)
+        throw new SkipFile();
+    if (typeof line["id"] !== "string" || typeof line["cwd"] !== "string")
+        throw new SkipFile();
+    return line;
+}
+/** 不解析就能统计的 ama 行：已过第一条条目、类型确定、行尾完整，且不需要读出内容。 */
+function tallyByType(tally, line, firstPromptTaken) {
+    if (!tally.hasFirst || !endsWithBrace(line))
+        return false;
+    const kind = lineTypeOf(line);
+    if (kind === undefined)
+        return false;
+    if (kind.type === "leaf" || kind.type === "session_info" || kind.type === "session")
+        return false;
+    if (kind.type !== "message")
+        return true;
+    if (kind.role === undefined)
+        return false;
+    if (kind.role === "system")
+        return true;
+    if (kind.role === "user" && !firstPromptTaken)
+        return false;
+    tally.messageCount++;
+    return true;
+}
+function tallyFile(file) {
+    const tally = { hasFirst: false, messageCount: 0 };
+    forEachLineSync(file, (buf, _index, last) => {
+        if (isBlankLine(buf))
+            return;
+        if (tally.header !== undefined && !last) {
+            if (tallyByType(tally, buf, tally.firstPrompt !== undefined))
+                return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(buf.toString("utf8"));
+        }
+        catch {
+            if (last)
+                return false; // 末尾半行：与 readSessionLines 一样忽略
+            throw new SkipFile();
+        }
+        if (tally.header === undefined)
+            tally.header = parseHeader(parsed);
+        else
+            tallyParsed(tally, parsed);
+    });
+    return tally;
+}
+/** 只读列出目录下的会话（最新在前）；损坏的文件跳过。 */
+export function listSessionItems(dir) {
+    const items = [];
+    for (const file of listSessionFiles(dir)) {
+        try {
+            const { header, first, name, firstPrompt, messageCount } = tallyFile(file);
+            if (header === undefined)
+                continue;
+            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, first))
+                item.subagent = true;
+            if (firstPrompt !== undefined)
+                item.firstPrompt = firstPrompt.slice(0, 200);
+            items.push(item);
+        }
+        catch {
+            // 损坏 / 不可读：列表里跳过（sessions show 会给出具体错误）
+        }
+    }
+    return items;
+}

package/dist/session/manager.d.ts

@@ -7,8 +7,9 @@
  * - `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 type { SessionEntry, SessionEntryInput, SessionHeader, SessionListItem, SessionManagerApi, SessionTreeNode } from "./types.js";
@@ -59,7 +60,10 @@ export declare class SessionManager implements SessionManagerApi {
     getTree(): SessionTreeNode[];
     name(): string | undefined;
     setName(name: string): void;
-    fork(entryId: string): SessionManager;
+    fork(entryId: string, forkOptions?: {
+        head?: SessionEntryInput;
+        cwd?: string;
+    }): SessionManager;
     /** 延迟会话：建文件、写头与缓存条目、加锁。返回文件路径（内存会话为 undefined）。幂等。 */
     flush(): string | undefined;
     isPersisted(): boolean;

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;