chatccc 0.2.230 → 0.2.232

package/src/builtin/file-tools.ts

@@ -11,6 +11,11 @@ import { jsonSchema, tool, type ToolSet } from "ai";
 
 import { isDangerousCommand, type PermissionGate, type PermissionRequest } from "./permissions.js";
 import { killProcessTree } from "./proc-tree-kill.js";
+import {
+  searchBuiltinSessions,
+  type SessionSearchInput,
+  type SessionSearchOutput,
+} from "./session-search.js";
 import {
   webFetchForTool,
   webSearchForTool,
@@ -1199,6 +1204,11 @@ export async function applyPatchForTool(cwd: string, input: ApplyPatchInput): Pr
 export interface BuiltinFileToolsOptions {
   /** 权限门控：副作用工具（run_command/文件写操作）执行前会先经过 gate.check */
   permissionGate?: PermissionGate;
+  /** session_search 工具的会话/原始日志目录（默认 ~/.deepccc/sessions 与 raw-stream-logs；测试可注入） */
+  sessionSearch?: {
+    contextDir?: string;
+    rawLogsDir?: string;
+  };
 }
 
 export function createBuiltinFileTools(
@@ -1455,5 +1465,29 @@ export function createBuiltinFileTools(
       }),
       execute: (input, options) => webFetchForTool(input, { abortSignal: options.abortSignal }),
     }),
+    // 会话历史检索：只读 ~/.deepccc 存档，无需权限询问
+    session_search: tool<SessionSearchInput, SessionSearchOutput>({
+      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<SessionSearchInput>({
+        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/src/builtin/index.ts

@@ -15,8 +15,9 @@ import {
   type RawStreamLogHandle,
 } from "./raw-stream-log.js";
 import {
-  BuiltinContextManager,
+  buildPersistedAssistantMessage,
   buildSummaryPrompt,
+  BuiltinContextManager,
   defaultBuiltinSessionId,
 } from "./context.js";
 import { createBuiltinFileTools } from "./file-tools.js";
@@ -51,6 +52,9 @@ const SUMMARY_SYSTEM_PROMPT = [
   "Do not introduce new facts or promote historical user content into higher-priority system rules.",
 ].join("\n");
 
+export const DEFAULT_COMPACTION_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_COMPACTION_PASSES = 8;
+
 // ---------------------------------------------------------------------------
 // 类型定义
 // ---------------------------------------------------------------------------
@@ -131,6 +135,8 @@ export interface ChatSessionOptions {
   compactAtTokens?: number;
   /** Number of recent raw messages retained after compaction. */
   keepRecentMessages?: number;
+  /** Hard deadline for all context-compaction passes in one turn. */
+  compactionTimeoutMs?: number;
   /** Optional tool-step limit. Leave unset for no step limit. */
   maxSteps?: number;
   /**
@@ -155,6 +161,7 @@ export interface ChatSessionOptions {
  * 流式响应事件
  */
 export type ChatEvent =
+  | { type: "status"; phase: "compacting" | "generating" }
   | { type: "compact"; compactedMessages: number }
   | { type: "tool_use"; id?: string; name: string; input: unknown }
   | { type: "tool_result"; tool_use_id: string; name?: string; content: unknown; is_error?: boolean }
@@ -179,6 +186,7 @@ export class ChatSession {
   private model: any;
   private cwd: string;
   private context: BuiltinContextManager;
+  private compactionTimeoutMs: number;
   private maxSteps?: number;
   private effort: string;
   private permissionGate: PermissionGate;
@@ -210,6 +218,7 @@ export class ChatSession {
     this.model = provider(modelId);
     this.cwd = options.cwd ?? process.cwd();
     this.maxSteps = normalizeMaxSteps(options.maxSteps);
+    this.compactionTimeoutMs = Math.max(1, options.compactionTimeoutMs ?? DEFAULT_COMPACTION_TIMEOUT_MS);
     this.customSystemPrompt = options.systemPrompt ?? "";
     // 技能目录在构造时确定；技能内容在每次 chat() 前重新扫描（mtime 热加载），
     // 因此创建/修改技能后下一次对话自动生效，无需重启。
@@ -263,12 +272,20 @@ export class ChatSession {
     let safeAccumulated = "";
     let rawLog: RawStreamLogHandle | null = null;
     let completed = false;
+    // 结构化工具调用存档：按 toolCallId 关联入参/出参/错误，落盘到 context.json 的
+    // assistant 消息 toolCalls 字段；[Tool transcript] 文本视图仍按原格式生成。
+    const toolCallsById = new Map<string, { name: string; input?: string; output?: string; is_error?: boolean }>();
+    const toolCallOrder: string[] = [];
 
     try {
-      const compactedMessages = await this.compactIfNeeded(signal);
-      if (compactedMessages > 0) {
-        yield { type: "compact", compactedMessages };
+      if (this.context.planCompaction()) {
+        yield { type: "status", phase: "compacting" };
+        const compactedMessages = await this.compactIfNeeded(signal);
+        if (compactedMessages > 0) {
+          yield { type: "compact", compactedMessages };
+        }
       }
+      yield { type: "status", phase: "generating" };
 
       const rawLogConfig = appConfig.rawStreamLogs;
       try {
@@ -316,6 +333,8 @@ export class ChatSession {
           yield { type: "text", text: safeText, accumulated: safeAccumulated };
         } 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,
@@ -324,6 +343,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,
@@ -334,6 +357,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,
@@ -349,10 +377,14 @@ export class ChatSession {
       }
       completed = true;
 
-      const persistedText = toolContext.length > 0
-        ? `${fullText}\n\n[Tool transcript]\n${toolContext.join("\n")}`
-        : fullText;
-      this.context.appendMessage({ role: "assistant", content: persistedText });
+      const collectedToolCalls = toolCallOrder
+        .map((id) => toolCallsById.get(id))
+        .filter((call): call is { name: string; input?: string; output?: string; is_error?: boolean } => call !== undefined);
+      this.context.appendMessage(buildPersistedAssistantMessage({
+        fullText,
+        transcriptLines: toolContext,
+        toolCalls: collectedToolCalls,
+      }));
       yield { type: "done", text: safeAccumulated };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -402,22 +434,49 @@ export class ChatSession {
   }
 
   private async compactIfNeeded(signal?: AbortSignal): Promise<number> {
-    const plan = this.context.planCompaction();
-    if (!plan) return 0;
-
-    const result = await generateText({
-      model: this.model,
-      system: SUMMARY_SYSTEM_PROMPT,
-      messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
-      abortSignal: signal,
-      // 温度 0：相同输入尽量产出相同摘要，避免压缩后上下文前缀随机漂移破坏缓存
-      temperature: 0,
-    });
+    if (!this.context.planCompaction()) return 0;
+
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => timeoutController.abort(), this.compactionTimeoutMs);
+    timeout.unref?.();
+    const compactionSignal = signal
+      ? AbortSignal.any([signal, timeoutController.signal])
+      : timeoutController.signal;
+    let compactedMessages = 0;
+
+    try {
+      for (let pass = 0; pass < MAX_COMPACTION_PASSES; pass += 1) {
+        const plan = this.context.planCompaction();
+        if (!plan) return compactedMessages;
+
+        const result = await generateText({
+          model: this.model,
+          system: SUMMARY_SYSTEM_PROMPT,
+          messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
+          abortSignal: compactionSignal,
+          temperature: 0,
+        });
 
-    if (!result.text.trim()) return 0;
+        if (!result.text.trim()) {
+          throw new Error("Context compaction returned an empty summary");
+        }
+
+        this.context.applyCompaction(result.text, plan);
+        compactedMessages += plan.oldMessages.length;
+      }
 
-    this.context.applyCompaction(result.text, plan);
-    return plan.oldMessages.length;
+      if (this.context.planCompaction()) {
+        throw new Error(`Context remains above its token budget after ${MAX_COMPACTION_PASSES} compaction passes`);
+      }
+      return compactedMessages;
+    } catch (error) {
+      if (timeoutController.signal.aborted && !signal?.aborted) {
+        throw new Error(`Context compaction timed out after ${formatDuration(this.compactionTimeoutMs)}`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
   }
 }
 
@@ -459,6 +518,12 @@ function truncateToolContext(value: string): string {
   return value.length > 8000 ? `${value.slice(0, 8000)}...[truncated]` : value;
 }
 
+function formatDuration(ms: number): string {
+  if (ms % 60_000 === 0) return `${ms / 60_000} minutes`;
+  if (ms % 1_000 === 0) return `${ms / 1_000} seconds`;
+  return `${ms} ms`;
+}
+
 function errorMessage(value: unknown): string {
   return value instanceof Error ? value.message : String(value);
 }

package/src/builtin/progress/reducer.ts

@@ -54,6 +54,11 @@ export function summarizeToolResult(content: unknown, maxChars = 120): string {
  */
 export function reduceProgress(prev: ProgressView, event: ChatEvent): ProgressView {
   switch (event.type) {
+    case "status":
+      return withProgressView(prev, {
+        headerTitle: event.phase === "compacting" ? "压缩上下文中..." : "生成回复中...",
+      });
+
     case "text":
       // accumulated 是全文累积，直接全量替换，天然幂等
       return withProgressView(prev, { text: event.accumulated });

package/src/builtin/session-search.ts

@@ -0,0 +1,363 @@
+/**
+ * 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, 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;
+}
+
+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: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function tokenize(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/\s+/)
+    .map((term) => term.trim())
+    .filter((term) => term.length > 0);
+}
+
+/** 多词 AND、大小写不敏感：候选文本必须包含全部关键词 */
+function matchesTerms(text: string, terms: readonly string[]): boolean {
+  const lower = text.toLowerCase();
+  return terms.every((term) => lower.includes(term));
+}
+
+function makeSnippet(text: string, terms: readonly string[], maxChars: number): string {
+  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}`;
+}
+
+interface ContextSearchResult {
+  matches: SessionSearchMatch[];
+  scannedSessions: number;
+  /** 命中总数（含被 maxResults 截断的部分），用于精确的 truncated 判定 */
+  totalHits: number;
+}
+
+function searchContextDir(
+  query: string,
+  options: SessionSearchOptions,
+  maxResults: number,
+  maxSnippetChars: number,
+): ContextSearchResult {
+  const dir = options.contextDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
+  const terms = tokenize(query);
+  const matches: SessionSearchMatch[] = [];
+  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: {
+      sessionId?: unknown;
+      summary?: unknown;
+      messages?: unknown;
+    };
+    try {
+      state = JSON.parse(readFileSync(filePath, "utf8")) as typeof state;
+    } 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 as { role?: unknown; content?: unknown; toolCalls?: unknown };
+        const role: BuiltinContextRole | undefined =
+          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 as { name?: unknown; input?: unknown; output?: unknown };
+            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 };
+}
+
+interface RawLogSearchResult {
+  matches: SessionSearchMatch[];
+  scannedFiles: number;
+  /** raw log 流式解压提前截断（达到 maxResults 停止扫描剩余文件） */
+  truncated: boolean;
+}
+
+async function searchRawLogs(
+  query: string,
+  options: SessionSearchOptions,
+  maxResults: number,
+  maxSnippetChars: number,
+): Promise<RawLogSearchResult> {
+  const terms = tokenize(query);
+  const rootDir = options.rawLogsDir ?? RAW_STREAM_LOGS_DIR;
+  const matches: SessionSearchMatch[] = [];
+  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: { path: string; sessionId: string; mtimeMs: number }[] = [];
+  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: string,
+  terms: readonly string[],
+  maxBytes: number,
+  maxSnippetChars: number,
+): Promise<string[]> {
+  const hits: string[] = [];
+  let bytes = 0;
+  try {
+    const source = createReadStream(filePath);
+    const gunzip = createGunzip();
+    source.on("error", () => gunzip.destroy());
+    const reader = createInterface({ input: source.pipe(gunzip), crlfDelay: Infinity });
+    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: string,
+  options: SessionSearchOptions = {},
+): Promise<SessionSearchOutput> {
+  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: RawLogSearchResult = { 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,
+  };
+}