@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/dist/harnesses/pi/PiSessionLocator.js

@@ -0,0 +1,212 @@
+import * as path from "path";
+import { matchProcessesToSessions } from "../../utils/matching.js";
+import { MATCH_TOLERANCE_MS } from "../../utils/matchingConstants.js";
+import { isDirectory, isSafePathSegment, listJsonl, safeReaddir, safeStat } from "../../utils/session.js";
+import { PI_SESSION_HEAD_MAX_BYTES, PiSessionParser } from "./PiSessionParser.js";
+import { homeDir } from "../shared.js";
+/** Pi session file names start with their creation time: `2026-06-10T08-58-20-754Z_<id>.jsonl`. */ const FILE_NAME_TIMESTAMP = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z_/;
+/**
+ * Finds Pi session files for running processes that the registry and the
+ * sessions.json tracker could not resolve.
+ *
+ * Live discovery is scoped so its cost follows live agents, not Pi history:
+ * - only the project dir Pi derives from each process cwd is listed;
+ * - only files created within MATCH_TOLERANCE_MS (the matcher's tolerance) of a
+ *   process start are opened,
+ *   and only their head (<= 64 KiB) is read for session id and cwd;
+ * - heads are cached per file (dev/ino/size) across calls on one instance;
+ * - a project dir whose scan matched none of its processes is skipped until
+ *   its mtime changes (a session file was added or removed) or a process it
+ *   has not seen needs it.
+ *
+ * Reuse one instance across refreshes to benefit from the caches.
+ */ export class PiSessionLocator {
+    parser;
+    sessionsDir;
+    heads = new Map();
+    noMatchDirs = new Map();
+    generation = 0;
+    constructor(options = {}, parser = new PiSessionParser()){
+        this.parser = parser;
+        this.sessionsDir = options.sessionsDir ?? path.join(homeDir(), ".pi", "agent", "sessions");
+    }
+    matchRunningProcesses(processes) {
+        this.generation++;
+        try {
+            if (processes.length === 0) return {
+                legacyMatches: [],
+                fallback: []
+            };
+            const scans = this.groupByProjectDir(processes, true);
+            const sessions = this.discoverSessionsInDirs(scans);
+            if (sessions.length === 0) {
+                this.rememberUnmatchedDirs(scans, []);
+                return {
+                    legacyMatches: [],
+                    fallback: processes
+                };
+            }
+            const legacyMatches = matchProcessesToSessions(processes, sessions);
+            this.rememberUnmatchedDirs(scans, legacyMatches);
+            return {
+                legacyMatches,
+                fallback: processes
+            };
+        } finally{
+            this.pruneHeads();
+        }
+    }
+    /**
+   * Session files that could match `processes`: files in each process's
+   * project dir created within the start-time window, with session id and
+   * cwd taken from a bounded head read.
+   */ discoverLiveSessions(processes = []) {
+        return this.discoverSessionsInDirs(this.groupByProjectDir(processes, false));
+    }
+    discoverHistoricalSessionFiles() {
+        return this.collectJsonlFiles(this.sessionsDir);
+    }
+    findHistoricalSessionFilesById(sessionId) {
+        if (!isSafePathSegment(sessionId)) return [];
+        return this.collectJsonlFiles(this.sessionsDir).filter((filePath)=>{
+            const basename = path.basename(filePath, ".jsonl");
+            return basename === sessionId || basename.endsWith(`_${sessionId}`);
+        });
+    }
+    /**
+   * Group matchable processes (cwd and start time set) by the project dir Pi
+   * stores their sessions in. With `skipUnchanged`, dirs whose previous scan
+   * matched nothing and that have not changed since are left out.
+   */ groupByProjectDir(processes, skipUnchanged) {
+        const scans = new Map();
+        if (!isDirectory(this.sessionsDir)) return scans;
+        for (const proc of processes){
+            if (!proc.cwd || !proc.startTime) continue;
+            const projectDir = path.join(this.sessionsDir, this.encodeProjectDir(proc.cwd));
+            const scan = scans.get(projectDir);
+            if (scan) {
+                scan.processes.push(proc);
+                continue;
+            }
+            const stat = safeStat(projectDir);
+            if (stat?.isDirectory()) {
+                scans.set(projectDir, {
+                    dirMtimeMs: stat.mtimeMs,
+                    processes: [
+                        proc
+                    ]
+                });
+            }
+        }
+        if (!skipUnchanged) return scans;
+        for (const projectDir of this.noMatchDirs.keys()){
+            if (!scans.has(projectDir)) this.noMatchDirs.delete(projectDir);
+        }
+        for (const [projectDir, scan] of scans){
+            const noMatch = this.noMatchDirs.get(projectDir);
+            // An unmatched process never held a session, so dropping one cannot free
+            // a session for another; only a dir change or an unseen process can.
+            const unchanged = noMatch !== undefined && noMatch.dirMtimeMs === scan.dirMtimeMs && scan.processes.every((proc)=>noMatch.processKeys.has(processKey(proc)));
+            if (unchanged) {
+                scans.delete(projectDir);
+            } else {
+                this.noMatchDirs.delete(projectDir);
+            }
+        }
+        return scans;
+    }
+    discoverSessionsInDirs(scans) {
+        const sessions = [];
+        for (const [projectDir, scan] of scans){
+            const cwd = scan.processes[0]?.cwd ?? "";
+            const startTimes = scan.processes.map((proc)=>proc.startTime?.getTime() ?? 0);
+            for (const fileName of listJsonl(projectDir)){
+                const filePath = path.join(projectDir, fileName);
+                const stat = safeStat(filePath);
+                if (!stat?.isFile()) continue;
+                const birthtimeMs = stat.birthtimeMs || stat.mtimeMs;
+                const createdMs = this.fileNameTimestamp(fileName);
+                const inWindow = startTimes.some((startMs)=>Math.abs(startMs - birthtimeMs) <= MATCH_TOLERANCE_MS || createdMs !== undefined && Math.abs(startMs - createdMs) <= MATCH_TOLERANCE_MS);
+                if (!inWindow) continue;
+                const head = this.readHead(filePath, stat);
+                sessions.push({
+                    sessionId: head?.sessionId || this.parser.sessionIdFromFile(filePath),
+                    filePath,
+                    projectDir,
+                    birthtimeMs,
+                    resolvedCwd: head?.projectPath || cwd
+                });
+            }
+        }
+        return sessions;
+    }
+    /** Head metadata for `filePath`, re-read only when appended bytes could change it. */ readHead(filePath, stat) {
+        const cached = this.heads.get(filePath);
+        const reusable = cached !== undefined && cached.dev === stat.dev && cached.ino === stat.ino && (cached.size === stat.size || stat.size > cached.size && this.isHeadSettled(cached.head));
+        if (reusable) {
+            cached.seen = this.generation;
+            return cached.head;
+        }
+        const head = this.parser.readSessionHead(filePath);
+        if (head) {
+            this.heads.set(filePath, {
+                dev: stat.dev,
+                ino: stat.ino,
+                size: stat.size,
+                head,
+                seen: this.generation
+            });
+        } else {
+            this.heads.delete(filePath);
+        }
+        return head;
+    }
+    /** Appending to a file cannot change a head that found both fields or hit the byte cap. */ isHeadSettled(head) {
+        return Boolean(head.sessionId) && Boolean(head.projectPath) || head.bytesRead >= PI_SESSION_HEAD_MAX_BYTES;
+    }
+    rememberUnmatchedDirs(scans, matches) {
+        const matchedPids = new Set(matches.map((match)=>match.process.pid));
+        for (const [projectDir, scan] of scans){
+            if (scan.processes.some((proc)=>matchedPids.has(proc.pid))) continue;
+            this.noMatchDirs.set(projectDir, {
+                dirMtimeMs: scan.dirMtimeMs,
+                processKeys: new Set(scan.processes.map(processKey))
+            });
+        }
+    }
+    pruneHeads() {
+        for (const [filePath, entry] of this.heads){
+            if (entry.seen !== this.generation) this.heads.delete(filePath);
+        }
+    }
+    fileNameTimestamp(fileName) {
+        const match = FILE_NAME_TIMESTAMP.exec(fileName);
+        if (!match) return undefined;
+        const [, date, hours, minutes, seconds, millis] = match;
+        const ms = Date.parse(`${date}T${hours}:${minutes}:${seconds}.${millis}Z`);
+        return Number.isNaN(ms) ? undefined : ms;
+    }
+    collectJsonlFiles(dir) {
+        const files = [];
+        for (const entry of safeReaddir(dir)){
+            const fullPath = path.join(dir, entry);
+            const stat = safeStat(fullPath);
+            if (!stat) continue;
+            if (stat.isDirectory()) {
+                files.push(...this.collectJsonlFiles(fullPath));
+            } else if (stat.isFile() && entry.endsWith(".jsonl")) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    encodeProjectDir(cwd) {
+        const normalized = path.resolve(cwd);
+        return `--${normalized.replace(/^\//, "").replace(/\//g, "-")}--`;
+    }
+}
+function processKey(proc) {
+    return `${proc.pid}:${proc.startTime?.getTime() ?? ""}`;
+}
+
+//# sourceMappingURL=PiSessionLocator.js.map

package/dist/harnesses/pi/PiSessionLocator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/harnesses/pi/PiSessionLocator.ts"],"sourcesContent":["import type * as fs from \"fs\";\nimport * as path from \"path\";\nimport type { ProcessInfo } from \"../../adapters/AgentAdapter.js\";\nimport { matchProcessesToSessions, type MatchResult } from \"../../utils/matching.js\";\nimport { MATCH_TOLERANCE_MS } from \"../../utils/matchingConstants.js\";\nimport {\n  isDirectory,\n  isSafePathSegment,\n  listJsonl,\n  safeReaddir,\n  safeStat,\n  type SessionFile,\n} from \"../../utils/session.js\";\nimport {\n  PI_SESSION_HEAD_MAX_BYTES,\n  PiSessionParser,\n  type PiSessionHead,\n} from \"./PiSessionParser.js\";\nimport { homeDir } from \"../shared.js\";\n\nexport interface PiSessionLocatorOptions {\n  sessionsDir?: string;\n}\n\nexport interface PiProcessSessionMatches {\n  legacyMatches: MatchResult[];\n  fallback: ProcessInfo[];\n}\n\n/** Pi session file names start with their creation time: `2026-06-10T08-58-20-754Z_<id>.jsonl`. */\nconst FILE_NAME_TIMESTAMP = /^(\\d{4}-\\d{2}-\\d{2})T(\\d{2})-(\\d{2})-(\\d{2})-(\\d{3})Z_/;\n\ninterface ProjectDirScan {\n  dirMtimeMs: number;\n  processes: ProcessInfo[];\n}\n\ninterface CachedHead {\n  dev: number;\n  ino: number;\n  size: number;\n  head: PiSessionHead;\n  seen: number;\n}\n\n/** A project dir whose last scan matched none of the processes that scanned it. */\ninterface NoMatchEntry {\n  dirMtimeMs: number;\n  processKeys: Set<string>;\n}\n\n/**\n * Finds Pi session files for running processes that the registry and the\n * sessions.json tracker could not resolve.\n *\n * Live discovery is scoped so its cost follows live agents, not Pi history:\n * - only the project dir Pi derives from each process cwd is listed;\n * - only files created within MATCH_TOLERANCE_MS (the matcher's tolerance) of a\n *   process start are opened,\n *   and only their head (<= 64 KiB) is read for session id and cwd;\n * - heads are cached per file (dev/ino/size) across calls on one instance;\n * - a project dir whose scan matched none of its processes is skipped until\n *   its mtime changes (a session file was added or removed) or a process it\n *   has not seen needs it.\n *\n * Reuse one instance across refreshes to benefit from the caches.\n */\nexport class PiSessionLocator {\n  private readonly sessionsDir: string;\n  private readonly heads = new Map<string, CachedHead>();\n  private readonly noMatchDirs = new Map<string, NoMatchEntry>();\n  private generation = 0;\n\n  constructor(\n    options: PiSessionLocatorOptions = {},\n    private readonly parser: PiSessionParser = new PiSessionParser(),\n  ) {\n    this.sessionsDir = options.sessionsDir ?? path.join(homeDir(), \".pi\", \"agent\", \"sessions\");\n  }\n\n  matchRunningProcesses(processes: ProcessInfo[]): PiProcessSessionMatches {\n    this.generation++;\n    try {\n      if (processes.length === 0) return { legacyMatches: [], fallback: [] };\n\n      const scans = this.groupByProjectDir(processes, true);\n      const sessions = this.discoverSessionsInDirs(scans);\n      if (sessions.length === 0) {\n        this.rememberUnmatchedDirs(scans, []);\n        return { legacyMatches: [], fallback: processes };\n      }\n\n      const legacyMatches = matchProcessesToSessions(processes, sessions);\n      this.rememberUnmatchedDirs(scans, legacyMatches);\n      return { legacyMatches, fallback: processes };\n    } finally {\n      this.pruneHeads();\n    }\n  }\n\n  /**\n   * Session files that could match `processes`: files in each process's\n   * project dir created within the start-time window, with session id and\n   * cwd taken from a bounded head read.\n   */\n  discoverLiveSessions(processes: ProcessInfo[] = []): SessionFile[] {\n    return this.discoverSessionsInDirs(this.groupByProjectDir(processes, false));\n  }\n\n  discoverHistoricalSessionFiles(): string[] {\n    return this.collectJsonlFiles(this.sessionsDir);\n  }\n\n  findHistoricalSessionFilesById(sessionId: string): string[] {\n    if (!isSafePathSegment(sessionId)) return [];\n\n    return this.collectJsonlFiles(this.sessionsDir).filter((filePath) => {\n      const basename = path.basename(filePath, \".jsonl\");\n      return basename === sessionId || basename.endsWith(`_${sessionId}`);\n    });\n  }\n\n  /**\n   * Group matchable processes (cwd and start time set) by the project dir Pi\n   * stores their sessions in. With `skipUnchanged`, dirs whose previous scan\n   * matched nothing and that have not changed since are left out.\n   */\n  private groupByProjectDir(\n    processes: ProcessInfo[],\n    skipUnchanged: boolean,\n  ): Map<string, ProjectDirScan> {\n    const scans = new Map<string, ProjectDirScan>();\n    if (!isDirectory(this.sessionsDir)) return scans;\n\n    for (const proc of processes) {\n      if (!proc.cwd || !proc.startTime) continue;\n      const projectDir = path.join(this.sessionsDir, this.encodeProjectDir(proc.cwd));\n      const scan = scans.get(projectDir);\n      if (scan) {\n        scan.processes.push(proc);\n        continue;\n      }\n      const stat = safeStat(projectDir);\n      if (stat?.isDirectory()) {\n        scans.set(projectDir, { dirMtimeMs: stat.mtimeMs, processes: [proc] });\n      }\n    }\n\n    if (!skipUnchanged) return scans;\n\n    for (const projectDir of this.noMatchDirs.keys()) {\n      if (!scans.has(projectDir)) this.noMatchDirs.delete(projectDir);\n    }\n    for (const [projectDir, scan] of scans) {\n      const noMatch = this.noMatchDirs.get(projectDir);\n      // An unmatched process never held a session, so dropping one cannot free\n      // a session for another; only a dir change or an unseen process can.\n      const unchanged =\n        noMatch !== undefined &&\n        noMatch.dirMtimeMs === scan.dirMtimeMs &&\n        scan.processes.every((proc) => noMatch.processKeys.has(processKey(proc)));\n      if (unchanged) {\n        scans.delete(projectDir);\n      } else {\n        this.noMatchDirs.delete(projectDir);\n      }\n    }\n    return scans;\n  }\n\n  private discoverSessionsInDirs(scans: Map<string, ProjectDirScan>): SessionFile[] {\n    const sessions: SessionFile[] = [];\n    for (const [projectDir, scan] of scans) {\n      const cwd = scan.processes[0]?.cwd ?? \"\";\n      const startTimes = scan.processes.map((proc) => proc.startTime?.getTime() ?? 0);\n\n      for (const fileName of listJsonl(projectDir)) {\n        const filePath = path.join(projectDir, fileName);\n        const stat = safeStat(filePath);\n        if (!stat?.isFile()) continue;\n\n        const birthtimeMs = stat.birthtimeMs || stat.mtimeMs;\n        const createdMs = this.fileNameTimestamp(fileName);\n        const inWindow = startTimes.some(\n          (startMs) =>\n            Math.abs(startMs - birthtimeMs) <= MATCH_TOLERANCE_MS ||\n            (createdMs !== undefined && Math.abs(startMs - createdMs) <= MATCH_TOLERANCE_MS),\n        );\n        if (!inWindow) continue;\n\n        const head = this.readHead(filePath, stat);\n        sessions.push({\n          sessionId: head?.sessionId || this.parser.sessionIdFromFile(filePath),\n          filePath,\n          projectDir,\n          birthtimeMs,\n          resolvedCwd: head?.projectPath || cwd,\n        });\n      }\n    }\n    return sessions;\n  }\n\n  /** Head metadata for `filePath`, re-read only when appended bytes could change it. */\n  private readHead(filePath: string, stat: fs.Stats): PiSessionHead | null {\n    const cached = this.heads.get(filePath);\n    const reusable =\n      cached !== undefined &&\n      cached.dev === stat.dev &&\n      cached.ino === stat.ino &&\n      (cached.size === stat.size || (stat.size > cached.size && this.isHeadSettled(cached.head)));\n    if (reusable) {\n      cached.seen = this.generation;\n      return cached.head;\n    }\n\n    const head = this.parser.readSessionHead(filePath);\n    if (head) {\n      this.heads.set(filePath, {\n        dev: stat.dev,\n        ino: stat.ino,\n        size: stat.size,\n        head,\n        seen: this.generation,\n      });\n    } else {\n      this.heads.delete(filePath);\n    }\n    return head;\n  }\n\n  /** Appending to a file cannot change a head that found both fields or hit the byte cap. */\n  private isHeadSettled(head: PiSessionHead): boolean {\n    return (\n      (Boolean(head.sessionId) && Boolean(head.projectPath)) ||\n      head.bytesRead >= PI_SESSION_HEAD_MAX_BYTES\n    );\n  }\n\n  private rememberUnmatchedDirs(scans: Map<string, ProjectDirScan>, matches: MatchResult[]): void {\n    const matchedPids = new Set(matches.map((match) => match.process.pid));\n    for (const [projectDir, scan] of scans) {\n      if (scan.processes.some((proc) => matchedPids.has(proc.pid))) continue;\n      this.noMatchDirs.set(projectDir, {\n        dirMtimeMs: scan.dirMtimeMs,\n        processKeys: new Set(scan.processes.map(processKey)),\n      });\n    }\n  }\n\n  private pruneHeads(): void {\n    for (const [filePath, entry] of this.heads) {\n      if (entry.seen !== this.generation) this.heads.delete(filePath);\n    }\n  }\n\n  private fileNameTimestamp(fileName: string): number | undefined {\n    const match = FILE_NAME_TIMESTAMP.exec(fileName);\n    if (!match) return undefined;\n    const [, date, hours, minutes, seconds, millis] = match;\n    const ms = Date.parse(`${date}T${hours}:${minutes}:${seconds}.${millis}Z`);\n    return Number.isNaN(ms) ? undefined : ms;\n  }\n\n  private collectJsonlFiles(dir: string): string[] {\n    const files: string[] = [];\n    for (const entry of safeReaddir(dir)) {\n      const fullPath = path.join(dir, entry);\n      const stat = safeStat(fullPath);\n      if (!stat) continue;\n      if (stat.isDirectory()) {\n        files.push(...this.collectJsonlFiles(fullPath));\n      } else if (stat.isFile() && entry.endsWith(\".jsonl\")) {\n        files.push(fullPath);\n      }\n    }\n    return files;\n  }\n\n  private encodeProjectDir(cwd: string): string {\n    const normalized = path.resolve(cwd);\n    return `--${normalized.replace(/^\\//, \"\").replace(/\\//g, \"-\")}--`;\n  }\n}\n\nfunction processKey(proc: ProcessInfo): string {\n  return `${proc.pid}:${proc.startTime?.getTime() ?? \"\"}`;\n}\n"],"names":["path","matchProcessesToSessions","MATCH_TOLERANCE_MS","isDirectory","isSafePathSegment","listJsonl","safeReaddir","safeStat","PI_SESSION_HEAD_MAX_BYTES","PiSessionParser","homeDir","FILE_NAME_TIMESTAMP","PiSessionLocator","sessionsDir","heads","Map","noMatchDirs","generation","options","parser","join","matchRunningProcesses","processes","length","legacyMatches","fallback","scans","groupByProjectDir","sessions","discoverSessionsInDirs","rememberUnmatchedDirs","pruneHeads","discoverLiveSessions","discoverHistoricalSessionFiles","collectJsonlFiles","findHistoricalSessionFilesById","sessionId","filter","filePath","basename","endsWith","skipUnchanged","proc","cwd","startTime","projectDir","encodeProjectDir","scan","get","push","stat","set","dirMtimeMs","mtimeMs","keys","has","delete","noMatch","unchanged","undefined","every","processKeys","processKey","startTimes","map","getTime","fileName","isFile","birthtimeMs","createdMs","fileNameTimestamp","inWindow","some","startMs","Math","abs","head","readHead","sessionIdFromFile","resolvedCwd","projectPath","cached","reusable","dev","ino","size","isHeadSettled","seen","readSessionHead","Boolean","bytesRead","matches","matchedPids","Set","match","process","pid","entry","exec","date","hours","minutes","seconds","millis","ms","Date","parse","Number","isNaN","dir","files","fullPath","normalized","resolve","replace"],"mappings":"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"}

package/dist/harnesses/pi/PiSessionParser.d.ts

@@ -0,0 +1,88 @@
+import type { ConversationMessage, ConversationOptions, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { type JsonlSummaryBounds } from "../../utils/IncrementalJsonlSummary.js";
+export interface PiSession {
+    sessionId: string;
+    projectPath: string;
+    summary: string;
+    sessionStart: Date;
+    lastActive: Date;
+    lastRole?: ConversationMessage["role"];
+}
+/**
+ * Session identity read from the start of a file, without parsing the rest.
+ * Fields are undefined when not found in the head.
+ */
+export interface PiSessionHead {
+    sessionId?: string;
+    projectPath?: string;
+    /** Bytes read from the file. */
+    bytesRead: number;
+    /** True when the whole file fit in the head read. */
+    complete: boolean;
+}
+/** Upper bound for `readSessionHead`; Pi writes its session header as the first line. */
+export declare const PI_SESSION_HEAD_MAX_BYTES: number;
+export interface PiSessionParserOptions {
+    /** Cold-start scan bounds for `readSessionIncremental` (see IncrementalJsonlSummary). */
+    summaryBounds?: JsonlSummaryBounds | false;
+}
+export declare class PiSessionParser {
+    /** Incremental reader backing `getConversation({ tail })`. */
+    private readonly tailReader;
+    private readonly sessionCache;
+    constructor(options?: PiSessionParserOptions);
+    readSession(filePath: string, fallbackCwd?: string): PiSession | null;
+    /**
+     * Same result as `readSession`, but backed by a per-instance incremental
+     * cache so repeated refreshes only parse bytes appended since the last call.
+     * Call `pruneSessionCache()` once per refresh to evict files no longer read.
+     *
+     * The first read of a large transcript is a bounded head + tail scan (see
+     * `summaryReducer.skip`); fields whose entries lie only in the skipped
+     * middle fall back to their defaults instead of forcing a full parse.
+     */
+    readSessionIncremental(filePath: string, fallbackCwd?: string): PiSession | null;
+    /** Evict cached summaries for files not read since the previous prune. */
+    pruneSessionCache(): void;
+    /**
+     * Read the session id and project path from the first complete lines of a
+     * file, stopping once both are found or after `maxBytes`. Null if unreadable.
+     */
+    readSessionHead(filePath: string, maxBytes?: number): PiSessionHead | null;
+    determineStatus(session: PiSession): AgentStatus;
+    getConversation(sessionFilePath: string, options?: ConversationOptions): ConversationMessage[];
+    fileToSessionSummary(filePath: string): SessionSummary | null;
+    sessionIdFromFile(filePath: string): string;
+    /**
+     * Fold one JSONL entry into the O(1) session summary. Mirrors the previous
+     * whole-file scan: id, cwd and start come from the first entry that has
+     * them; last active, last user message and last role track the latest one.
+     *
+     * `skip` (bounded cold start) keeps the head's first-* fields (id, cwd,
+     * start, first user message) and clears the latest ones, so those come from
+     * the tail only. Tail entries never fill a first-* field: Pi message entries
+     * carry their own `id`, which must not become the session id. A first-*
+     * value beyond the head falls back like a missing one (filename id,
+     * `fallbackCwd`, file birthtime, no first user message); a latest value
+     * before the tail window stays unset (file mtime for last active).
+     */
+    private readonly summaryReducer;
+    private toSession;
+    private applyHeadLine;
+    private readJsonl;
+    private parseJsonlLine;
+    private entriesToMessages;
+    private entryToMessage;
+    private entryRole;
+    private entryContent;
+    private contentToString;
+    private messageRecord;
+    private asRecord;
+    private roleLikeType;
+    private entryTimestamp;
+    private entrySessionId;
+    private entryCwd;
+    private firstString;
+}
+//# sourceMappingURL=PiSessionParser.d.ts.map

package/dist/harnesses/pi/PiSessionParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PiSessionParser.d.ts","sourceRoot":"","sources":["../../../src/harnesses/pi/PiSessionParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACf,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAGL,KAAK,kBAAkB,EAExB,MAAM,wCAAwC,CAAC;AAKhD,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,IAAI,CAAC;IACnB,UAAU,EAAE,IAAI,CAAC;IACjB,QAAQ,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;CACxC;AAsBD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAmBD,yFAAyF;AACzF,eAAO,MAAM,yBAAyB,QAAY,CAAC;AAGnD,MAAM,WAAW,sBAAsB;IACrC,yFAAyF;IACzF,aAAa,CAAC,EAAE,kBAAkB,GAAG,KAAK,CAAC;CAC5C;AAED,qBAAa,eAAe;IAC1B,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0C;gBAE3D,OAAO,GAAE,sBAA2B;IAMhD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAK,GAAG,SAAS,GAAG,IAAI;IAMjE;;;;;;;;OAQG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAK,GAAG,SAAS,GAAG,IAAI;IAK5E,0EAA0E;IAC1E,iBAAiB,IAAI,IAAI;IAIzB;;;OAGG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,SAA4B,GAAG,aAAa,GAAG,IAAI;IAgD7F,eAAe,CAAC,OAAO,EAAE,SAAS,GAAG,WAAW;IAMhD,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,EAAE;IAmB9F,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAkB7D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM3C;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAqC7B;IAEF,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,YAAY;IAwBpB,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,QAAQ;IAchB,OAAO,CAAC,WAAW;CAMpB"}

package/dist/harnesses/pi/PiSessionParser.js

@@ -0,0 +1,318 @@
+import * as fs from "fs";
+import * as path from "path";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { IncrementalJsonlSummary, reduceJsonlContent } from "../../utils/IncrementalJsonlSummary.js";
+import { JsonlTailReader, normalizeTail } from "../../utils/jsonlTail.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+import { isIdle, parseTimestamp, SUMMARY_MAX_LENGTH, truncate } from "../shared.js";
+/** Upper bound for `readSessionHead`; Pi writes its session header as the first line. */ export const PI_SESSION_HEAD_MAX_BYTES = 64 * 1024;
+const HEAD_CHUNK_BYTES = 4 * 1024;
+export class PiSessionParser {
+    /** Incremental reader backing `getConversation({ tail })`. */ tailReader = new JsonlTailReader();
+    sessionCache;
+    constructor(options = {}){
+        this.sessionCache = new IncrementalJsonlSummary(this.summaryReducer, {
+            bounds: options.summaryBounds
+        });
+    }
+    readSession(filePath, fallbackCwd = "") {
+        const content = safeReadFile(filePath);
+        if (content === undefined) return null;
+        return this.toSession(filePath, fallbackCwd, reduceJsonlContent(this.summaryReducer, content));
+    }
+    /**
+   * Same result as `readSession`, but backed by a per-instance incremental
+   * cache so repeated refreshes only parse bytes appended since the last call.
+   * Call `pruneSessionCache()` once per refresh to evict files no longer read.
+   *
+   * The first read of a large transcript is a bounded head + tail scan (see
+   * `summaryReducer.skip`); fields whose entries lie only in the skipped
+   * middle fall back to their defaults instead of forcing a full parse.
+   */ readSessionIncremental(filePath, fallbackCwd = "") {
+        const result = this.sessionCache.read(filePath);
+        return result ? this.toSession(filePath, fallbackCwd, result.state) : null;
+    }
+    /** Evict cached summaries for files not read since the previous prune. */ pruneSessionCache() {
+        this.sessionCache.prune();
+    }
+    /**
+   * Read the session id and project path from the first complete lines of a
+   * file, stopping once both are found or after `maxBytes`. Null if unreadable.
+   */ readSessionHead(filePath, maxBytes = PI_SESSION_HEAD_MAX_BYTES) {
+        let fd;
+        try {
+            fd = fs.openSync(filePath, "r");
+        } catch  {
+            return null;
+        }
+        try {
+            const head = {
+                bytesRead: 0,
+                complete: false
+            };
+            const buffer = Buffer.alloc(maxBytes);
+            let lineStart = 0;
+            while(head.bytesRead < maxBytes){
+                const bytesRead = fs.readSync(fd, buffer, head.bytesRead, Math.min(HEAD_CHUNK_BYTES, maxBytes - head.bytesRead), head.bytesRead);
+                if (bytesRead === 0) {
+                    head.complete = true;
+                    break;
+                }
+                head.bytesRead += bytesRead;
+                let newline = buffer.indexOf(0x0a, lineStart);
+                while(newline !== -1 && newline < head.bytesRead){
+                    this.applyHeadLine(head, buffer.toString("utf8", lineStart, newline));
+                    lineStart = newline + 1;
+                    if (head.sessionId && head.projectPath) return head;
+                    newline = buffer.indexOf(0x0a, lineStart);
+                }
+            }
+            // The unterminated last line is only trusted when it ends the file
+            if (head.complete && lineStart < head.bytesRead) {
+                this.applyHeadLine(head, buffer.toString("utf8", lineStart, head.bytesRead));
+            }
+            return head;
+        } catch  {
+            return null;
+        } finally{
+            fs.closeSync(fd);
+        }
+    }
+    determineStatus(session) {
+        if (isIdle(session.lastActive)) return AgentStatus.IDLE;
+        if (session.lastRole === "assistant") return AgentStatus.WAITING;
+        return AgentStatus.RUNNING;
+    }
+    getConversation(sessionFilePath, options) {
+        const includeSystem = options?.verbose ?? false;
+        const tail = normalizeTail(options?.tail);
+        if (tail !== undefined) {
+            return this.tailReader.read(sessionFilePath, tail, {
+                parseLine: (line)=>{
+                    const entry = this.parseJsonlLine(line);
+                    return entry ? this.entryToMessage(entry, includeSystem) : null;
+                }
+            }, String(includeSystem));
+        }
+        return this.entriesToMessages(this.readJsonl(sessionFilePath), includeSystem);
+    }
+    fileToSessionSummary(filePath) {
+        const content = safeReadFile(filePath);
+        if (content === undefined) return null;
+        const state = reduceJsonlContent(this.summaryReducer, content);
+        const session = this.toSession(filePath, "", state);
+        if (!session) return null;
+        return {
+            type: "pi",
+            sessionId: session.sessionId,
+            cwd: session.projectPath,
+            firstUserMessage: state.firstUserMessage ?? "",
+            lastActive: session.lastActive,
+            startedAt: session.sessionStart,
+            sessionFilePath: filePath
+        };
+    }
+    sessionIdFromFile(filePath) {
+        const base = path.basename(filePath, ".jsonl");
+        const underscore = base.lastIndexOf("_");
+        return underscore >= 0 ? base.slice(underscore + 1) : base;
+    }
+    /**
+   * Fold one JSONL entry into the O(1) session summary. Mirrors the previous
+   * whole-file scan: id, cwd and start come from the first entry that has
+   * them; last active, last user message and last role track the latest one.
+   *
+   * `skip` (bounded cold start) keeps the head's first-* fields (id, cwd,
+   * start, first user message) and clears the latest ones, so those come from
+   * the tail only. Tail entries never fill a first-* field: Pi message entries
+   * carry their own `id`, which must not become the session id. A first-*
+   * value beyond the head falls back like a missing one (filename id,
+   * `fallbackCwd`, file birthtime, no first user message); a latest value
+   * before the tail window stays unset (file mtime for last active).
+   */ summaryReducer = {
+        initial: ()=>({
+                entryCount: 0
+            }),
+        reduce: (state, value)=>{
+            const entry = this.asRecord(value);
+            if (!entry) return state;
+            const next = {
+                ...state,
+                entryCount: state.entryCount + 1
+            };
+            const inHead = !state.pastHead;
+            if (inHead) {
+                next.sessionId ??= this.entrySessionId(entry);
+                next.projectPath ??= this.entryCwd(entry);
+            }
+            const timestamp = parseTimestamp(this.entryTimestamp(entry));
+            if (timestamp) {
+                if (inHead) next.firstTimestampMs ??= timestamp.getTime();
+                next.lastTimestampMs = timestamp.getTime();
+            }
+            const message = this.entryToMessage(entry, true);
+            if (message) {
+                next.lastRole = message.role;
+                if (message.role === "user") {
+                    next.lastUserMessage = message.content;
+                    if (inHead) next.firstUserMessage ??= message.content;
+                }
+            }
+            return next;
+        },
+        skip: (state)=>({
+                entryCount: state.entryCount,
+                pastHead: true,
+                sessionId: state.sessionId,
+                projectPath: state.projectPath,
+                firstTimestampMs: state.firstTimestampMs,
+                firstUserMessage: state.firstUserMessage
+            })
+    };
+    toSession(filePath, fallbackCwd, state) {
+        if (state.entryCount === 0) return null;
+        const needsStat = state.firstTimestampMs === undefined || state.lastTimestampMs === undefined;
+        const stat = needsStat ? safeStat(filePath) : undefined;
+        const sessionStart = state.firstTimestampMs !== undefined ? new Date(state.firstTimestampMs) : stat?.birthtime ?? stat?.mtime ?? new Date();
+        const lastActive = state.lastTimestampMs !== undefined ? new Date(state.lastTimestampMs) : stat?.mtime ?? sessionStart;
+        return {
+            sessionId: state.sessionId || this.sessionIdFromFile(filePath),
+            projectPath: state.projectPath || fallbackCwd,
+            summary: state.lastUserMessage ? truncate(state.lastUserMessage, SUMMARY_MAX_LENGTH) : "Pi session active",
+            sessionStart,
+            lastActive,
+            lastRole: state.lastRole
+        };
+    }
+    applyHeadLine(head, line) {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        let entry;
+        try {
+            entry = this.asRecord(JSON.parse(trimmed));
+        } catch  {
+            return;
+        }
+        if (!entry) return;
+        head.sessionId ??= this.entrySessionId(entry);
+        head.projectPath ??= this.entryCwd(entry);
+    }
+    readJsonl(filePath) {
+        const content = safeReadFile(filePath);
+        if (content === undefined) return [];
+        const entries = [];
+        for (const line of content.split(/\r?\n/)){
+            const entry = this.parseJsonlLine(line);
+            if (entry) entries.push(entry);
+        }
+        return entries;
+    }
+    parseJsonlLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) return null;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        } catch  {
+            return null;
+        }
+        return null;
+    }
+    entriesToMessages(entries, includeSystem) {
+        return entries.map((entry)=>this.entryToMessage(entry, includeSystem)).filter((msg)=>msg !== null);
+    }
+    entryToMessage(entry, includeSystem) {
+        const role = this.entryRole(entry);
+        if (!role) return null;
+        if (role === "system" && !includeSystem) return null;
+        const content = this.entryContent(entry).trim();
+        if (!content) return null;
+        return {
+            role,
+            content,
+            timestamp: this.entryTimestamp(entry)
+        };
+    }
+    entryRole(entry) {
+        const message = this.messageRecord(entry);
+        const raw = this.firstString(entry.role, message?.role, this.roleLikeType(entry.type), entry.payload?.role, entry.payload?.type, entry.data?.role, entry.data?.type);
+        if (!raw) return null;
+        const normalized = raw.toLowerCase();
+        if (normalized === "user" || normalized === "human") return "user";
+        if (normalized === "assistant" || normalized === "ai" || normalized === "pi") return "assistant";
+        if (normalized === "system") return "system";
+        return null;
+    }
+    entryContent(entry) {
+        const message = this.messageRecord(entry);
+        const candidates = [
+            entry.content,
+            entry.text,
+            message?.content,
+            message?.text,
+            message?.message,
+            entry.message,
+            entry.payload?.content,
+            entry.payload?.text,
+            entry.payload?.message,
+            entry.data?.content,
+            entry.data?.text,
+            entry.data?.message
+        ];
+        for (const candidate of candidates){
+            const text = this.contentToString(candidate);
+            if (text) return text;
+        }
+        return "";
+    }
+    contentToString(value) {
+        if (typeof value === "string") return value;
+        if (Array.isArray(value)) {
+            return value.map((item)=>this.contentToString(item)).filter(Boolean).join("");
+        }
+        if (!value || typeof value !== "object") return "";
+        const record = value;
+        return this.contentToString(record.content ?? record.text ?? record.value);
+    }
+    messageRecord(entry) {
+        return this.asRecord(entry.message);
+    }
+    asRecord(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+        return value;
+    }
+    roleLikeType(value) {
+        if (typeof value !== "string") return undefined;
+        const normalized = value.toLowerCase();
+        if ([
+            "user",
+            "human",
+            "assistant",
+            "ai",
+            "pi",
+            "system"
+        ].includes(normalized)) {
+            return value;
+        }
+        return undefined;
+    }
+    entryTimestamp(entry) {
+        return this.firstString(entry.timestamp, entry.payload?.timestamp, entry.data?.timestamp, entry.createdAt, entry.created_at);
+    }
+    entrySessionId(entry) {
+        return this.firstString(entry.sessionId, entry.session_id, entry.id, entry.payload?.sessionId, entry.payload?.session_id, entry.payload?.id, entry.data?.sessionId, entry.data?.session_id, entry.data?.id);
+    }
+    entryCwd(entry) {
+        return this.firstString(entry.cwd, entry.projectPath, entry.project_path, entry.payload?.cwd, entry.payload?.projectPath, entry.payload?.project_path, entry.data?.cwd, entry.data?.projectPath, entry.data?.project_path);
+    }
+    firstString(...values) {
+        for (const value of values){
+            if (typeof value === "string" && value) return value;
+        }
+        return undefined;
+    }
+}
+
+//# sourceMappingURL=PiSessionParser.js.map