deepccc 0.1.10 → 0.1.12

package/README.md

@@ -219,7 +219,7 @@ echo "运行测试并解释失败原因" | deepccc --stream-json
 
 ## 在 ChatCCC 中使用
 
-**ChatCCC 已内置 deepccc**：ChatCCC 的 "CCC Agent" 工具直接内嵌 deepccc 的代码（`src/builtin/`），以 `permissionMode: "bypass"` 全自动运行，无需单独安装或配置本仓库。
+**ChatCCC 已内置 deepccc**：ChatCCC 的 "CCC Agent" 工具直接内嵌 deepccc 的代码（仓库内 `deepccc-agent/` 子目录），以 `permissionMode: "bypass"` 全自动运行，无需单独安装或配置本仓库。
 
 ChatCCC 是一个把 Claude Code / Codex / Cursor / CCC Agent 聚合到飞书/企微等 IM 消息通道的本地机器人框架，提供会话管理、过程卡片、用量统计与隐私替换等能力。
 
@@ -234,7 +234,7 @@ ChatCCC 是一个把 Claude Code / Codex / Cursor / CCC Agent 聚合到飞书/
 
 这种方式适合已经在 ChatCCC 里协作的场景：ChatCCC 负责会话入口和消息通道，`deepccc` 负责本地编程 Agent 能力，包括读取项目提示词、运行命令、编辑文件和输出流式结果。
 
-如果希望让 ChatCCC 使用本仓库（deepccc-agent）最新的独立版本能力，也可以把 `src/builtin/` 与本仓库 `src/` 同步后构建。
+deepccc 的内核主战场在 ChatCCC 仓库的 `deepccc-agent/` 子目录；本仓库（deepccc-agent）是发布镜像，由 ChatCCC 仓库的 `sync-deepccc.mjs` 目录级同步（多的删、少的补、不同的改），之后 `npm run build && npm publish` 发布独立 `deepccc` 包。
 
 ## 项目提示词自动注入
 

package/bin/deepccc.mjs

@@ -1,26 +1,26 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-
-const require = createRequire(import.meta.url);
-const pkgRoot = dirname(require.resolve("../package.json"));
-const distCli = join(pkgRoot, "dist", "cli.js");
-
-let args;
-if (existsSync(distCli)) {
-  args = [distCli, ...process.argv.slice(2)];
-} else {
-  const tsxCli = require.resolve("tsx/cli");
-  const sourceCli = join(pkgRoot, "src", "cli.ts");
-  args = [tsxCli, sourceCli, ...process.argv.slice(2)];
-}
-
-const result = spawnSync(process.execPath, args, {
-  stdio: "inherit",
-  cwd: process.cwd(),
-  env: process.env,
-});
-
-process.exit(result.status === null ? 1 : result.status);
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const pkgRoot = dirname(require.resolve("../package.json"));
+const distCli = join(pkgRoot, "dist", "cli.js");
+
+let args;
+if (existsSync(distCli)) {
+  args = [distCli, ...process.argv.slice(2)];
+} else {
+  const tsxCli = require.resolve("tsx/cli");
+  const sourceCli = join(pkgRoot, "src", "cli.ts");
+  args = [tsxCli, sourceCli, ...process.argv.slice(2)];
+}
+
+const result = spawnSync(process.execPath, args, {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: process.env,
+});
+
+process.exit(result.status === null ? 1 : result.status);

package/dist/cli.js

@@ -429,6 +429,11 @@ async function runRepl(args) {
             rl.prompt();
             return;
         }
+        if (input === "/sessions") {
+            printSessions();
+            rl.prompt();
+            return;
+        }
         currentAbort = new AbortController();
         const signal = currentAbort.signal;
         // TTY 下用"过程区块"（飞书过程卡片的终端形态）：固定区域原地更新、

package/dist/context.d.ts

@@ -1,7 +1,21 @@
 export type BuiltinContextRole = "user" | "assistant";
+/**
+ * 结构化工具调用存档（与 content 里的 [Tool transcript] 文本互为冗余视图）：
+ * content 文本保持不变供模型消费；toolCalls 数组提供可检索、可回放的结构化数据。
+ */
+export interface BuiltinContextToolCall {
+    name: string;
+    /** 工具入参（JSON 文本，已截断到安全上限） */
+    input?: string;
+    /** 工具出参（JSON 文本或错误消息，已截断到安全上限） */
+    output?: string;
+    is_error?: boolean;
+}
 export interface BuiltinContextMessage {
     role: BuiltinContextRole;
     content: string;
+    /** 可选结构化工具调用记录（assistant 消息专用） */
+    toolCalls?: BuiltinContextToolCall[];
 }
 export interface BuiltinContextState {
     version: 1;
@@ -53,6 +67,21 @@ export declare function latestBuiltinSessionForCwd(cwd: string, contextDir?: str
  */
 export declare function estimateBuiltinContextTokens(summary: string, messages: readonly BuiltinContextMessage[]): number;
 export declare function serializeMessagesForSummary(messages: readonly BuiltinContextMessage[]): string;
+export declare const DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS = 32000;
+export declare const DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24000;
+/**
+ * 构造持久化的 assistant 消息：content 保持既有"正文 + [Tool transcript]"文本格式
+ * （模型上下文行为不变），同时附加结构化 toolCalls 存档（供 session-search 等检索）。
+ */
+export declare function buildPersistedAssistantMessage(params: {
+    fullText: string;
+    /** [Tool transcript] 的文本行（按原始流顺序，含 tool_call / tool_result / tool_error） */
+    transcriptLines: readonly string[];
+    /** 结构化工具调用（按调用顺序）；有则写入消息的 toolCalls 字段 */
+    toolCalls?: readonly BuiltinContextToolCall[];
+    maxAssistantChars?: number;
+    maxTranscriptChars?: number;
+}): BuiltinContextMessage;
 export declare function buildSummaryPrompt(plan: BuiltinCompactionPlan): string;
 export declare class BuiltinContextManager {
     readonly persist: boolean;

package/dist/context.js

@@ -39,7 +39,32 @@ function normalizeMessage(value) {
         return null;
     if (typeof raw.content !== "string")
         return null;
-    return { role: raw.role, content: raw.content };
+    const message = { role: raw.role, content: raw.content };
+    const toolCalls = normalizeToolCalls(raw.toolCalls);
+    if (toolCalls.length > 0)
+        message.toolCalls = toolCalls;
+    return message;
+}
+function normalizeToolCalls(value) {
+    if (!Array.isArray(value))
+        return [];
+    const calls = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const raw = entry;
+        if (typeof raw.name !== "string" || raw.name.length === 0)
+            continue;
+        const call = { name: raw.name };
+        if (typeof raw.input === "string")
+            call.input = raw.input;
+        if (typeof raw.output === "string")
+            call.output = raw.output;
+        if (typeof raw.is_error === "boolean")
+            call.is_error = raw.is_error;
+        calls.push(call);
+    }
+    return calls;
 }
 function emptyState(sessionId, cwd) {
     const now = Date.now();
@@ -153,6 +178,27 @@ function truncateMiddle(value, maxChars, marker) {
     const tailChars = Math.floor(available / 2);
     return `${value.slice(0, headChars)}\n${marker}\n${value.slice(-tailChars)}`;
 }
+export const DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS = 32_000;
+export const DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24_000;
+const ASSISTANT_TRUNCATED_MARKER = "...[assistant response truncated in context]...";
+const TOOL_TRANSCRIPT_TRUNCATED_MARKER = "...[tool transcript truncated]...";
+/**
+ * 构造持久化的 assistant 消息：content 保持既有"正文 + [Tool transcript]"文本格式
+ * （模型上下文行为不变），同时附加结构化 toolCalls 存档（供 session-search 等检索）。
+ */
+export function buildPersistedAssistantMessage(params) {
+    const maxAssistantChars = params.maxAssistantChars ?? DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS;
+    const maxTranscriptChars = params.maxTranscriptChars ?? DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS;
+    const persistedAssistantText = truncateMiddle(params.fullText, maxAssistantChars, ASSISTANT_TRUNCATED_MARKER);
+    const content = params.transcriptLines.length > 0
+        ? `${persistedAssistantText}\n\n[Tool transcript]\n${truncateMiddle(params.transcriptLines.join("\n"), maxTranscriptChars, TOOL_TRANSCRIPT_TRUNCATED_MARKER)}`
+        : persistedAssistantText;
+    const message = { role: "assistant", content };
+    const toolCalls = normalizeToolCalls(params.toolCalls);
+    if (toolCalls.length > 0)
+        message.toolCalls = toolCalls;
+    return message;
+}
 function serializeMessagesForCompaction(messages) {
     const sections = [];
     let remaining = MAX_COMPACTION_SOURCE_CHARS;

package/dist/file-tools.d.ts

@@ -150,5 +150,10 @@ export declare function applyPatchForTool(cwd: string, input: ApplyPatchInput):
 export interface BuiltinFileToolsOptions {
     /** 权限门控：副作用工具（run_command/文件写操作）执行前会先经过 gate.check */
     permissionGate?: PermissionGate;
+    /** session_search 工具的会话/原始日志目录（默认 ~/.deepccc/sessions 与 raw-stream-logs；测试可注入） */
+    sessionSearch?: {
+        contextDir?: string;
+        rawLogsDir?: string;
+    };
 }
 export declare function createBuiltinFileTools(cwd: string, options?: BuiltinFileToolsOptions): ToolSet;

package/dist/file-tools.js

@@ -9,6 +9,7 @@ import { createInterface } from "node:readline";
 import { jsonSchema, tool } from "ai";
 import { isDangerousCommand } from "./permissions.js";
 import { killProcessTree } from "./proc-tree-kill.js";
+import { searchBuiltinSessions, } from "./session-search.js";
 import { webFetchForTool, webSearchForTool, } from "./web-tools.js";
 const MAX_READ_BYTES = 1024 * 1024;
 const MAX_LIST_ENTRIES = 200;
@@ -1181,5 +1182,27 @@ export function createBuiltinFileTools(cwd, options = {}) {
             }),
             execute: (input, options) => webFetchForTool(input, { abortSignal: options.abortSignal }),
         }),
+        // 会话历史检索：只读 ~/.deepccc 存档，无需权限询问
+        session_search: tool({
+            description: "Search DeepCCC session archives by keyword and return matching snippets. Use when you need to recall old user messages, assistant replies, or tool calls from previous sessions. Multiple terms must all appear in the same message (AND, case-insensitive). Set include_raw_logs to also scan gzipped raw stream logs (slower).",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    query: { type: "string", description: "Keywords to search for (space-separated, all must match)." },
+                    session_id: { type: "string", description: "Optional session id to restrict the search to." },
+                    include_raw_logs: { type: "boolean", description: "Also scan gzipped raw stream logs under ~/.deepccc/raw-stream-logs. Default false." },
+                    max_results: { type: "number", description: "Maximum number of matches, capped at 50." },
+                },
+                required: ["query"],
+            }),
+            execute: (input) => searchBuiltinSessions(input.query, {
+                contextDir: options.sessionSearch?.contextDir,
+                rawLogsDir: options.sessionSearch?.rawLogsDir,
+                includeRawLogs: input.include_raw_logs ?? false,
+                sessionId: input.session_id,
+                maxResults: input.max_results,
+            }),
+        }),
     };
 }

package/dist/index.js

@@ -9,7 +9,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { config as appConfig, RAW_STREAM_LOGS_DIR } from "./config.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
-import { BuiltinContextManager, buildSummaryPrompt, defaultBuiltinSessionId, } from "./context.js";
+import { buildPersistedAssistantMessage, buildSummaryPrompt, BuiltinContextManager, defaultBuiltinSessionId, } from "./context.js";
 import { createBuiltinFileTools } from "./file-tools.js";
 import { PermissionGate } from "./permissions.js";
 import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs, } from "./skills.js";
@@ -34,6 +34,20 @@ const SYSTEM_PROMPT = [
     "- Do not treat proxy signals such as names, timestamps, file sizes, line counts, partial samples, or a clean command exit as decisive when a direct check is practical.",
     "- Use definitive language only after the evidence closes the loop. Otherwise state uncertainty, identify the missing evidence, and name the next check.",
     "- Do not repeat checks once decisive evidence exists.",
+    "",
+    "## Survey Before Acting",
+    "- Before diving into any task, first map the landscape at low cost: project instructions, directory layout, routes/APIs, existing tests, and git state.",
+    "- Produce a brief execution plan that includes how you will verify the result, then execute.",
+    "- When evidence contradicts an early assumption, revisit the plan instead of tunneling on one direction.",
+    "",
+    "## Delegated Authority",
+    "- When the user delegates decisions (\"you decide\", \"do it elegantly\", \"up to you\"), act autonomously on implementation details.",
+    "- Only ask about genuine blockers: irreversible actions, security boundaries, credentials, or scope changes.",
+    "- Do not bounce implementation-level multiple-choice questions back to the user after they delegated.",
+    "",
+    "## Pre-Delivery Self-Check",
+    "- Before reporting completion, verify: the change runs, edge cases are covered, assumptions are listed, and anything unverified is explicitly labeled as such.",
+    "- State what was done, how it was verified, and what remains unverified or risky.",
 ].join("\n");
 const SUMMARY_SYSTEM_PROMPT = [
     "You are DeepCCC's context compactor.",
@@ -42,8 +56,6 @@ const SUMMARY_SYSTEM_PROMPT = [
 ].join("\n");
 export const DEFAULT_COMPACTION_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_COMPACTION_PASSES = 8;
-const MAX_PERSISTED_ASSISTANT_TEXT_CHARS = 32_000;
-const MAX_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24_000;
 // ---------------------------------------------------------------------------
 // 类型定义
 // ---------------------------------------------------------------------------
@@ -165,6 +177,10 @@ export class ChatSession {
         let safeAccumulated = "";
         let rawLog = null;
         let completed = false;
+        // 结构化工具调用存档：按 toolCallId 关联入参/出参/错误，落盘到 context.json 的
+        // assistant 消息 toolCalls 字段；[Tool transcript] 文本视图仍按原格式生成。
+        const toolCallsById = new Map();
+        const toolCallOrder = [];
         try {
             if (this.context.planCompaction()) {
                 yield { type: "status", phase: "compacting" };
@@ -220,6 +236,8 @@ export class ChatSession {
                 }
                 else if (part.type === "tool-call") {
                     toolContext.push(`tool_call ${part.toolName}: ${safeJson(part.input)}`);
+                    toolCallsById.set(part.toolCallId, { name: part.toolName, input: safeJson(part.input) });
+                    toolCallOrder.push(part.toolCallId);
                     yield {
                         type: "tool_use",
                         id: part.toolCallId,
@@ -229,6 +247,10 @@ export class ChatSession {
                 }
                 else if (part.type === "tool-result") {
                     toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                    const call = toolCallsById.get(part.toolCallId);
+                    if (call) {
+                        call.output = truncateToolContext(safeJson(part.output));
+                    }
                     yield {
                         type: "tool_result",
                         tool_use_id: part.toolCallId,
@@ -240,6 +262,11 @@ export class ChatSession {
                 else if (part.type === "tool-error") {
                     const message = errorMessage(part.error);
                     toolContext.push(`tool_error ${part.toolName}: ${message}`);
+                    const call = toolCallsById.get(part.toolCallId);
+                    if (call) {
+                        call.output = message;
+                        call.is_error = true;
+                    }
                     yield {
                         type: "tool_result",
                         tool_use_id: part.toolCallId,
@@ -255,11 +282,14 @@ export class ChatSession {
                 }
             }
             completed = true;
-            const persistedAssistantText = truncateMiddle(fullText, MAX_PERSISTED_ASSISTANT_TEXT_CHARS, "...[assistant response truncated in context]...");
-            const persistedText = toolContext.length > 0
-                ? `${persistedAssistantText}\n\n[Tool transcript]\n${truncateMiddle(toolContext.join("\n"), MAX_PERSISTED_TOOL_TRANSCRIPT_CHARS, "...[tool transcript truncated]...")}`
-                : persistedAssistantText;
-            this.context.appendMessage({ role: "assistant", content: persistedText });
+            const collectedToolCalls = toolCallOrder
+                .map((id) => toolCallsById.get(id))
+                .filter((call) => call !== undefined);
+            this.context.appendMessage(buildPersistedAssistantMessage({
+                fullText,
+                transcriptLines: toolContext,
+                toolCalls: collectedToolCalls,
+            }));
             yield { type: "done", text: safeAccumulated };
         }
         catch (err) {
@@ -386,14 +416,6 @@ function safeRawStreamJson(value) {
 function truncateToolContext(value) {
     return value.length > 8000 ? `${value.slice(0, 8000)}...[truncated]` : value;
 }
-function truncateMiddle(value, maxChars, marker) {
-    if (value.length <= maxChars)
-        return value;
-    const available = Math.max(0, maxChars - marker.length - 2);
-    const headChars = Math.ceil(available / 2);
-    const tailChars = Math.floor(available / 2);
-    return `${value.slice(0, headChars)}\n${marker}\n${value.slice(-tailChars)}`;
-}
 function formatDuration(ms) {
     if (ms % 60_000 === 0)
         return `${ms / 60_000} minutes`;

package/dist/session-search.d.ts

@@ -0,0 +1,59 @@
+/**
+ * session-search.ts — DeepCCC 历史会话关键词检索
+ *
+ * 供 agent 通过 session_search 工具按需查找很久以前的原始消息/工具调用：
+ * - 主数据源：~/.deepccc/sessions/<sessionId>/context.json（明文 JSON，含 summary、
+ *   messages.content 与结构化 toolCalls）
+ * - 可选数据源：~/.deepccc/raw-stream-logs/deepccc/<sessionId>/*.jsonl.gz（gzip 原始流，
+ *   逐行解压检索，默认关闭）
+ *
+ * 纯关键词匹配（多词 AND、大小写不敏感），不依赖向量索引。
+ */
+import { type BuiltinContextRole } from "./context.js";
+export interface SessionSearchOptions {
+    /** 会话目录，默认 ~/.deepccc/sessions */
+    contextDir?: string;
+    /** raw-stream-logs 根目录，默认 ~/.deepccc/raw-stream-logs */
+    rawLogsDir?: string;
+    /** 是否搜索 gzip 原始流日志（默认 false，较慢） */
+    includeRawLogs?: boolean;
+    /** 只搜索指定 sessionId（目录名或 state.sessionId 匹配） */
+    sessionId?: string;
+    /** 结果上限（默认 20，上限 50） */
+    maxResults?: number;
+    /** 单条命中片段最大字符数（默认 400） */
+    maxSnippetChars?: number;
+    /** 单个 raw log 文件最多解压检索的字节数（默认 4MB） */
+    maxRawLogBytesPerFile?: number;
+}
+export interface SessionSearchInput {
+    query: string;
+    session_id?: string;
+    include_raw_logs?: boolean;
+    max_results?: number;
+}
+export interface SessionSearchMatch {
+    sessionId: string;
+    source: "context" | "summary" | "raw-log";
+    role?: BuiltinContextRole;
+    /** 在 messages 数组中的下标 */
+    messageIndex?: number;
+    /** 在 message.toolCalls 数组中的下标（仅结构化工具调用命中时） */
+    toolCallIndex?: number;
+    toolCallName?: string;
+    snippet: string;
+    filePath: string;
+}
+export interface SessionSearchOutput {
+    query: string;
+    terms: string[];
+    matches: SessionSearchMatch[];
+    truncated: boolean;
+    scannedSessions: number;
+    scannedRawLogFiles: number;
+}
+/**
+ * 关键词检索历史会话存档。context.json 为同步扫描；raw-stream-logs 为
+ * gzip 逐行解压（异步，仅 options.includeRawLogs 时启用）。
+ */
+export declare function searchBuiltinSessions(query: string, options?: SessionSearchOptions): Promise<SessionSearchOutput>;

package/dist/session-search.js

@@ -0,0 +1,276 @@
+/**
+ * session-search.ts — DeepCCC 历史会话关键词检索
+ *
+ * 供 agent 通过 session_search 工具按需查找很久以前的原始消息/工具调用：
+ * - 主数据源：~/.deepccc/sessions/<sessionId>/context.json（明文 JSON，含 summary、
+ *   messages.content 与结构化 toolCalls）
+ * - 可选数据源：~/.deepccc/raw-stream-logs/deepccc/<sessionId>/*.jsonl.gz（gzip 原始流，
+ *   逐行解压检索，默认关闭）
+ *
+ * 纯关键词匹配（多词 AND、大小写不敏感），不依赖向量索引。
+ */
+import { createReadStream, existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { createGunzip } from "node:zlib";
+import { RAW_STREAM_LOGS_DIR } from "./config.js";
+import { DEFAULT_BUILTIN_CONTEXT_DIR } from "./context.js";
+const DEFAULT_MAX_RESULTS = 20;
+const MAX_RESULTS_CAP = 50;
+const DEFAULT_MAX_SNIPPET_CHARS = 400;
+const MAX_SNIPPET_CHARS_CAP = 2_000;
+const DEFAULT_MAX_RAW_LOG_BYTES_PER_FILE = 4 * 1024 * 1024;
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function tokenize(query) {
+    return query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((term) => term.trim())
+        .filter((term) => term.length > 0);
+}
+/** 多词 AND、大小写不敏感：候选文本必须包含全部关键词 */
+function matchesTerms(text, terms) {
+    const lower = text.toLowerCase();
+    return terms.every((term) => lower.includes(term));
+}
+function makeSnippet(text, terms, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const lower = text.toLowerCase();
+    let hitIndex = -1;
+    for (const term of terms) {
+        const index = lower.indexOf(term);
+        if (index !== -1) {
+            hitIndex = index;
+            break;
+        }
+    }
+    const half = Math.floor(maxChars / 2);
+    if (hitIndex === -1) {
+        return `${text.slice(0, half)}…${text.slice(-half)}`;
+    }
+    const start = Math.max(0, hitIndex - half);
+    const end = Math.min(text.length, hitIndex + half);
+    const prefix = start > 0 ? "…" : "";
+    const suffix = end < text.length ? "…" : "";
+    return `${prefix}${text.slice(start, end)}${suffix}`;
+}
+function searchContextDir(query, options, maxResults, maxSnippetChars) {
+    const dir = options.contextDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
+    const terms = tokenize(query);
+    const matches = [];
+    if (terms.length === 0 || !existsSync(dir)) {
+        return { matches, scannedSessions: 0, totalHits: 0 };
+    }
+    const restrictTo = options.sessionId?.trim();
+    let scannedSessions = 0;
+    let totalHits = 0;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        if (restrictTo && entry.name !== restrictTo)
+            continue;
+        const filePath = join(dir, entry.name, "context.json");
+        if (!existsSync(filePath))
+            continue;
+        let state;
+        try {
+            state = JSON.parse(readFileSync(filePath, "utf8"));
+        }
+        catch {
+            continue; // 损坏或非 JSON 的会话文件跳过
+        }
+        if (!state || typeof state !== "object")
+            continue;
+        if (restrictTo && state.sessionId !== restrictTo && entry.name !== restrictTo)
+            continue;
+        scannedSessions += 1;
+        const sessionId = typeof state.sessionId === "string" ? state.sessionId : entry.name;
+        if (typeof state.summary === "string" && matchesTerms(state.summary, terms)) {
+            totalHits += 1;
+            matches.push({
+                sessionId,
+                source: "summary",
+                snippet: makeSnippet(state.summary, terms, maxSnippetChars),
+                filePath,
+            });
+        }
+        if (Array.isArray(state.messages)) {
+            state.messages.forEach((message, messageIndex) => {
+                if (!message || typeof message !== "object")
+                    return;
+                const raw = message;
+                const role = raw.role === "user" || raw.role === "assistant" ? raw.role : undefined;
+                if (typeof raw.content === "string" && matchesTerms(raw.content, terms)) {
+                    totalHits += 1;
+                    matches.push({
+                        sessionId,
+                        source: "context",
+                        role,
+                        messageIndex,
+                        snippet: makeSnippet(raw.content, terms, maxSnippetChars),
+                        filePath,
+                    });
+                }
+                if (Array.isArray(raw.toolCalls)) {
+                    raw.toolCalls.forEach((call, toolCallIndex) => {
+                        if (!call || typeof call !== "object")
+                            return;
+                        const callRaw = call;
+                        const name = typeof callRaw.name === "string" ? callRaw.name : "";
+                        const input = typeof callRaw.input === "string" ? callRaw.input : "";
+                        const output = typeof callRaw.output === "string" ? callRaw.output : "";
+                        if (name.length === 0 && input.length === 0 && output.length === 0)
+                            return;
+                        const haystack = [name, input, output].join("\n");
+                        if (!matchesTerms(haystack, terms))
+                            return;
+                        totalHits += 1;
+                        const source = output || input || name;
+                        matches.push({
+                            sessionId,
+                            source: "context",
+                            role,
+                            messageIndex,
+                            toolCallIndex,
+                            toolCallName: name,
+                            snippet: makeSnippet(source, terms, maxSnippetChars),
+                            filePath,
+                        });
+                    });
+                }
+            });
+        }
+    }
+    return { matches: matches.slice(0, maxResults), scannedSessions, totalHits };
+}
+async function searchRawLogs(query, options, maxResults, maxSnippetChars) {
+    const terms = tokenize(query);
+    const rootDir = options.rawLogsDir ?? RAW_STREAM_LOGS_DIR;
+    const matches = [];
+    if (terms.length === 0 || !existsSync(rootDir)) {
+        return { matches, scannedFiles: 0, truncated: false };
+    }
+    const toolRoot = join(rootDir, "deepccc");
+    if (!existsSync(toolRoot))
+        return { matches, scannedFiles: 0, truncated: false };
+    const restrictTo = options.sessionId?.trim();
+    const maxBytesPerFile = Math.max(0, options.maxRawLogBytesPerFile ?? DEFAULT_MAX_RAW_LOG_BYTES_PER_FILE);
+    // 收集所有 .jsonl.gz 文件，按 mtime 新→旧排序（最新轮次优先）
+    const files = [];
+    for (const sessionEntry of readdirSync(toolRoot, { withFileTypes: true })) {
+        if (!sessionEntry.isDirectory())
+            continue;
+        if (restrictTo && sessionEntry.name !== restrictTo)
+            continue;
+        const sessionDir = join(toolRoot, sessionEntry.name);
+        let entries;
+        try {
+            entries = readdirSync(sessionDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const fileEntry of entries) {
+            if (!fileEntry.isFile() || !fileEntry.name.endsWith(".jsonl.gz"))
+                continue;
+            const filePath = join(sessionDir, fileEntry.name);
+            try {
+                const info = statSync(filePath);
+                files.push({ path: filePath, sessionId: sessionEntry.name, mtimeMs: info.mtimeMs });
+            }
+            catch {
+                // 无法 stat 的文件跳过
+            }
+        }
+    }
+    files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let scannedFiles = 0;
+    let truncated = false;
+    for (const file of files) {
+        if (matches.length >= maxResults) {
+            truncated = true;
+            break;
+        }
+        scannedFiles += 1;
+        const snippets = await searchGzipFileLines(file.path, terms, maxBytesPerFile, maxSnippetChars);
+        for (const snippet of snippets) {
+            matches.push({
+                sessionId: file.sessionId,
+                source: "raw-log",
+                snippet,
+                filePath: file.path,
+            });
+            if (matches.length >= maxResults)
+                break;
+        }
+    }
+    return { matches: matches.slice(0, maxResults), scannedFiles, truncated };
+}
+async function searchGzipFileLines(filePath, terms, maxBytes, maxSnippetChars) {
+    const hits = [];
+    let bytes = 0;
+    try {
+        const source = createReadStream(filePath);
+        const gunzip = createGunzip();
+        // 防崩溃（线上事故）：截断/损坏的 gzip 会在 zlib 层 emit 'error'（如
+        // "unexpected end of file"）。若无人监听，错误事件会升级为 uncaughtException
+        // 直接杀死整个服务（崩溃黑匣子 exit(1)）。显式挂监听把错误降级为
+        // “跳过该文件”：destroy 流让 for await 正常结束，不再冒泡。
+        source.on("error", () => gunzip.destroy());
+        gunzip.on("error", () => gunzip.destroy());
+        const reader = createInterface({ input: source.pipe(gunzip), crlfDelay: Infinity });
+        // readline 会把 input 流的 error 转发到自己身上，同样需要监听避免冒泡
+        reader.on("error", () => { });
+        for await (const line of reader) {
+            bytes += Buffer.byteLength(line, "utf-8");
+            if (bytes > maxBytes)
+                break;
+            if (!matchesTerms(line, terms))
+                continue;
+            hits.push(makeSnippet(line, terms, maxSnippetChars));
+            if (hits.length >= 50)
+                break;
+        }
+    }
+    catch {
+        // 损坏的 gzip 文件按 best-effort 跳过
+    }
+    return hits;
+}
+/**
+ * 关键词检索历史会话存档。context.json 为同步扫描；raw-stream-logs 为
+ * gzip 逐行解压（异步，仅 options.includeRawLogs 时启用）。
+ */
+export async function searchBuiltinSessions(query, options = {}) {
+    const terms = tokenize(query);
+    const maxResults = clamp(options.maxResults ?? DEFAULT_MAX_RESULTS, 1, MAX_RESULTS_CAP);
+    const maxSnippetChars = clamp(options.maxSnippetChars ?? DEFAULT_MAX_SNIPPET_CHARS, 80, MAX_SNIPPET_CHARS_CAP);
+    if (terms.length === 0) {
+        return {
+            query,
+            terms,
+            matches: [],
+            truncated: false,
+            scannedSessions: 0,
+            scannedRawLogFiles: 0,
+        };
+    }
+    const contextResult = searchContextDir(query, options, maxResults, maxSnippetChars);
+    let rawResult = { matches: [], scannedFiles: 0, truncated: false };
+    if (options.includeRawLogs) {
+        rawResult = await searchRawLogs(query, options, maxResults, maxSnippetChars);
+    }
+    const matches = [...contextResult.matches, ...rawResult.matches].slice(0, maxResults);
+    const truncated = contextResult.totalHits > maxResults || rawResult.truncated || rawResult.matches.length > maxResults;
+    return {
+        query,
+        terms,
+        matches,
+        truncated,
+        scannedSessions: contextResult.scannedSessions,
+        scannedRawLogFiles: rawResult.scannedFiles,
+    };
+}

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "deepccc",
-  "version": "0.1.10",
-  "description": "A lightweight DeepSeek-optimized coding agent with OpenAI-compatible model support.",
-  "license": "Apache-2.0",
-  "keywords": [
-    "agent",
-    "deepseek",
-    "coding-agent",
-    "openai-compatible",
-    "cli"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/wzj998/deepccc-agent.git"
-  },
-  "bugs": {
-    "url": "https://github.com/wzj998/deepccc-agent/issues"
-  },
-  "homepage": "https://github.com/wzj998/deepccc-agent#readme",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "bin": {
-    "deepccc": "bin/deepccc.mjs"
-  },
-  "files": [
-    "dist/",
-    "bin/",
-    "docs/",
-    "package.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "node node_modules/typescript/bin/tsc -p tsconfig.build.json",
-    "prepack": "node node_modules/typescript/bin/tsc -p tsconfig.build.json",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "node node_modules/typescript/bin/tsc --noEmit"
-  },
-  "dependencies": {
-    "@ai-sdk/openai-compatible": "^2.0.47",
-    "@vscode/ripgrep": "^1.18.0",
-    "ai": "^6.0.184"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "deepccc",
+  "version": "0.1.12",
+  "description": "A lightweight DeepSeek-optimized coding agent with OpenAI-compatible model support.",
+  "license": "Apache-2.0",
+  "keywords": [
+    "agent",
+    "deepseek",
+    "coding-agent",
+    "openai-compatible",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wzj998/deepccc-agent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wzj998/deepccc-agent/issues"
+  },
+  "homepage": "https://github.com/wzj998/deepccc-agent#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "deepccc": "bin/deepccc.mjs"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "docs/",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.build.json",
+    "prepack": "node node_modules/typescript/bin/tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "node node_modules/typescript/bin/tsc --noEmit"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@vscode/ripgrep": "^1.18.0",
+    "ai": "^6.0.184"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}