@tonyclaw/agent-inspector 2.1.17 → 2.1.19

package/src/mcp/toolHandlers.ts

@@ -85,6 +85,8 @@ const SearchLogsResponseSchema = z.object({
 const PAGINATION_DEFAULTS = { offset: 0, limit: 3 };
 export const LIMIT_HARD_CAP = 5;
 const LOG_DETAIL_TEXT_LIMIT = 200_000;
+const PROCESS_LOG_LIMIT_DEFAULT = 50;
+const PROCESS_LOG_LIMIT_MAX = 200;
 
 export function clampLimit(input: number | undefined): number {
   if (input === undefined) return PAGINATION_DEFAULTS.limit;
@@ -92,6 +94,12 @@ export function clampLimit(input: number | undefined): number {
   return Math.min(Math.floor(input), LIMIT_HARD_CAP);
 }
 
+function clampProcessLogLimit(input: number | undefined): number {
+  if (input === undefined) return PROCESS_LOG_LIMIT_DEFAULT;
+  if (!Number.isFinite(input) || input < 1) return 1;
+  return Math.min(Math.floor(input), PROCESS_LOG_LIMIT_MAX);
+}
+
 function textJson(data: unknown): ToolResult {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
@@ -147,10 +155,15 @@ function buildBoundedLogDetail(log: CapturedLog): Record<string, unknown> {
   };
 }
 
-export function buildLogSummary(log: CapturedLog) {
-  const hasError =
+function logHasError(log: CapturedLog): boolean {
+  return (
     (log.error !== null && log.error !== undefined && log.error.length > 0) ||
-    (log.responseStatus !== null && log.responseStatus !== undefined && log.responseStatus >= 400);
+    (log.responseStatus !== null && log.responseStatus !== undefined && log.responseStatus >= 400)
+  );
+}
+
+export function buildLogSummary(log: CapturedLog) {
+  const hasError = logHasError(log);
   const rawRequestBodyBytes = log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody);
   const responseTextBytes = log.responseTextBytes ?? textByteLength(log.responseText);
   return {
@@ -190,6 +203,92 @@ export function buildLogSummary(log: CapturedLog) {
   };
 }
 
+function sortedUniqueStrings(values: Array<string | null | undefined>): string[] {
+  return [
+    ...new Set(
+      values.filter(
+        (value): value is string => value !== null && value !== undefined && value !== "",
+      ),
+    ),
+  ].sort((left, right) => left.localeCompare(right));
+}
+
+function sortedUniqueNumbers(values: Array<number | null | undefined>): number[] {
+  return [
+    ...new Set(
+      values.filter(
+        (value): value is number => value !== null && value !== undefined && Number.isFinite(value),
+      ),
+    ),
+  ].sort((left, right) => left - right);
+}
+
+function inferAgentFromUserAgent(userAgent: string | null | undefined): string | null {
+  if (userAgent === null || userAgent === undefined) return null;
+  const lower = userAgent.toLowerCase();
+  if (lower.includes("codex")) return "Codex";
+  if (lower.includes("opencode")) return "OpenCode";
+  if (lower.includes("claude")) return "Claude Code";
+  if (lower.includes("mimocode")) return "MiMoCode";
+  if (lower.includes("ai-sdk")) return "AI SDK";
+  return null;
+}
+
+function processSummary(
+  clientPid: number,
+  logs: readonly CapturedLog[],
+  total: number,
+  limit: number,
+): Record<string, unknown> {
+  const sortedLogs = [...logs].sort((left, right) => left.id - right.id);
+  const first = sortedLogs[0];
+  const last = sortedLogs[sortedLogs.length - 1];
+  const userAgents = sortedUniqueStrings(sortedLogs.map((log) => log.userAgent));
+  const agents = sortedUniqueStrings(userAgents.map(inferAgentFromUserAgent));
+  const sessions = sortedUniqueStrings(sortedLogs.map((log) => log.sessionId));
+  return {
+    clientPid,
+    total,
+    limit,
+    logCount: sortedLogs.length,
+    sessionCount: sessions.length,
+    sessions,
+    agents,
+    userAgents,
+    clientPorts: sortedUniqueNumbers(sortedLogs.map((log) => log.clientPort)),
+    clientCwds: sortedUniqueStrings(sortedLogs.map((log) => log.clientCwd)),
+    clientProjectFolders: sortedUniqueStrings(sortedLogs.map((log) => log.clientProjectFolder)),
+    models: sortedUniqueStrings(sortedLogs.map((log) => log.model)),
+    providers: sortedUniqueStrings(sortedLogs.map((log) => log.providerName)),
+    errorCount: sortedLogs.filter(logHasError).length,
+    startedAt: first?.timestamp ?? null,
+    updatedAt: last?.timestamp ?? null,
+    latestLogs: sortedLogs.slice(-Math.min(10, sortedLogs.length)).reverse().map(buildLogSummary),
+  };
+}
+
+async function readCompactLogsPage(
+  callApi: CallApiFn,
+  params: URLSearchParams,
+): Promise<{ logs: CapturedLog[]; total: number } | ToolResult> {
+  const path = `/api/logs?${params.toString()}`;
+  const res = await callApi(path);
+  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = LogsListResponseSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/logs returned an unparseable logs shape");
+  const logs = parsed.data.logs ?? [];
+  return { logs, total: parsed.data.total ?? logs.length };
+}
+
+function isToolResult(value: unknown): value is ToolResult {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    Object.getOwnPropertyDescriptor(value, "content") !== undefined
+  );
+}
+
 // ===========================================================================
 // Per-tool impls
 // ===========================================================================
@@ -199,6 +298,7 @@ export type ListLogsArgs = {
   limit?: number;
   sessionId?: string;
   model?: string;
+  clientPid?: number;
 };
 
 export async function listLogsImpl(callApi: CallApiFn, args: ListLogsArgs): Promise<ToolResult> {
@@ -215,6 +315,9 @@ export async function listLogsImpl(callApi: CallApiFn, args: ListLogsArgs): Prom
   if (args.model !== undefined && args.model.length > 0) {
     params.set("model", args.model);
   }
+  if (args.clientPid !== undefined) {
+    params.set("clientPid", String(args.clientPid));
+  }
   const res = await callApi(`/api/logs?${params.toString()}`);
   if (!res.ok) return toolError(`GET /api/logs returned ${res.status}`);
   const rawBody: unknown = await res.json();
@@ -231,6 +334,7 @@ export type SearchLogsArgs = {
   scanLimit?: number;
   sessionId?: string;
   model?: string;
+  clientPid?: number;
 };
 
 export async function searchLogsImpl(
@@ -253,6 +357,9 @@ export async function searchLogsImpl(
   if (args.model !== undefined && args.model.length > 0) {
     params.set("model", args.model);
   }
+  if (args.clientPid !== undefined) {
+    params.set("clientPid", String(args.clientPid));
+  }
 
   const res = await callApi(`/api/logs?${params.toString()}`);
   if (!res.ok) return toolError(`GET /api/logs search returned ${res.status}`);
@@ -514,6 +621,276 @@ export async function getSessionTimelineImpl(
   );
 }
 
+export type ListProcessesArgs = {
+  limit?: number;
+  scanLimit?: number;
+};
+
+export async function listProcessesImpl(
+  callApi: CallApiFn,
+  args: ListProcessesArgs = {},
+): Promise<ToolResult> {
+  const scanLimit = clampProcessLogLimit(args.scanLimit ?? args.limit);
+  const params = new URLSearchParams({
+    q: "",
+    offset: "0",
+    limit: String(Math.min(scanLimit, 50)),
+    scanLimit: String(scanLimit),
+  });
+  const res = await callApi(`/api/logs?${params.toString()}`);
+  if (!res.ok) return toolError(`GET /api/logs process scan returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = SearchLogsResponseSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/logs returned an unparseable process scan shape");
+
+  const grouped = new Map<number, CapturedLog[]>();
+  for (const log of parsed.data.logs) {
+    if (log.clientPid === null || log.clientPid === undefined) continue;
+    const existing = grouped.get(log.clientPid) ?? [];
+    existing.push(log);
+    grouped.set(log.clientPid, existing);
+  }
+
+  const processes = [...grouped.entries()]
+    .map(([clientPid, logs]) => processSummary(clientPid, logs, logs.length, logs.length))
+    .sort((left, right) => {
+      const leftUpdated = typeof left["updatedAt"] === "string" ? left["updatedAt"] : "";
+      const rightUpdated = typeof right["updatedAt"] === "string" ? right["updatedAt"] : "";
+      return rightUpdated.localeCompare(leftUpdated);
+    });
+
+  return textJson({
+    scanned: parsed.data.scanned ?? parsed.data.logs.length,
+    processCount: processes.length,
+    processes,
+  });
+}
+
+export type ProcessArgs = {
+  clientPid: number;
+  limit?: number;
+  offset?: number;
+};
+
+export async function getProcessImpl(callApi: CallApiFn, args: ProcessArgs): Promise<ToolResult> {
+  const limit = clampProcessLogLimit(args.limit);
+  const offset = args.offset ?? 0;
+  const params = new URLSearchParams({
+    clientPid: String(args.clientPid),
+    offset: String(offset),
+    limit: String(limit),
+    compact: "1",
+  });
+  const result = await readCompactLogsPage(callApi, params);
+  if (isToolResult(result)) return result;
+  return textJson(processSummary(args.clientPid, result.logs, result.total, limit));
+}
+
+export async function getProcessTimelineImpl(
+  callApi: CallApiFn,
+  args: ProcessArgs,
+): Promise<ToolResult> {
+  const limit = clampTimelineLimit(args.limit);
+  const offset = args.offset ?? 0;
+  const params = new URLSearchParams({
+    clientPid: String(args.clientPid),
+    offset: String(offset),
+    limit: String(limit),
+    compact: "1",
+  });
+  const result = await readCompactLogsPage(callApi, params);
+  if (isToolResult(result)) return result;
+  const sortedLogs = [...result.logs].sort((left, right) => left.id - right.id);
+  return textJson({
+    clientPid: args.clientPid,
+    logCoverage: "bounded",
+    total: result.total,
+    limit,
+    eventCount: sortedLogs.length,
+    requestCount: sortedLogs.length,
+    errorCount: sortedLogs.filter(logHasError).length,
+    startedAt: sortedLogs[0]?.timestamp ?? null,
+    updatedAt: sortedLogs.at(-1)?.timestamp ?? null,
+    sessions: sortedUniqueStrings(sortedLogs.map((log) => log.sessionId)),
+    models: sortedUniqueStrings(sortedLogs.map((log) => log.model)),
+    providers: sortedUniqueStrings(sortedLogs.map((log) => log.providerName)),
+    events: sortedLogs.map((log, index) => ({
+      sequence: index + 1,
+      kind: "request",
+      logId: log.id,
+      ...buildLogSummary(log),
+    })),
+  });
+}
+
+export async function getLogHeadersImpl(callApi: CallApiFn, id: number): Promise<ToolResult> {
+  const res = await callApi(`/api/logs/${id}`);
+  if (!res.ok) return toolError(`GET /api/logs/${id} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = CapturedLogSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError(`GET /api/logs/${id} returned an unparseable CapturedLog`);
+  }
+  const log = parsed.data;
+  return textJson({
+    id: log.id,
+    sessionId: log.sessionId,
+    userAgent: log.userAgent,
+    origin: log.origin,
+    clientPid: log.clientPid ?? null,
+    clientPort: log.clientPort ?? null,
+    clientCwd: log.clientCwd ?? null,
+    clientProjectFolder: log.clientProjectFolder ?? null,
+    apiFormat: log.apiFormat,
+    method: log.method,
+    path: log.path,
+    model: log.model,
+    rawHeaders: log.rawHeaders ?? null,
+    headers: log.headers ?? null,
+    hasRawHeaders: log.rawHeaders !== undefined && Object.keys(log.rawHeaders).length > 0,
+    hasHeaders: log.headers !== undefined && Object.keys(log.headers).length > 0,
+    bodyContentMode: log.bodyContentMode ?? null,
+  });
+}
+
+export async function getRuntimeConfigImpl(callApi: CallApiFn): Promise<ToolResult> {
+  const configRes = await callApi("/api/config");
+  if (!configRes.ok) return toolError(`GET /api/config returned ${configRes.status}`);
+  const statsRes = await callApi("/api/logs?stats=1");
+  if (!statsRes.ok) return toolError(`GET /api/logs?stats=1 returned ${statsRes.status}`);
+  const config: unknown = await configRes.json();
+  const storage: unknown = await statsRes.json();
+  return textJson({
+    config,
+    storage,
+  });
+}
+
+export type DiagnoseCaptureArgs = {
+  id?: number;
+};
+
+export async function diagnoseCaptureImpl(
+  callApi: CallApiFn,
+  args: DiagnoseCaptureArgs = {},
+): Promise<ToolResult> {
+  const runtime = await getRuntimeConfigImpl(callApi);
+  if (runtime.isError === true) return runtime;
+  const runtimeText = runtime.content[0]?.text ?? "{}";
+  const runtimePayload: unknown = JSON.parse(runtimeText);
+  const runtimeRecord = isRecord(runtimePayload) ? runtimePayload : {};
+  const configRecord = isRecord(runtimeRecord["config"]) ? runtimeRecord["config"] : {};
+  const captureMode = stringField(configRecord, "captureMode");
+
+  let log: CapturedLog | null = null;
+  if (args.id !== undefined) {
+    const logRes = await callApi(`/api/logs/${args.id}`);
+    if (!logRes.ok) return toolError(`GET /api/logs/${args.id} returned ${logRes.status}`);
+    const rawLog: unknown = await logRes.json();
+    const parsed = CapturedLogSchema.safeParse(rawLog);
+    if (!parsed.success) return toolError(`GET /api/logs/${args.id} returned an unparseable log`);
+    log = parsed.data;
+  }
+
+  const findings: string[] = [];
+  const recommendations: string[] = [];
+  if (captureMode !== "full") {
+    findings.push(
+      "Runtime captureMode is not full, so request/response bodies and headers may be compacted.",
+    );
+    recommendations.push(
+      "Restart or launch Agent Inspector with full capture mode when header/body evidence is required.",
+    );
+  }
+  if (log !== null) {
+    if (log.rawHeaders === undefined || Object.keys(log.rawHeaders).length === 0) {
+      findings.push(`Log ${String(log.id)} has no rawHeaders stored.`);
+    }
+    if (log.headers === undefined || Object.keys(log.headers).length === 0) {
+      findings.push(`Log ${String(log.id)} has no upstream headers stored.`);
+    }
+    if (log.rawRequestBody === null) {
+      findings.push(`Log ${String(log.id)} does not include rawRequestBody in this response.`);
+    }
+    if (log.bodyContentMode === "compact") {
+      findings.push(`Log ${String(log.id)} is in compact body mode.`);
+      recommendations.push(
+        "Use inspector_get_log_headers for header-only checks and enable full capture for future body inspection.",
+      );
+    }
+  }
+
+  return textJson({
+    captureMode,
+    logId: log?.id ?? null,
+    hasLog: log !== null,
+    findings,
+    recommendations,
+    runtime: runtimeRecord,
+  });
+}
+
+export type AddGroupProcessArgs = {
+  groupId: string;
+  clientPid: number;
+  labelPrefix?: string;
+};
+
+export async function addGroupProcessImpl(
+  callApi: CallApiFn,
+  args: AddGroupProcessArgs,
+): Promise<ToolResult> {
+  const params = new URLSearchParams({
+    clientPid: String(args.clientPid),
+    offset: "0",
+    limit: String(PROCESS_LOG_LIMIT_MAX),
+    compact: "1",
+  });
+  const result = await readCompactLogsPage(callApi, params);
+  if (isToolResult(result)) return result;
+
+  const bySession = new Map<string, CapturedLog[]>();
+  for (const log of result.logs) {
+    if (log.sessionId === null || log.sessionId === "") continue;
+    const existing = bySession.get(log.sessionId) ?? [];
+    existing.push(log);
+    bySession.set(log.sessionId, existing);
+  }
+  if (bySession.size === 0) {
+    return toolError(`No sessions found for clientPid ${String(args.clientPid)}`);
+  }
+
+  let groupResult: ReturnType<typeof addInspectorGroupSession> | null = null;
+  const attached: Array<Record<string, unknown>> = [];
+  for (const [sessionId, logs] of bySession.entries()) {
+    const first = logs[0];
+    const last = logs.at(-1);
+    const userAgent = last?.userAgent ?? first?.userAgent ?? null;
+    const agent = inferAgentFromUserAgent(userAgent);
+    groupResult = addInspectorGroupSession(args.groupId, {
+      sessionId,
+      label: `${args.labelPrefix ?? `PID ${String(args.clientPid)}`} - ${sessionId}`,
+      agent,
+      provider: last?.providerName ?? first?.providerName ?? null,
+      model: last?.model ?? first?.model ?? null,
+      metadata: {
+        clientPid: args.clientPid,
+        processLogCount: logs.length,
+        userAgent: userAgent ?? "",
+      },
+    });
+    if (!groupResult.ok) return toolError(groupResult.message);
+    attached.push({ sessionId, logCount: logs.length, agent, userAgent });
+  }
+
+  if (groupResult === null || !groupResult.ok) return toolError("Group process attach failed");
+  return textJson({
+    group: groupResult.value,
+    clientPid: args.clientPid,
+    attached,
+  });
+}
+
 type EvidenceFileKind = "json" | "markdown" | "html" | "zip";
 
 type EvidenceFileSummary = {

package/src/proxy/logSearch.ts

@@ -10,6 +10,7 @@ export type LogSearchOptions = {
   query: string;
   sessionId?: string;
   model?: string;
+  clientPid?: number;
   offset: number;
   limit: number;
   scanLimit: number;
@@ -93,6 +94,7 @@ export async function searchLogsPage(options: LogSearchOptions): Promise<LogSear
   const firstPage = await listLogsPage({
     sessionId: options.sessionId,
     model: options.model,
+    clientPid: options.clientPid,
     offset: 0,
     limit: 1,
     includeBodies: false,
@@ -101,6 +103,7 @@ export async function searchLogsPage(options: LogSearchOptions): Promise<LogSear
   const scanPage = await listLogsPage({
     sessionId: options.sessionId,
     model: options.model,
+    clientPid: options.clientPid,
     offset: scanOffset,
     limit: scanLimit,
     includeBodies: false,

package/src/proxy/store.ts

@@ -99,6 +99,7 @@ export type ClearPersistedLogsByIdsResult = {
 export type ListLogsPageOptions = {
   sessionId?: string;
   model?: string;
+  clientPid?: number;
   offset: number;
   limit: number;
   includeBodies?: boolean;
@@ -114,6 +115,7 @@ export type ListLogsPageResult = {
 export type ListLogsCursorPageOptions = {
   sessionId?: string;
   model?: string;
+  clientPid?: number;
   limit: number;
   includeBodies?: boolean;
   beforeLogId?: number;
@@ -145,6 +147,7 @@ type LogCursorPageIndex = {
   key: string;
   sessionId?: string;
   model?: string;
+  clientPid?: number;
   ids: number[];
   logsById: Map<number, CapturedLog>;
   entriesById: Map<number, LogIndexEntry>;
@@ -155,17 +158,19 @@ let logCursorPageIndexBuildCount = 0;
 let sessionArchiveQueue: Promise<void> = Promise.resolve();
 
 function cursorPageIndexKey(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
 ): string {
   return JSON.stringify({
     sessionId: options.sessionId ?? null,
     model: options.model ?? null,
+    clientPid: options.clientPid ?? null,
   });
 }
 
 function matchesCursorIndexFilters(log: CapturedLog, index: LogCursorPageIndex): boolean {
   if (index.sessionId !== undefined && getLogSessionId(log) !== index.sessionId) return false;
   if (index.model !== undefined && log.model !== index.model) return false;
+  if (index.clientPid !== undefined && log.clientPid !== index.clientPid) return false;
   return true;
 }
 
@@ -561,17 +566,27 @@ async function scanLogFileForId(filePath: string, id: number): Promise<CapturedL
   return lastMatch;
 }
 
-export function getFilteredLogs(sessionId?: string, model?: string): CapturedLog[] {
+export function getFilteredLogs(
+  sessionId?: string,
+  model?: string,
+  clientPid?: number,
+): CapturedLog[] {
   // Cache maintains insertion order (sorted by ID since logs are added in ID order)
   // Use spread instead of Array.from for slightly better performance
   return [...memoryCache.values()].filter((l) => {
-    return matchesLogFilters(l, sessionId, model);
+    return matchesLogFilters(l, sessionId, model, clientPid);
   });
 }
 
-function matchesLogFilters(log: CapturedLog, sessionId?: string, model?: string): boolean {
+function matchesLogFilters(
+  log: CapturedLog,
+  sessionId?: string,
+  model?: string,
+  clientPid?: number,
+): boolean {
   if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return false;
   if (model !== undefined && log.model !== model) return false;
+  if (clientPid !== undefined && log.clientPid !== clientPid) return false;
   return true;
 }
 
@@ -637,7 +652,11 @@ async function visitArchivedSessionLogs(
 }
 
 function canUseIndexedListPage(options: ListLogsPageOptions): boolean {
-  return options.sessionId === undefined && options.model === undefined;
+  return (
+    options.sessionId === undefined &&
+    options.model === undefined &&
+    options.clientPid === undefined
+  );
 }
 
 function hasUsableIndexOffset(entry: LogIndexEntry): boolean {
@@ -695,7 +714,7 @@ export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLo
   let total = 0;
 
   const visitLog = (log: CapturedLog): void => {
-    if (!matchesLogFilters(log, options.sessionId, options.model)) return;
+    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) return;
 
     if (!seenIds.has(log.id)) {
       seenIds.add(log.id);
@@ -781,16 +800,20 @@ function matchesLogIndexEntryFilters(
   entry: LogIndexEntry,
   sessionId: string | undefined,
   model: string | undefined,
+  clientPid: number | undefined,
 ): boolean {
   if (sessionId !== undefined && entry.sessionId !== sessionId) return false;
   if (model !== undefined && entry.model !== model) return false;
+  if (clientPid !== undefined && entry.summary?.clientPid !== clientPid) return false;
   return true;
 }
 
 async function buildLogCursorPageIndexFromLogIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
   allowRebuild: boolean,
 ): Promise<LogCursorPageIndex | null> {
+  if (options.clientPid !== undefined) return null;
+
   let entries = await listFilteredIndexEntries(options);
   if (entries.length === 0 && allowRebuild) {
     await rebuildIndex();
@@ -804,7 +827,7 @@ async function buildLogCursorPageIndexFromLogIndex(
   }
 
   const matchingEntries = entries.filter((entry) =>
-    matchesLogIndexEntryFilters(entry, options.sessionId, options.model),
+    matchesLogIndexEntryFilters(entry, options.sessionId, options.model, options.clientPid),
   );
 
   if (matchingEntries.some((entry) => !hasLogIndexSummary(entry))) {
@@ -828,7 +851,7 @@ async function buildLogCursorPageIndexFromLogIndex(
 
   const logsById = new Map<number, CapturedLog>();
   for (const log of memoryCache.values()) {
-    if (!matchesLogFilters(log, options.sessionId, options.model)) continue;
+    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) continue;
     idsById.add(log.id);
     logsById.set(log.id, log);
   }
@@ -838,7 +861,7 @@ async function buildLogCursorPageIndexFromLogIndex(
     const archivedLogs = await listArchivedSessionLogs(options.sessionId);
     for (const archivedLog of archivedLogs) {
       const log = normalizeLog(archivedLog);
-      if (!matchesLogFilters(log, options.sessionId, options.model)) continue;
+      if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) continue;
       observeSessionLog(log);
       idsById.add(log.id);
       logsById.set(log.id, log);
@@ -849,6 +872,7 @@ async function buildLogCursorPageIndexFromLogIndex(
     key: cursorPageIndexKey(options),
     sessionId: options.sessionId,
     model: options.model,
+    clientPid: options.clientPid,
     ids: [...idsById].sort((left, right) => left - right),
     logsById,
     entriesById,
@@ -856,7 +880,7 @@ async function buildLogCursorPageIndexFromLogIndex(
 }
 
 async function buildLogCursorPageIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
 ): Promise<LogCursorPageIndex> {
   logCursorPageIndexBuildCount += 1;
   const indexed = await buildLogCursorPageIndexFromLogIndex(options, true);
@@ -866,7 +890,7 @@ async function buildLogCursorPageIndex(
   const logsById = new Map<number, CapturedLog>();
 
   const visitLog = (log: CapturedLog): void => {
-    if (!matchesLogFilters(log, options.sessionId, options.model)) return;
+    if (!matchesLogFilters(log, options.sessionId, options.model, options.clientPid)) return;
     logsById.set(log.id, log);
   };
 
@@ -885,6 +909,7 @@ async function buildLogCursorPageIndex(
     key,
     sessionId: options.sessionId,
     model: options.model,
+    clientPid: options.clientPid,
     ids: [...logsById.keys()].sort((left, right) => left - right),
     logsById,
     entriesById: new Map<number, LogIndexEntry>(),
@@ -892,7 +917,7 @@ async function buildLogCursorPageIndex(
 }
 
 async function getLogCursorPageIndex(
-  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model">,
+  options: Pick<ListLogsCursorPageOptions, "sessionId" | "model" | "clientPid">,
 ): Promise<LogCursorPageIndex> {
   const key = cursorPageIndexKey(options);
   const cached = logCursorPageIndexes.get(key);
@@ -1027,7 +1052,7 @@ async function collectIndexedSessionLogSummaries(sessionId: string): Promise<Ses
 
   const needsMetadataRebuild = entries.some((entry) => !hasLogIndexFilterMetadata(entry));
   const needsSummaryRebuild = entries.some((entry) => {
-    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined)) return false;
+    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined, undefined)) return false;
     return !hasLogIndexSummary(entry);
   });
 
@@ -1038,7 +1063,7 @@ async function collectIndexedSessionLogSummaries(sessionId: string): Promise<Ses
 
   const summaries: SessionLogSummary[] = [];
   for (const entry of entries) {
-    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined)) continue;
+    if (!matchesLogIndexEntryFilters(entry, sessionId, undefined, undefined)) continue;
     if (entry.summary === undefined) continue;
     summaries.push(buildSessionLogSummary(compactLogFromIndexSummary(entry.summary)));
   }