@blogic-cz/agent-tools 0.15.2 → 0.15.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/gh-tool/index.ts

@@ -25,6 +25,7 @@ import {
   prCloseCommand,
   prEditCommand,
   prMergeCommand,
+  prReadyCommand,
   prThreadsCommand,
   prCommentsCommand,
   prIssueCommentsCommand,
@@ -81,6 +82,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prCloseCommand,
     prEditCommand,
     prMergeCommand,
+    prReadyCommand,
     prWaitMergeableCommand,
     prThreadsCommand,
     prCommentsCommand,

package/src/gh-tool/pr/commands.ts

@@ -38,6 +38,7 @@ import {
   fetchFailedChecks,
   listPRs,
   mergePR,
+  readyPR,
   rerunChecks,
   triggerChecks,
   watchPRs,
@@ -644,6 +645,30 @@ export const prMergeCommand = Command.make(
     ),
 ).pipe(Command.withDescription("Merge a PR (dry-run by default, use --confirm to execute)"));
 
+export const prReadyCommand = Command.make(
+  "ready",
+  {
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(
+      Flag.withDescription("PR number (default: current branch PR)"),
+      Flag.optional,
+    ),
+    repo: repoOption,
+  },
+  ({ format, pr, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const result = yield* readyPR({ pr: Option.getOrNull(pr) });
+        yield* logFormatted(result, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Mark a draft PR as ready for review (no-op if it's already ready for review)",
+  ),
+);
+
 export const prChecksCommand = Command.make(
   "checks",
   {

package/src/gh-tool/pr/core.ts

@@ -972,6 +972,23 @@ export const closePR = Effect.fn("pr.closePR")(function* (opts: {
   return yield* viewPR(opts.pr);
 });
 
+export const readyPR = Effect.fn("pr.readyPR")(function* (opts: { pr: number | null }) {
+  const gh = yield* GitHubService;
+
+  const info = yield* viewPR(opts.pr);
+
+  // Idempotent: a PR that's already ready needs no mutation, and `gh pr ready` on a
+  // non-draft PR is a no-op that would just add a pointless call.
+  if (!info.isDraft) {
+    return { ...info, wasAlreadyReady: true };
+  }
+
+  yield* gh.runGh(["pr", "ready", String(info.number)]);
+
+  const updated = yield* viewPR(info.number);
+  return { ...updated, wasAlreadyReady: false };
+});
+
 export const editPR = Effect.fn("pr.editPR")(function* (opts: {
   pr: number;
   title: string | null;

package/src/gh-tool/pr/index.ts

@@ -13,6 +13,7 @@ export {
   prLastHumanReviewerCommand,
   prListCommand,
   prMergeCommand,
+  prReadyCommand,
   prReplyCommand,
   prRerunChecksCommand,
   prReplyAndResolveCommand,

package/src/observability-tool/shared.ts

@@ -67,6 +67,31 @@ async function discoverDatasources(url: string, token?: string): Promise<Grafana
   return (await response.json()) as GrafanaDatasource[];
 }
 
+function findTempoUid(datasources: GrafanaDatasource[]): string | undefined {
+  return (
+    datasources.find((datasource) => datasource.uid === DEFAULT_TEMPO_UID)?.uid ??
+    datasources.find((datasource) => datasource.type === "tempo")?.uid
+  );
+}
+
+/**
+ * Trace commands need a Tempo datasource. Fails with an explicit message instead of
+ * building a request against an undefined datasource UID.
+ */
+export function requireTempoUid(
+  config: ObservabilityEnvConfig,
+): Effect.Effect<string, ObservabilityToolError> {
+  return config.tempoUid
+    ? Effect.succeed(config.tempoUid)
+    : Effect.fail(
+        new ObservabilityToolError({
+          cause: new Error(
+            "No Tempo datasource found on this Grafana instance - trace commands are unavailable (metrics query still works)",
+          ),
+        }),
+      );
+}
+
 async function resolveFromProfile(
   profile: ObservabilityConfig | undefined,
   env: string,
@@ -79,13 +104,9 @@ async function resolveFromProfile(
   const token = resolveToken(environment.tokenEnvVar);
   const datasources = await discoverDatasources(environment.url, token);
 
-  const tempoUid =
-    datasources.find((datasource) => datasource.uid === DEFAULT_TEMPO_UID)?.uid ??
-    datasources.find((datasource) => datasource.type === "tempo")?.uid;
-
-  if (!tempoUid) {
-    throw new Error(`No Tempo datasource found in observability.${env} config`);
-  }
+  // Tempo is optional: metrics/logs work on Grafana instances without it (e.g. Percona PMM).
+  // Trace commands fail later with an explicit message via requireTempoUid().
+  const tempoUid = findTempoUid(datasources);
 
   return {
     url: environment.url,
@@ -146,17 +167,10 @@ export const resolveConfig = (env: string, profile: Option.Option<string>) =>
         const resolved = resolveFromEnv(env);
 
         const datasources = await discoverDatasources(resolved.url, resolved.token);
-        const tempoUid =
-          datasources.find((datasource) => datasource.uid === DEFAULT_TEMPO_UID)?.uid ??
-          datasources.find((datasource) => datasource.type === "tempo")?.uid;
-
-        if (!tempoUid) {
-          throw new Error(`No Tempo datasource found for environment '${env}'`);
-        }
 
         return {
           ...resolved,
-          tempoUid,
+          tempoUid: findTempoUid(datasources),
         } satisfies ObservabilityEnvConfig;
       },
       catch: (cause) => new ObservabilityToolError({ cause }),

package/src/observability-tool/trace.ts

@@ -11,6 +11,7 @@ import {
   observabilityDsQuery,
   observabilityFetch,
   profileOption,
+  requireTempoUid,
   resolveConfig,
 } from "./shared";
 import { extractLogsFromDsQuery } from "./logs";
@@ -232,15 +233,18 @@ function searchTempoBySpanId(
   spanId: string,
   window: SearchWindow,
 ): Effect.Effect<TempoSearchResponse, ObservabilityToolError> {
-  const now = Math.floor(Date.now() / 1000);
-  const startEpoch = relativeToEpoch(window.start, now);
-  const endEpoch = relativeToEpoch(window.end, now);
-  const traceql = encodeURIComponent(`{ span:id = "${spanId}" }`);
-  const searchUrl =
-    `/api/datasources/proxy/uid/${config.tempoUid}/api/search` +
-    `?q=${traceql}&start=${startEpoch}&end=${endEpoch}&limit=5`;
-
-  return observabilityFetch<TempoSearchResponse>(config, searchUrl);
+  return Effect.gen(function* () {
+    const tempoUid = yield* requireTempoUid(config);
+    const now = Math.floor(Date.now() / 1000);
+    const startEpoch = relativeToEpoch(window.start, now);
+    const endEpoch = relativeToEpoch(window.end, now);
+    const traceql = encodeURIComponent(`{ span:id = "${spanId}" }`);
+    const searchUrl =
+      `/api/datasources/proxy/uid/${tempoUid}/api/search` +
+      `?q=${traceql}&start=${startEpoch}&end=${endEpoch}&limit=5`;
+
+    return yield* observabilityFetch<TempoSearchResponse>(config, searchUrl);
+  });
 }
 
 function fetchFullTrace(
@@ -248,9 +252,10 @@ function fetchFullTrace(
   traceId: string,
 ): Effect.Effect<FlattenedSpan[], ObservabilityToolError> {
   return Effect.gen(function* () {
+    const tempoUid = yield* requireTempoUid(config);
     const raw = yield* observabilityFetch<TempoTraceResponse>(
       config,
-      `/api/datasources/proxy/uid/${config.tempoUid}/api/traces/${traceId}`,
+      `/api/datasources/proxy/uid/${tempoUid}/api/traces/${traceId}`,
     );
     return flattenTrace(raw);
   });
@@ -382,7 +387,7 @@ function handleTraceGet(
       data: {
         environment: env,
         grafanaUrl: config.url,
-        tempoDatasourceUid: config.tempoUid,
+        tempoDatasourceUid: config.tempoUid ?? null,
         input: parsed,
         resolution,
         summary: summarizeTrace(resolution.resolvedTraceId, spans),

package/src/observability-tool/types.ts

@@ -5,7 +5,8 @@ export type ObservabilityEnvConfig = {
   token?: string;
   prometheusUid: string;
   lokiUid: string;
-  tempoUid: string;
+  /** Undefined when the Grafana instance has no Tempo datasource (e.g. Percona PMM). */
+  tempoUid?: string;
 };
 
 export type LogLine = {

package/src/session-tool/index.ts

@@ -13,11 +13,18 @@ import { Console, Effect, Layer, Result } from "effect";
 
 import type { MessageSummary, SessionResult, SessionSource } from "./types";
 
+import { ALL_SESSION_SOURCES } from "./types";
+
 import { makeSchemaCommand, formatOption, formatOutput, VERSION } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { ResolvedPaths, ResolvedPathsLayer } from "./config";
 import { SessionStorageNotFoundError } from "./errors";
 import { formatDate, SessionService, SessionServiceLayer, truncate } from "./service";
+import {
+  projectSessionFilter,
+  sessionSummariesFromMessages,
+  sortSessionSummaries,
+} from "./summaries";
 
 const AppLayer = SessionServiceLayer.pipe(Layer.provideMerge(ResolvedPathsLayer));
 
@@ -31,19 +38,8 @@ const filterBySource = (summaries: MessageSummary[], source: string): MessageSum
   return summaries.filter((s) => s.source === (source as SessionSource));
 };
 
-const latestSessionSummaries = (summaries: MessageSummary[]): MessageSummary[] => {
-  const bySession = new Map<string, MessageSummary>();
-
-  for (const summary of summaries) {
-    const key = `${summary.source}:${summary.sessionID}`;
-    const previous = bySession.get(key);
-    if (previous === undefined || summary.created > previous.created) {
-      bySession.set(key, summary);
-    }
-  }
-
-  return [...bySession.values()].toSorted((left, right) => right.created - left.created);
-};
+const sourceSet = (source: string): ReadonlySet<SessionSource> =>
+  source === "all" ? ALL_SESSION_SOURCES : new Set([source as SessionSource]);
 
 const buildScopeLabel = (searchAll: boolean, currentDir: string) => {
   if (searchAll) {
@@ -97,9 +93,19 @@ const listCommand = Command.make(
       const scope = buildScopeLabel(all, currentDir);
 
       const result = yield* Effect.gen(function* () {
-        const sessionFilter = all ? null : yield* sessionService.getSessionsForProject(currentDir);
+        const sources = sourceSet(source);
+        const projectSessions = new Map<SessionSource, Set<string>>();
+        if (!all) {
+          for (const sessionSource of sources) {
+            const matching = yield* sessionService.getSessionsForProject(
+              currentDir,
+              new Set([sessionSource]),
+            );
+            projectSessions.set(sessionSource, matching);
+          }
+        }
 
-        if (sessionFilter !== null && sessionFilter.size === 0) {
+        if (!all && [...projectSessions.values()].every((sessions) => sessions.size === 0)) {
           return {
             success: false,
             error: "No sessions found for current project",
@@ -113,10 +119,28 @@ const listCommand = Command.make(
           } satisfies SessionResult;
         }
 
-        const allSummaries = yield* sessionService.getMessageSummaries(sessionFilter);
-        const summaries = latestSessionSummaries(filterBySource(allSummaries, source));
+        const nonPiSources = [...sources].filter((item) => item !== "pi");
+        const [messagesBySource, piSummaries] = yield* Effect.all([
+          Effect.all(
+            nonPiSources.map((sessionSource) =>
+              sessionService.getMessageSummaries(
+                projectSessionFilter(projectSessions, sessionSource, all),
+                new Set([sessionSource]),
+              ),
+            ),
+          ),
+          sources.has("pi")
+            ? sessionService.getPiSessionSummaries(projectSessionFilter(projectSessions, "pi", all))
+            : Effect.succeed([]),
+        ]);
+        const messages = messagesBySource.flat();
+        const summaries = sortSessionSummaries([
+          ...sessionSummariesFromMessages(messages),
+          ...piSummaries,
+        ]);
         const results = summaries.slice(0, limit).map((summary) => ({
-          created: formatDate(summary.created),
+          createdAt: formatDate(summary.createdAt),
+          updatedAt: formatDate(summary.updatedAt),
           sessionID: summary.sessionID,
           title: summary.title,
           source: summary.source,

package/src/session-tool/pi.ts

@@ -1,9 +1,17 @@
 import { Effect } from "effect";
+// node:fs/promises, not Bun.file/Bun.Glob: vitest runs under Node, where the Bun globals do not
+// exist, and every function below is reached by the suite. See AGENTS.md.
+import { open, readFile, readdir, stat } from "node:fs/promises";
 
-import type { MessageSummary } from "./types";
+import type { MessageSummary, SessionSummary } from "./types";
 
 import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
 
+export const PI_HEADER_MAX_BYTES = 64 * 1024;
+export const PI_SUMMARY_HEAD_MAX_BYTES = 256 * 1024;
+export const PI_SUMMARY_TAIL_MAX_BYTES = 256 * 1024;
+const PI_READ_CONCURRENCY = 16;
+
 export type PiContentBlock =
   | { type: "text"; text: string }
   | { type: string; [key: string]: unknown };
@@ -16,18 +24,33 @@ export type PiRecord =
       message: { role: string; content: string | ReadonlyArray<PiContentBlock> };
     };
 
+export type PiSessionMetadata = SessionSummary & {
+  cwd: string | null;
+  bytesRead: number;
+  parsedLines: number;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null;
 
-export const parsePiLine = (line: string): PiRecord | null => {
-  let parsed: unknown;
+const parseJsonRecord = (line: string): Record<string, unknown> | null => {
   try {
-    parsed = JSON.parse(line);
+    const parsed: unknown = JSON.parse(line);
+    return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
   }
+};
 
-  if (!isRecord(parsed) || typeof parsed.type !== "string") {
+const timestampValue = (value: unknown): number | null => {
+  if (typeof value !== "string") return null;
+  const timestamp = new Date(value).getTime();
+  return Number.isFinite(timestamp) ? timestamp : null;
+};
+
+export const parsePiLine = (line: string): PiRecord | null => {
+  const parsed = parseJsonRecord(line);
+  if (parsed === null || typeof parsed.type !== "string") {
     return null;
   }
 
@@ -89,25 +112,106 @@ export const getPiSessionId = (filePath: string): string => {
 };
 
 const walkSessionFiles = async (basePath: string): Promise<string[]> => {
-  const { Glob } = await import("bun");
-  const glob = new Glob("*/*.jsonl");
-  return Array.fromAsync(glob.scan({ cwd: basePath, absolute: true }));
+  const directories = await readdir(basePath, { withFileTypes: true });
+  const files = await Promise.all(
+    directories
+      .filter((entry) => entry.isDirectory())
+      .map(async (directory) => {
+        const directoryPath = `${basePath}/${directory.name}`;
+        return (await readdir(directoryPath, { withFileTypes: true }))
+          .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+          .map((entry) => `${directoryPath}/${entry.name}`);
+      }),
+  );
+  return files.flat();
 };
 
-const readSessionCwd = async (sessionFile: string): Promise<string | null> => {
+const readSlice = async (filePath: string, start: number, end: number): Promise<string> => {
+  const length = Math.max(0, end - start);
+  if (length === 0) return "";
+  const handle = await open(filePath, "r");
   try {
-    const text = await Bun.file(sessionFile).text();
-    const firstLine = text.split("\n")[0] ?? "";
-    const record = parsePiLine(firstLine);
-    if (record !== null && record.type === "session") {
-      return record.cwd ?? null;
-    }
-    return null;
-  } catch {
-    return null;
+    const buffer = Buffer.allocUnsafe(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
   }
 };
 
+const completeLines = (text: string, startsAtBeginning: boolean, endsAtEnd: boolean): string[] => {
+  const lines = text.split(/\r?\n/u);
+  if (!startsAtBeginning) lines.shift();
+  if (!endsAtEnd && !text.endsWith("\n")) lines.pop();
+  return lines.map((line) => line.trim()).filter((line) => line.length > 0);
+};
+
+const readPiSessionHeader = async (sessionFile: string) => {
+  const { size } = await stat(sessionFile);
+  const end = Math.min(size, PI_HEADER_MAX_BYTES);
+  const text = await readSlice(sessionFile, 0, end);
+  const line = completeLines(text, true, end === size)[0] ?? "";
+  const record = parsePiLine(line);
+  return record?.type === "session" ? record : null;
+};
+
+export const readPiSessionMetadata = async (sessionFile: string): Promise<PiSessionMetadata> => {
+  const file = await stat(sessionFile);
+  const { size } = file;
+  const fullReadLimit = PI_SUMMARY_HEAD_MAX_BYTES + PI_SUMMARY_TAIL_MAX_BYTES;
+  const readWhole = size <= fullReadLimit;
+  const headEnd = readWhole ? size : PI_SUMMARY_HEAD_MAX_BYTES;
+  const tailStart = readWhole ? 0 : Math.max(headEnd, size - PI_SUMMARY_TAIL_MAX_BYTES);
+  const tailReadStart = readWhole ? 0 : Math.max(0, tailStart - 1);
+  const head = await readSlice(sessionFile, 0, headEnd);
+  const tail = readWhole ? head : await readSlice(sessionFile, tailReadStart, size);
+  const headLines = completeLines(head, true, headEnd === size);
+  const tailLines = readWhole ? [] : completeLines(tail, tailReadStart === 0, true);
+  const allLines = [...headLines, ...tailLines];
+  const header = parsePiLine(headLines[0] ?? "");
+  const records = headLines
+    .map(parsePiLine)
+    .filter((record): record is PiRecord => record !== null);
+  const activityTimestamps = allLines
+    .map(parseJsonRecord)
+    .filter((record): record is Record<string, unknown> => record !== null)
+    .filter((record) => record.type !== "session")
+    .map((record) => timestampValue(record.timestamp))
+    .filter((timestamp): timestamp is number => timestamp !== null);
+  const headerTimestamp = header?.type === "session" ? timestampValue(header.timestamp) : null;
+  const createdAt = headerTimestamp ?? activityTimestamps[0] ?? file.mtimeMs;
+  const updatedAt = activityTimestamps.length > 0 ? Math.max(...activityTimestamps) : file.mtimeMs;
+
+  return {
+    sessionID: getPiSessionId(sessionFile),
+    title: extractPiTitle(records),
+    createdAt,
+    updatedAt,
+    source: "pi",
+    cwd: header?.type === "session" ? (header.cwd ?? null) : null,
+    bytesRead: headEnd + (readWhole ? 0 : size - tailReadStart),
+    parsedLines: allLines.length,
+  };
+};
+
+const mapConcurrent = async <T, R>(
+  values: ReadonlyArray<T>,
+  transform: (value: T) => Promise<R | null>,
+): Promise<R[]> => {
+  const results: Array<R | null> = Array.from({ length: values.length }, () => null);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(PI_READ_CONCURRENCY, values.length) }, async () => {
+    while (next < values.length) {
+      const index = next;
+      next += 1;
+      // eslint-disable-next-line no-await-in-loop -- worker loop intentionally caps file-read concurrency
+      results[index] = await transform(values[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results.filter((value): value is R => value !== null);
+};
+
 export const getPiSessions = (
   basePath: string,
   projectDir: string | null,
@@ -119,8 +223,15 @@ export const getPiSessions = (
         return allFiles;
       }
 
-      const cwds = await Promise.all(allFiles.map((file) => readSessionCwd(file)));
-      return allFiles.filter((_, i) => cwds[i] === projectDir);
+      const matching = await mapConcurrent(allFiles, async (file) => {
+        try {
+          const header = await readPiSessionHeader(file);
+          return header?.cwd === projectDir ? file : null;
+        } catch {
+          return null;
+        }
+      });
+      return matching;
     },
     catch: (error) =>
       new SessionStorageNotFoundError({
@@ -129,6 +240,31 @@ export const getPiSessions = (
       }),
   });
 
+export const readPiSessionSummaries = (
+  sessionFiles: string[],
+): Effect.Effect<SessionSummary[], SessionError> =>
+  Effect.tryPromise({
+    try: () =>
+      mapConcurrent(sessionFiles, async (sessionFile) => {
+        try {
+          const {
+            cwd: _cwd,
+            bytesRead: _bytesRead,
+            parsedLines: _parsedLines,
+            ...summary
+          } = await readPiSessionMetadata(sessionFile);
+          return summary;
+        } catch {
+          return null;
+        }
+      }),
+    catch: (error) =>
+      new SessionReadError({
+        message: error instanceof Error ? error.message : "Failed to read pi session summaries",
+        source: "pi",
+      }),
+  });
+
 export const readPiMessages = (
   sessionFiles: string[],
 ): Effect.Effect<MessageSummary[], SessionError> =>
@@ -140,7 +276,7 @@ export const readPiMessages = (
         let fileContent: string;
         try {
           // eslint-disable-next-line eslint/no-await-in-loop -- sequential file read keeps memory bounded
-          fileContent = await Bun.file(sessionFile).text();
+          fileContent = await readFile(sessionFile, "utf8");
         } catch {
           continue;
         }
@@ -175,13 +311,7 @@ export const readPiMessages = (
         }
       }
 
-      return (
-        summaries as MessageSummary[] & {
-          toSorted(
-            compareFn: (left: MessageSummary, right: MessageSummary) => number,
-          ): MessageSummary[];
-        }
-      ).toSorted((left, right) => right.created - left.created);
+      return summaries.toSorted((left, right) => right.created - left.created);
     },
     catch: (error) =>
       new SessionReadError({

package/src/session-tool/service.ts

@@ -1,11 +1,13 @@
 import { Context, Effect, Layer } from "effect";
 import { readdir } from "node:fs/promises";
 
-import type { MessageSummary, SessionInfo, SessionSource } from "./types";
+import type { MessageSummary, SessionInfo, SessionSource, SessionSummary } from "./types";
+
+import { ALL_SESSION_SOURCES } from "./types";
 
 import { getClaudeCodeSessions, readClaudeCodeMessages } from "./claude-code";
 import { getCodexSessions, getCodexSessionId, readCodexMessages } from "./codex";
-import { getPiSessions, getPiSessionId, readPiMessages } from "./pi";
+import { getPiSessions, getPiSessionId, readPiMessages, readPiSessionSummaries } from "./pi";
 import { ResolvedPaths } from "./config";
 import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
 
@@ -42,12 +44,7 @@ type FileEntry = { filePath: string; content: string };
 
 type SourceFilter = ReadonlySet<SessionSource>;
 
-const ALL_SOURCES: SourceFilter = new Set<SessionSource>([
-  "opencode",
-  "claude-code",
-  "codex",
-  "pi",
-]);
+const ALL_SOURCES: SourceFilter = ALL_SESSION_SOURCES;
 const UUID_SOURCES: SourceFilter = new Set<SessionSource>(["claude-code", "codex", "pi"]);
 const OPENCODE_ONLY: SourceFilter = new Set<SessionSource>(["opencode"]);
 
@@ -80,6 +77,16 @@ const detectSourceFilter = (filterSessions: Set<string> | null): SourceFilter =>
   return ALL_SOURCES;
 };
 
+const requestedSourceFilter = (
+  filterSessions: Set<string> | null,
+  requested?: ReadonlySet<SessionSource>,
+): SourceFilter => {
+  const detected = detectSourceFilter(filterSessions);
+  return requested === undefined
+    ? detected
+    : new Set([...detected].filter((source) => requested.has(source)));
+};
+
 /**
  * Reads JSON files from a two-level directory (parent/sub/*.json) using Bun.file().
  * Required for ~100k OpenCode message files where shell-per-file would timeout.
@@ -158,9 +165,14 @@ export class SessionService extends Context.Service<
   {
     readonly getSessionsForProject: (
       projectDir: string | null,
+      sources?: ReadonlySet<SessionSource>,
     ) => Effect.Effect<Set<string>, SessionError>;
+    readonly getPiSessionSummaries: (
+      filterSessions: Set<string> | null,
+    ) => Effect.Effect<SessionSummary[], SessionError>;
     readonly getMessageSummaries: (
       filterSessions: Set<string> | null,
+      sources?: ReadonlySet<SessionSource>,
     ) => Effect.Effect<MessageSummary[], SessionError>;
     readonly searchSummaries: (summaries: MessageSummary[], query: string) => MessageSummary[];
   }
@@ -173,27 +185,33 @@ export class SessionService extends Context.Service<
       return {
         getSessionsForProject: Effect.fn("SessionService.getSessionsForProject")(function* (
           projectDir: string | null,
+          sources?: ReadonlySet<SessionSource>,
         ) {
-          const opencodeSessions = yield* Effect.gen(function* () {
-            const files = yield* readJsonFilesInTree(paths.sessionsPath);
-            const matchingSessions = new Set<string>();
+          const sourceFilter = sources ?? ALL_SOURCES;
+          const opencodeSessions = !sourceFilter.has("opencode")
+            ? new Set<string>()
+            : yield* Effect.gen(function* () {
+                const files = yield* readJsonFilesInTree(paths.sessionsPath);
+                const matchingSessions = new Set<string>();
 
-            for (const { content } of files) {
-              const parsed = parseJson<SessionInfo>(content);
-              if (parsed === null) continue;
+                for (const { content } of files) {
+                  const parsed = parseJson<SessionInfo>(content);
+                  if (parsed === null) continue;
 
-              if (projectDir === null || parsed.directory === projectDir) {
-                matchingSessions.add(parsed.id);
-              }
-            }
+                  if (projectDir === null || parsed.directory === projectDir) {
+                    matchingSessions.add(parsed.id);
+                  }
+                }
 
-            return matchingSessions;
-          }).pipe(
-            Effect.catchTag("SessionStorageNotFoundError", () => Effect.succeed(new Set<string>())),
-          );
+                return matchingSessions;
+              }).pipe(
+                Effect.catchTag("SessionStorageNotFoundError", () =>
+                  Effect.succeed(new Set<string>()),
+                ),
+              );
 
           const claudeSessions =
-            paths.claudeCodePath === null
+            !sourceFilter.has("claude-code") || paths.claudeCodePath === null
               ? new Set<string>()
               : yield* getClaudeCodeSessions(paths.claudeCodePath, projectDir).pipe(
                   Effect.map(
@@ -208,7 +226,7 @@ export class SessionService extends Context.Service<
                 );
 
           const codexSessions =
-            paths.codexPath === null
+            !sourceFilter.has("codex") || paths.codexPath === null
               ? new Set<string>()
               : yield* getCodexSessions(paths.codexPath, projectDir).pipe(
                   Effect.map(
@@ -221,7 +239,7 @@ export class SessionService extends Context.Service<
                 );
 
           const piSessions =
-            paths.piPath === null
+            !sourceFilter.has("pi") || paths.piPath === null
               ? new Set<string>()
               : yield* getPiSessions(paths.piPath, projectDir).pipe(
                   Effect.map(
@@ -246,10 +264,31 @@ export class SessionService extends Context.Service<
           return matchingSessions;
         }),
 
+        getPiSessionSummaries: Effect.fn("SessionService.getPiSessionSummaries")(function* (
+          filterSessions: Set<string> | null,
+        ) {
+          if (paths.piPath === null) return [];
+          return yield* getPiSessions(paths.piPath, null).pipe(
+            Effect.map((sessionFiles) =>
+              filterSessions === null
+                ? sessionFiles
+                : sessionFiles.filter((sessionFile) =>
+                    filterSessions.has(getPiSessionId(sessionFile)),
+                  ),
+            ),
+            Effect.flatMap(readPiSessionSummaries),
+            Effect.catchTags({
+              SessionStorageNotFoundError: () => Effect.succeed([]),
+              SessionReadError: () => Effect.succeed([]),
+            }),
+          );
+        }),
+
         getMessageSummaries: Effect.fn("SessionService.getMessageSummaries")(function* (
           filterSessions: Set<string> | null,
+          sources?: ReadonlySet<SessionSource>,
         ) {
-          const sourceFilter = detectSourceFilter(filterSessions);
+          const sourceFilter = requestedSourceFilter(filterSessions, sources);
 
           const opencodeSummaries = !sourceFilter.has("opencode")
             ? []

package/src/session-tool/summaries.ts

@@ -0,0 +1,42 @@
+import type { MessageSummary, SessionSummary } from "./types";
+
+export const sessionSummariesFromMessages = (summaries: MessageSummary[]): SessionSummary[] => {
+  const bySession = new Map<string, SessionSummary>();
+
+  for (const summary of summaries) {
+    const key = `${summary.source}:${summary.sessionID}`;
+    const previous = bySession.get(key);
+    if (previous === undefined) {
+      bySession.set(key, {
+        sessionID: summary.sessionID,
+        title: summary.title,
+        createdAt: summary.created,
+        updatedAt: summary.created,
+        source: summary.source,
+      });
+      continue;
+    }
+    previous.createdAt = Math.min(previous.createdAt, summary.created);
+    if (summary.created > previous.updatedAt) {
+      previous.updatedAt = summary.created;
+      previous.title = summary.title;
+    }
+  }
+
+  return [...bySession.values()];
+};
+
+export const projectSessionFilter = (
+  sessionsBySource: ReadonlyMap<SessionSummary["source"], Set<string>>,
+  source: SessionSummary["source"],
+  allProjects: boolean,
+): Set<string> | null => (allProjects ? null : (sessionsBySource.get(source) ?? new Set()));
+
+export const sortSessionSummaries = (summaries: SessionSummary[]): SessionSummary[] =>
+  summaries.toSorted(
+    (left, right) =>
+      right.updatedAt - left.updatedAt ||
+      right.createdAt - left.createdAt ||
+      left.source.localeCompare(right.source) ||
+      left.sessionID.localeCompare(right.sessionID),
+  );

package/src/session-tool/types.ts

@@ -10,8 +10,10 @@ export type SessionInfo = {
   projectID: string;
 };
 
-export const SessionSourceLiterals = Schema.Literals(["opencode", "claude-code", "codex", "pi"]);
-export type SessionSource = Schema.Schema.Type<typeof SessionSourceLiterals>;
+export const SESSION_SOURCES = ["opencode", "claude-code", "codex", "pi"] as const;
+export const SessionSourceLiterals = Schema.Literals(SESSION_SOURCES);
+export type SessionSource = (typeof SESSION_SOURCES)[number];
+export const ALL_SESSION_SOURCES: ReadonlySet<SessionSource> = new Set(SESSION_SOURCES);
 
 export type MessageSummary = {
   sessionID: string;
@@ -23,6 +25,14 @@ export type MessageSummary = {
   source: SessionSource;
 };
 
+export type SessionSummary = {
+  sessionID: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  source: SessionSource;
+};
+
 export type SessionResult = {
   success: boolean;
   data?: unknown;