@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/dist/utils/IncrementalJsonlSummary.js

@@ -0,0 +1,209 @@
+/**
+ * Incremental JSONL Summary
+ *
+ * Keeps a small per-file summary of append-only JSONL transcripts so repeated
+ * refreshes only parse bytes that were appended since the previous read.
+ *
+ * Usage:
+ * ```ts
+ * const summaries = new IncrementalJsonlSummary<MyState>({
+ *   initial: () => ({ lastType: undefined }),
+ *   reduce: (state, entry) => ({ ...state, lastType: (entry as any)?.type }),
+ * });
+ *
+ * const result = summaries.read(filePath); // { state, size, mtime, skippedBytes } | null
+ * summaries.prune(); // once per refresh: evict paths not read since the last prune
+ * ```
+ *
+ * Read rules, keyed by file path:
+ * - dev, ino, size and mtimeMs unchanged → cached state, 0 bytes read.
+ * - same dev/ino and size grew → read only the bytes after the last complete line.
+ * - anything else (first read, shrink, rotation, in-place rewrite) → rebuild.
+ *
+ * A rebuild of a file larger than `headBytes + tailBytes` (default 1 MiB +
+ * 4 MiB) is a bounded cold start rather than a full parse: it folds the
+ * complete lines in `[0, headBytes)`, calls `reducer.skip(state)`, then folds
+ * the lines that start inside `[size - tailBytes, size)`, including a line
+ * that starts exactly at `size - tailBytes` (one extra byte before the window
+ * is read to tell). Lines straddling a window edge are dropped. A field whose
+ * entries all sit in the skipped middle keeps whatever `skip` leaves; there is
+ * never a hidden full scan. The result's `skippedBytes` reports the unread
+ * middle, and the cache is seeded at end of file so later appends stay
+ * incremental.
+ *
+ * An unterminated last line is never folded into the committed state. If it
+ * already parses as JSON it is applied to the returned state only, and it is
+ * re-read (from its start offset) once more bytes arrive.
+ */ import * as fs from "fs";
+export const DEFAULT_HEAD_BYTES = 1024 * 1024;
+export const DEFAULT_TAIL_BYTES = 4 * 1024 * 1024;
+const DEFAULT_CHUNK_SIZE = 1024 * 1024;
+const NEWLINE = 0x0a;
+/** Fold a whole JSONL string with a reducer (one-shot, uncached). */ export function reduceJsonlContent(reducer, content) {
+    let state = reducer.initial();
+    for (const line of content.split("\n")){
+        state = reduceLine(reducer, state, line);
+    }
+    return state;
+}
+export class IncrementalJsonlSummary {
+    reducer;
+    entries = new Map();
+    chunkSize;
+    bounds;
+    generation = 0;
+    constructor(reducer, options = {}){
+        this.reducer = reducer;
+        this.chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+        this.bounds = options.bounds ?? {
+            headBytes: DEFAULT_HEAD_BYTES,
+            tailBytes: DEFAULT_TAIL_BYTES
+        };
+    }
+    /** Number of cached files. */ get size() {
+        return this.entries.size;
+    }
+    /** Return the summary of `filePath`, reading only what changed. Null if unreadable. */ read(filePath) {
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        } catch  {
+            this.entries.delete(filePath);
+            return null;
+        }
+        const cached = this.entries.get(filePath);
+        const sameFile = cached !== undefined && cached.dev === stat.dev && cached.ino === stat.ino;
+        if (sameFile && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+            cached.seen = this.generation;
+            return toResult(cached);
+        }
+        const appended = sameFile && stat.size > cached.size;
+        const entry = appended ? {
+            ...cached
+        } : {
+            dev: stat.dev,
+            ino: stat.ino,
+            size: 0,
+            mtimeMs: 0,
+            mtime: stat.mtime,
+            offset: 0,
+            discarding: false,
+            committed: this.reducer.initial(),
+            state: this.reducer.initial(),
+            skippedBytes: 0,
+            seen: this.generation
+        };
+        try {
+            const fd = fs.openSync(filePath, "r");
+            try {
+                const bounds = this.bounds;
+                if (!appended && bounds && stat.size > bounds.headBytes + bounds.tailBytes) {
+                    this.readBounded(fd, entry, stat.size, bounds);
+                } else {
+                    this.readRange(fd, entry, stat.size);
+                }
+            } finally{
+                fs.closeSync(fd);
+            }
+        } catch  {
+            this.entries.delete(filePath);
+            return null;
+        }
+        entry.mtimeMs = stat.mtimeMs;
+        entry.mtime = stat.mtime;
+        entry.seen = this.generation;
+        this.entries.set(filePath, entry);
+        return toResult(entry);
+    }
+    /** Evict entries not read since the previous `prune()` call. Call once per refresh. */ prune() {
+        for (const [filePath, entry] of this.entries){
+            if (entry.seen !== this.generation) {
+                this.entries.delete(filePath);
+            }
+        }
+        this.generation++;
+    }
+    /** Cold start: fold the head lines, `skip`, then the lines starting in the tail window. */ readBounded(fd, entry, size, { headBytes, tailBytes }) {
+        this.readRange(fd, entry, headBytes);
+        const tailStart = size - tailBytes;
+        const head = entry.committed;
+        entry.committed = this.reducer.skip ? this.reducer.skip(head) : head;
+        // Lines are only folded from their first byte, and tailStart may fall
+        // mid-line. Discard from one byte earlier (tailStart > headBytes >= 0): if
+        // that byte is the newline ending the previous line, discarding stops there
+        // and the line starting at tailStart is folded; otherwise the partial line
+        // is dropped up to its newline.
+        entry.offset = tailStart - 1;
+        entry.discarding = true;
+        entry.skippedBytes = tailStart - headBytes;
+        this.readRange(fd, entry, size);
+    }
+    /** Fold complete lines in `[entry.offset, end)` into `entry`. */ readRange(fd, entry, end) {
+        const chunk = Buffer.allocUnsafe(Math.min(this.chunkSize, Math.max(end - entry.offset, 1)));
+        let position = entry.offset;
+        let carry;
+        let committed = entry.committed;
+        let discarding = entry.discarding;
+        while(position < end){
+            const bytesRead = fs.readSync(fd, chunk, 0, Math.min(chunk.length, end - position), position);
+            if (bytesRead === 0) break;
+            position += bytesRead;
+            let lineStart = 0;
+            let newline = chunk.indexOf(NEWLINE, 0);
+            while(newline !== -1 && newline < bytesRead){
+                if (discarding) {
+                    discarding = false;
+                } else {
+                    const lineBytes = carry ? Buffer.concat([
+                        carry,
+                        chunk.subarray(lineStart, newline)
+                    ]) : chunk.subarray(lineStart, newline);
+                    committed = reduceLine(this.reducer, committed, lineBytes.toString("utf8"));
+                }
+                carry = undefined;
+                lineStart = newline + 1;
+                newline = chunk.indexOf(NEWLINE, lineStart);
+            }
+            if (lineStart < bytesRead && !discarding) {
+                const rest = Buffer.from(chunk.subarray(lineStart, bytesRead));
+                carry = carry ? Buffer.concat([
+                    carry,
+                    rest
+                ]) : rest;
+            }
+        }
+        entry.committed = committed;
+        entry.discarding = discarding;
+        entry.offset = position - (carry?.length ?? 0);
+        entry.size = position;
+        entry.state = carry ? reduceTentative(this.reducer, committed, carry.toString("utf8")) : committed;
+    }
+}
+function toResult(entry) {
+    return {
+        state: entry.state,
+        size: entry.size,
+        mtime: entry.mtime,
+        skippedBytes: entry.skippedBytes
+    };
+}
+function reduceLine(reducer, state, line) {
+    if (!/\S/.test(line)) return state;
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    } catch  {
+        entry = undefined;
+    }
+    return reducer.reduce(state, entry);
+}
+/** Apply an unterminated line only if it is already valid JSON (i.e. fully written). */ function reduceTentative(reducer, state, line) {
+    if (!/\S/.test(line)) return state;
+    try {
+        return reducer.reduce(state, JSON.parse(line));
+    } catch  {
+        return state;
+    }
+}
+
+//# sourceMappingURL=IncrementalJsonlSummary.js.map

package/dist/utils/IncrementalJsonlSummary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/IncrementalJsonlSummary.ts"],"sourcesContent":["/**\n * Incremental JSONL Summary\n *\n * Keeps a small per-file summary of append-only JSONL transcripts so repeated\n * refreshes only parse bytes that were appended since the previous read.\n *\n * Usage:\n * ```ts\n * const summaries = new IncrementalJsonlSummary<MyState>({\n *   initial: () => ({ lastType: undefined }),\n *   reduce: (state, entry) => ({ ...state, lastType: (entry as any)?.type }),\n * });\n *\n * const result = summaries.read(filePath); // { state, size, mtime, skippedBytes } | null\n * summaries.prune(); // once per refresh: evict paths not read since the last prune\n * ```\n *\n * Read rules, keyed by file path:\n * - dev, ino, size and mtimeMs unchanged → cached state, 0 bytes read.\n * - same dev/ino and size grew → read only the bytes after the last complete line.\n * - anything else (first read, shrink, rotation, in-place rewrite) → rebuild.\n *\n * A rebuild of a file larger than `headBytes + tailBytes` (default 1 MiB +\n * 4 MiB) is a bounded cold start rather than a full parse: it folds the\n * complete lines in `[0, headBytes)`, calls `reducer.skip(state)`, then folds\n * the lines that start inside `[size - tailBytes, size)`, including a line\n * that starts exactly at `size - tailBytes` (one extra byte before the window\n * is read to tell). Lines straddling a window edge are dropped. A field whose\n * entries all sit in the skipped middle keeps whatever `skip` leaves; there is\n * never a hidden full scan. The result's `skippedBytes` reports the unread\n * middle, and the cache is seeded at end of file so later appends stay\n * incremental.\n *\n * An unterminated last line is never folded into the committed state. If it\n * already parses as JSON it is applied to the returned state only, and it is\n * re-read (from its start offset) once more bytes arrive.\n */\n\nimport * as fs from \"fs\";\n\n/**\n * Pure fold over the entries of a JSONL file.\n *\n * `reduce` receives each non-blank line in file order: the parsed JSON value,\n * or `undefined` when the line is not valid JSON. It must return a new state\n * rather than mutate `state`, and the state should stay O(1) in file size\n * (no entry arrays or raw file contents).\n *\n * `skip` is called once when a bounded cold start skips the middle of a file,\n * between the head lines and the tail lines. It returns the state the tail\n * lines fold onto: keep what the head established (e.g. the first entry) and\n * reset fields that track the latest entry, so those come only from lines\n * actually read. Without `skip`, tail lines fold straight onto the head state.\n */\nexport interface JsonlSummaryReducer<S> {\n  initial(): S;\n  reduce(state: S, entry: unknown): S;\n  skip?(state: S): S;\n}\n\nexport interface JsonlSummaryResult<S> {\n  state: S;\n  /** File size in bytes when the state was computed. */\n  size: number;\n  /** File mtime (`fs.Stats.mtime`) when the state was computed. */\n  mtime: Date;\n  /** Bytes the bounded cold start did not read; 0 when the whole file was parsed. */\n  skippedBytes: number;\n}\n\nexport interface JsonlSummaryBounds {\n  /** Bytes scanned from the start of the file on a cold start. */\n  headBytes: number;\n  /** Bytes scanned at the end of the file on a cold start. */\n  tailBytes: number;\n}\n\nexport interface IncrementalJsonlSummaryOptions {\n  /** Bytes read per `fs.readSync` call. */\n  chunkSize?: number;\n  /** Cold-start scan bounds; `false` parses rebuilt files from byte 0. */\n  bounds?: JsonlSummaryBounds | false;\n}\n\ninterface CacheEntry<S> {\n  dev: number;\n  ino: number;\n  size: number;\n  mtimeMs: number;\n  mtime: Date;\n  /** Byte offset just past the last newline folded into `committed`. */\n  offset: number;\n  /** `offset` is mid-line: drop bytes up to and including the next newline. */\n  discarding: boolean;\n  /** State after every newline-terminated line. */\n  committed: S;\n  /** `committed` plus the unterminated last line, when it parses as JSON. */\n  state: S;\n  /** Bytes the cold start did not read. */\n  skippedBytes: number;\n  /** Prune generation in which this entry was last read. */\n  seen: number;\n}\n\nexport const DEFAULT_HEAD_BYTES = 1024 * 1024;\nexport const DEFAULT_TAIL_BYTES = 4 * 1024 * 1024;\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024;\nconst NEWLINE = 0x0a;\n\n/** Fold a whole JSONL string with a reducer (one-shot, uncached). */\nexport function reduceJsonlContent<S>(reducer: JsonlSummaryReducer<S>, content: string): S {\n  let state = reducer.initial();\n  for (const line of content.split(\"\\n\")) {\n    state = reduceLine(reducer, state, line);\n  }\n  return state;\n}\n\nexport class IncrementalJsonlSummary<S> {\n  private readonly entries = new Map<string, CacheEntry<S>>();\n  private readonly chunkSize: number;\n  private readonly bounds: JsonlSummaryBounds | false;\n  private generation = 0;\n\n  constructor(\n    private readonly reducer: JsonlSummaryReducer<S>,\n    options: IncrementalJsonlSummaryOptions = {},\n  ) {\n    this.chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;\n    this.bounds = options.bounds ?? {\n      headBytes: DEFAULT_HEAD_BYTES,\n      tailBytes: DEFAULT_TAIL_BYTES,\n    };\n  }\n\n  /** Number of cached files. */\n  get size(): number {\n    return this.entries.size;\n  }\n\n  /** Return the summary of `filePath`, reading only what changed. Null if unreadable. */\n  read(filePath: string): JsonlSummaryResult<S> | null {\n    let stat: fs.Stats;\n    try {\n      stat = fs.statSync(filePath);\n    } catch {\n      this.entries.delete(filePath);\n      return null;\n    }\n\n    const cached = this.entries.get(filePath);\n    const sameFile = cached !== undefined && cached.dev === stat.dev && cached.ino === stat.ino;\n\n    if (sameFile && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {\n      cached.seen = this.generation;\n      return toResult(cached);\n    }\n\n    const appended = sameFile && stat.size > cached.size;\n    const entry: CacheEntry<S> = appended\n      ? { ...cached }\n      : {\n          dev: stat.dev,\n          ino: stat.ino,\n          size: 0,\n          mtimeMs: 0,\n          mtime: stat.mtime,\n          offset: 0,\n          discarding: false,\n          committed: this.reducer.initial(),\n          state: this.reducer.initial(),\n          skippedBytes: 0,\n          seen: this.generation,\n        };\n\n    try {\n      const fd = fs.openSync(filePath, \"r\");\n      try {\n        const bounds = this.bounds;\n        if (!appended && bounds && stat.size > bounds.headBytes + bounds.tailBytes) {\n          this.readBounded(fd, entry, stat.size, bounds);\n        } else {\n          this.readRange(fd, entry, stat.size);\n        }\n      } finally {\n        fs.closeSync(fd);\n      }\n    } catch {\n      this.entries.delete(filePath);\n      return null;\n    }\n\n    entry.mtimeMs = stat.mtimeMs;\n    entry.mtime = stat.mtime;\n    entry.seen = this.generation;\n    this.entries.set(filePath, entry);\n    return toResult(entry);\n  }\n\n  /** Evict entries not read since the previous `prune()` call. Call once per refresh. */\n  prune(): void {\n    for (const [filePath, entry] of this.entries) {\n      if (entry.seen !== this.generation) {\n        this.entries.delete(filePath);\n      }\n    }\n    this.generation++;\n  }\n\n  /** Cold start: fold the head lines, `skip`, then the lines starting in the tail window. */\n  private readBounded(\n    fd: number,\n    entry: CacheEntry<S>,\n    size: number,\n    { headBytes, tailBytes }: JsonlSummaryBounds,\n  ): void {\n    this.readRange(fd, entry, headBytes);\n\n    const tailStart = size - tailBytes;\n    const head = entry.committed;\n    entry.committed = this.reducer.skip ? this.reducer.skip(head) : head;\n    // Lines are only folded from their first byte, and tailStart may fall\n    // mid-line. Discard from one byte earlier (tailStart > headBytes >= 0): if\n    // that byte is the newline ending the previous line, discarding stops there\n    // and the line starting at tailStart is folded; otherwise the partial line\n    // is dropped up to its newline.\n    entry.offset = tailStart - 1;\n    entry.discarding = true;\n    entry.skippedBytes = tailStart - headBytes;\n    this.readRange(fd, entry, size);\n  }\n\n  /** Fold complete lines in `[entry.offset, end)` into `entry`. */\n  private readRange(fd: number, entry: CacheEntry<S>, end: number): void {\n    const chunk = Buffer.allocUnsafe(Math.min(this.chunkSize, Math.max(end - entry.offset, 1)));\n    let position = entry.offset;\n    let carry: Buffer | undefined;\n    let committed = entry.committed;\n    let discarding = entry.discarding;\n\n    while (position < end) {\n      const bytesRead = fs.readSync(fd, chunk, 0, Math.min(chunk.length, end - position), position);\n      if (bytesRead === 0) break;\n      position += bytesRead;\n\n      let lineStart = 0;\n      let newline = chunk.indexOf(NEWLINE, 0);\n      while (newline !== -1 && newline < bytesRead) {\n        if (discarding) {\n          discarding = false;\n        } else {\n          const lineBytes = carry\n            ? Buffer.concat([carry, chunk.subarray(lineStart, newline)])\n            : chunk.subarray(lineStart, newline);\n          committed = reduceLine(this.reducer, committed, lineBytes.toString(\"utf8\"));\n        }\n        carry = undefined;\n        lineStart = newline + 1;\n        newline = chunk.indexOf(NEWLINE, lineStart);\n      }\n\n      if (lineStart < bytesRead && !discarding) {\n        const rest = Buffer.from(chunk.subarray(lineStart, bytesRead));\n        carry = carry ? Buffer.concat([carry, rest]) : rest;\n      }\n    }\n\n    entry.committed = committed;\n    entry.discarding = discarding;\n    entry.offset = position - (carry?.length ?? 0);\n    entry.size = position;\n    entry.state = carry\n      ? reduceTentative(this.reducer, committed, carry.toString(\"utf8\"))\n      : committed;\n  }\n}\n\nfunction toResult<S>(entry: CacheEntry<S>): JsonlSummaryResult<S> {\n  return {\n    state: entry.state,\n    size: entry.size,\n    mtime: entry.mtime,\n    skippedBytes: entry.skippedBytes,\n  };\n}\n\nfunction reduceLine<S>(reducer: JsonlSummaryReducer<S>, state: S, line: string): S {\n  if (!/\\S/.test(line)) return state;\n  let entry: unknown;\n  try {\n    entry = JSON.parse(line);\n  } catch {\n    entry = undefined;\n  }\n  return reducer.reduce(state, entry);\n}\n\n/** Apply an unterminated line only if it is already valid JSON (i.e. fully written). */\nfunction reduceTentative<S>(reducer: JsonlSummaryReducer<S>, state: S, line: string): S {\n  if (!/\\S/.test(line)) return state;\n  try {\n    return reducer.reduce(state, JSON.parse(line));\n  } catch {\n    return state;\n  }\n}\n"],"names":["fs","DEFAULT_HEAD_BYTES","DEFAULT_TAIL_BYTES","DEFAULT_CHUNK_SIZE","NEWLINE","reduceJsonlContent","reducer","content","state","initial","line","split","reduceLine","IncrementalJsonlSummary","entries","Map","chunkSize","bounds","generation","options","headBytes","tailBytes","size","read","filePath","stat","statSync","delete","cached","get","sameFile","undefined","dev","ino","mtimeMs","seen","toResult","appended","entry","mtime","offset","discarding","committed","skippedBytes","fd","openSync","readBounded","readRange","closeSync","set","prune","tailStart","head","skip","end","chunk","Buffer","allocUnsafe","Math","min","max","position","carry","bytesRead","readSync","length","lineStart","newline","indexOf","lineBytes","concat","subarray","toString","rest","from","reduceTentative","test","JSON","parse","reduce"],"mappings":"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"}

package/dist/utils/jsonlTail.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Tail reader for append-only JSONL transcripts.
+ *
+ * Reading the last N conversation messages from a large transcript should not
+ * require reading (and JSON-parsing) the whole file. This reader:
+ *
+ * 1. On the first call for a file, reads backward from the end in fixed-size
+ *    chunks until enough messages are collected (or the start is reached).
+ * 2. Remembers `{dev, ino, offset}` plus a small window of parsed items, and
+ *    on later calls parses only bytes appended since `offset`.
+ * 3. Resets (re-reads from the end) when the file is truncated or replaced by
+ *    a different inode.
+ *
+ * Each adapter supplies a {@link JsonlTailSource}: `parseLine` maps one raw
+ * line to a candidate item (or null) and the optional `finalize` turns a
+ * contiguous window of items into messages. `finalize` exists for formats
+ * where one line's visibility depends on other lines (e.g. Codex drops an
+ * `event_msg` mirrored by a `response_item`); line-independent formats can
+ * omit it and return a {@link ConversationMessage} directly from `parseLine`.
+ */
+import type { ConversationMessage } from "../adapters/AgentAdapter.js";
+/**
+ * Normalize a `tail` option: a positive integer, or undefined for "full
+ * conversation" (the pre-existing behaviour).
+ */
+export declare function normalizeTail(tail: number | undefined): number | undefined;
+/** Keep the last `tail` messages of an already fully-parsed conversation. */
+export declare function sliceTail<T>(messages: T[], tail: number | undefined): T[];
+export declare const DEFAULT_TAIL_CHUNK_SIZE: number;
+export interface JsonlTailSource<Item> {
+    /** Map one raw JSONL line (no trailing newline) to an item, or null to skip it. */
+    parseLine(line: string): Item | null;
+    /**
+     * Convert a contiguous window of items (oldest first) into messages. Must
+     * behave like the adapter's full parse restricted to that window. Defaults
+     * to treating every item as a {@link ConversationMessage}.
+     */
+    finalize?(items: Item[]): ConversationMessage[];
+}
+export interface JsonlTailReaderOptions {
+    /** Bytes read per backward step. Defaults to 64 KiB. */
+    chunkSize?: number;
+    /** Number of (file, variant, tail) windows kept in the LRU cache. */
+    maxFiles?: number;
+}
+export declare class JsonlTailReader {
+    private readonly chunkSize;
+    private readonly maxFiles;
+    private readonly cache;
+    constructor(options?: JsonlTailReaderOptions);
+    /**
+     * Return the last `tail` messages of `filePath`.
+     *
+     * @param variant  Cache discriminator for sources whose output differs by
+     *                 option (e.g. verbose vs. non-verbose).
+     * @param overscan Extra messages collected beyond `tail` before trimming,
+     *                 for sources whose `finalize` looks at neighbouring lines.
+     */
+    read<Item>(filePath: string, tail: number, source: JsonlTailSource<Item>, variant?: string, overscan?: number): ConversationMessage[];
+    /** Forget all cached windows. */
+    clear(): void;
+    private readBackward;
+    /**
+     * Parse bytes appended since the cached offset. Returns null when the
+     * bytes before the offset no longer match (file rewritten in place).
+     */
+    private readAppended;
+    private parse;
+    private countMessages;
+    private finish;
+    private touch;
+}
+//# sourceMappingURL=jsonlTail.d.ts.map

package/dist/utils/jsonlTail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonlTail.d.ts","sourceRoot":"","sources":["../../src/utils/jsonlTail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAI1E;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,EAAE,CAGzE;AAED,eAAO,MAAM,uBAAuB,QAAY,CAAC;AAKjD,MAAM,WAAW,eAAe,CAAC,IAAI;IACnC,mFAAmF;IACnF,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,mBAAmB,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,sBAAsB;IACrC,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAoBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;gBAE1C,OAAO,GAAE,sBAA2B;IAKhD;;;;;;;OAOG;IACH,IAAI,CAAC,IAAI,EACP,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,EAC7B,OAAO,SAAK,EACZ,QAAQ,SAAI,GACX,mBAAmB,EAAE;IAuDxB,iCAAiC;IACjC,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,YAAY;IAkEpB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAoDpB,OAAO,CAAC,KAAK;IAMb,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,KAAK;CASd"}

package/dist/utils/jsonlTail.js

@@ -0,0 +1,238 @@
+/**
+ * Tail reader for append-only JSONL transcripts.
+ *
+ * Reading the last N conversation messages from a large transcript should not
+ * require reading (and JSON-parsing) the whole file. This reader:
+ *
+ * 1. On the first call for a file, reads backward from the end in fixed-size
+ *    chunks until enough messages are collected (or the start is reached).
+ * 2. Remembers `{dev, ino, offset}` plus a small window of parsed items, and
+ *    on later calls parses only bytes appended since `offset`.
+ * 3. Resets (re-reads from the end) when the file is truncated or replaced by
+ *    a different inode.
+ *
+ * Each adapter supplies a {@link JsonlTailSource}: `parseLine` maps one raw
+ * line to a candidate item (or null) and the optional `finalize` turns a
+ * contiguous window of items into messages. `finalize` exists for formats
+ * where one line's visibility depends on other lines (e.g. Codex drops an
+ * `event_msg` mirrored by a `response_item`); line-independent formats can
+ * omit it and return a {@link ConversationMessage} directly from `parseLine`.
+ */ import * as fs from "fs";
+/**
+ * Normalize a `tail` option: a positive integer, or undefined for "full
+ * conversation" (the pre-existing behaviour).
+ */ export function normalizeTail(tail) {
+    if (tail === undefined || !Number.isFinite(tail)) return undefined;
+    const n = Math.floor(tail);
+    return n > 0 ? n : undefined;
+}
+/** Keep the last `tail` messages of an already fully-parsed conversation. */ export function sliceTail(messages, tail) {
+    const n = normalizeTail(tail);
+    return n !== undefined && messages.length > n ? messages.slice(-n) : messages;
+}
+export const DEFAULT_TAIL_CHUNK_SIZE = 64 * 1024;
+const DEFAULT_MAX_FILES = 16;
+const NEWLINE = 0x0a;
+const ANCHOR_BYTES = 32;
+export class JsonlTailReader {
+    chunkSize;
+    maxFiles;
+    cache = new Map();
+    constructor(options = {}){
+        this.chunkSize = Math.max(1, options.chunkSize ?? DEFAULT_TAIL_CHUNK_SIZE);
+        this.maxFiles = Math.max(1, options.maxFiles ?? DEFAULT_MAX_FILES);
+    }
+    /**
+   * Return the last `tail` messages of `filePath`.
+   *
+   * @param variant  Cache discriminator for sources whose output differs by
+   *                 option (e.g. verbose vs. non-verbose).
+   * @param overscan Extra messages collected beyond `tail` before trimming,
+   *                 for sources whose `finalize` looks at neighbouring lines.
+   */ read(filePath, tail, source, variant = "", overscan = 0) {
+        const key = `${variant}\0${tail}\0${filePath}`;
+        const threshold = tail + Math.max(0, overscan);
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        } catch  {
+            this.cache.delete(key);
+            return [];
+        }
+        const cached = this.cache.get(key);
+        if (cached && cached.dev === stat.dev && cached.ino === stat.ino && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+            this.touch(key, cached);
+            return cached.result.slice();
+        }
+        let fd;
+        try {
+            fd = fs.openSync(filePath, "r");
+        } catch  {
+            this.cache.delete(key);
+            return [];
+        }
+        try {
+            const current = fs.fstatSync(fd);
+            const canAppend = cached !== undefined && cached.dev === current.dev && cached.ino === current.ino && current.size >= cached.offset && // A very large append is cheaper to re-read from the end.
+            current.size - cached.offset <= Math.max(this.chunkSize * 16, 1024 * 1024);
+            const state = canAppend && this.readAppended(fd, current, cached, tail, threshold, source) || this.readBackward(fd, current, tail, threshold, source);
+            this.touch(key, state);
+            return state.result.slice();
+        } catch  {
+            this.cache.delete(key);
+            return [];
+        } finally{
+            fs.closeSync(fd);
+        }
+    }
+    /** Forget all cached windows. */ clear() {
+        this.cache.clear();
+    }
+    readBackward(fd, stat, tail, threshold, source) {
+        const reversed = [];
+        let partial = null;
+        let offset = 0;
+        let sawNewline = false;
+        // Pieces of the line currently being assembled, in file order.
+        let pending = [];
+        let pos = stat.size;
+        const takeLine = (piece)=>{
+            const lineBuf = pending.length === 0 ? piece : Buffer.concat([
+                piece,
+                ...pending
+            ]);
+            pending = [];
+            if (!sawNewline) {
+                // Bytes after the file's last newline: an unterminated (possibly
+                // still being written) line. Parsed tentatively, never cached.
+                sawNewline = true;
+                partial = this.parse(lineBuf, source);
+                return;
+            }
+            const item = this.parse(lineBuf, source);
+            if (item !== null) reversed.push(item);
+        };
+        while(pos > 0){
+            const len = Math.min(this.chunkSize, pos);
+            pos -= len;
+            const buf = readExactly(fd, pos, len);
+            let end = len;
+            let nl = end > 0 ? buf.lastIndexOf(NEWLINE, end - 1) : -1;
+            while(nl !== -1){
+                if (!sawNewline) offset = pos + nl + 1;
+                takeLine(buf.subarray(nl + 1, end));
+                end = nl;
+                nl = end > 0 ? buf.lastIndexOf(NEWLINE, end - 1) : -1;
+            }
+            if (end > 0) pending.unshift(buf.subarray(0, end));
+            if (this.countMessages(reversed, partial, source, threshold) >= threshold) break;
+        }
+        if (pos === 0 && pending.length > 0) {
+            // The first line of the file (no newline before it).
+            const first = pending.shift();
+            takeLine(first);
+        }
+        const items = reversed.reverse();
+        return {
+            dev: stat.dev,
+            ino: stat.ino,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            offset,
+            anchor: readAnchor(fd, offset),
+            items,
+            result: this.finish(items, partial, source, tail)
+        };
+    }
+    /**
+   * Parse bytes appended since the cached offset. Returns null when the
+   * bytes before the offset no longer match (file rewritten in place).
+   */ readAppended(fd, stat, cached, tail, threshold, source) {
+        let items = cached.items;
+        let offset = cached.offset;
+        let partial = null;
+        const anchorLength = cached.anchor.length;
+        const raw = readExactly(fd, cached.offset - anchorLength, stat.size - offset + anchorLength);
+        if (!raw.subarray(0, anchorLength).equals(cached.anchor)) return null;
+        const buf = raw.subarray(anchorLength);
+        let anchor = cached.anchor;
+        if (buf.length > 0) {
+            const added = [];
+            let start = 0;
+            let nl = buf.indexOf(NEWLINE, start);
+            while(nl !== -1){
+                const item = this.parse(buf.subarray(start, nl), source);
+                if (item !== null) added.push(item);
+                start = nl + 1;
+                nl = buf.indexOf(NEWLINE, start);
+            }
+            offset = cached.offset + start;
+            if (start > 0) anchor = tailBytes(raw.subarray(0, anchorLength + start));
+            if (start < buf.length) partial = this.parse(buf.subarray(start), source);
+            if (added.length > 0) {
+                items = items.concat(added);
+                // Bound the retained window; keep a generous margin so sources whose
+                // finalize() drops items (e.g. de-duplication) still cover `tail`.
+                if (items.length > threshold * 4) items = items.slice(-threshold * 2);
+            }
+        }
+        return {
+            dev: stat.dev,
+            ino: stat.ino,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            offset,
+            anchor,
+            items,
+            result: this.finish(items, partial, source, tail)
+        };
+    }
+    parse(lineBuf, source) {
+        const line = lineBuf.toString("utf-8");
+        if (line.trim().length === 0) return null;
+        return source.parseLine(line);
+    }
+    countMessages(reversed, partial, source, threshold) {
+        const available = reversed.length + (partial === null ? 0 : 1);
+        if (!source.finalize || available < threshold) return available;
+        const window = reversed.slice().reverse();
+        if (partial !== null) window.push(partial);
+        return source.finalize(window).length;
+    }
+    finish(items, partial, source, tail) {
+        const window = partial === null ? items : [
+            ...items,
+            partial
+        ];
+        const messages = source.finalize ? source.finalize(window) : window.slice();
+        return messages.length > tail ? messages.slice(-tail) : messages;
+    }
+    touch(key, state) {
+        this.cache.delete(key);
+        this.cache.set(key, state);
+        while(this.cache.size > this.maxFiles){
+            const oldest = this.cache.keys().next().value;
+            if (oldest === undefined) break;
+            this.cache.delete(oldest);
+        }
+    }
+}
+function readExactly(fd, position, length) {
+    const buf = Buffer.allocUnsafe(length);
+    let filled = 0;
+    while(filled < length){
+        const n = fs.readSync(fd, buf, filled, length - filled, position + filled);
+        if (n === 0) break;
+        filled += n;
+    }
+    return filled === length ? buf : buf.subarray(0, filled);
+}
+function readAnchor(fd, offset) {
+    const start = Math.max(0, offset - ANCHOR_BYTES);
+    return Buffer.from(readExactly(fd, start, offset - start));
+}
+function tailBytes(buf) {
+    return Buffer.from(buf.subarray(Math.max(0, buf.length - ANCHOR_BYTES)));
+}
+
+//# sourceMappingURL=jsonlTail.js.map

package/dist/utils/jsonlTail.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/jsonlTail.ts"],"sourcesContent":["/**\n * Tail reader for append-only JSONL transcripts.\n *\n * Reading the last N conversation messages from a large transcript should not\n * require reading (and JSON-parsing) the whole file. This reader:\n *\n * 1. On the first call for a file, reads backward from the end in fixed-size\n *    chunks until enough messages are collected (or the start is reached).\n * 2. Remembers `{dev, ino, offset}` plus a small window of parsed items, and\n *    on later calls parses only bytes appended since `offset`.\n * 3. Resets (re-reads from the end) when the file is truncated or replaced by\n *    a different inode.\n *\n * Each adapter supplies a {@link JsonlTailSource}: `parseLine` maps one raw\n * line to a candidate item (or null) and the optional `finalize` turns a\n * contiguous window of items into messages. `finalize` exists for formats\n * where one line's visibility depends on other lines (e.g. Codex drops an\n * `event_msg` mirrored by a `response_item`); line-independent formats can\n * omit it and return a {@link ConversationMessage} directly from `parseLine`.\n */\n\nimport * as fs from \"fs\";\nimport type { ConversationMessage } from \"../adapters/AgentAdapter.js\";\n\n/**\n * Normalize a `tail` option: a positive integer, or undefined for \"full\n * conversation\" (the pre-existing behaviour).\n */\nexport function normalizeTail(tail: number | undefined): number | undefined {\n  if (tail === undefined || !Number.isFinite(tail)) return undefined;\n  const n = Math.floor(tail);\n  return n > 0 ? n : undefined;\n}\n\n/** Keep the last `tail` messages of an already fully-parsed conversation. */\nexport function sliceTail<T>(messages: T[], tail: number | undefined): T[] {\n  const n = normalizeTail(tail);\n  return n !== undefined && messages.length > n ? messages.slice(-n) : messages;\n}\n\nexport const DEFAULT_TAIL_CHUNK_SIZE = 64 * 1024;\nconst DEFAULT_MAX_FILES = 16;\nconst NEWLINE = 0x0a;\nconst ANCHOR_BYTES = 32;\n\nexport interface JsonlTailSource<Item> {\n  /** Map one raw JSONL line (no trailing newline) to an item, or null to skip it. */\n  parseLine(line: string): Item | null;\n  /**\n   * Convert a contiguous window of items (oldest first) into messages. Must\n   * behave like the adapter's full parse restricted to that window. Defaults\n   * to treating every item as a {@link ConversationMessage}.\n   */\n  finalize?(items: Item[]): ConversationMessage[];\n}\n\nexport interface JsonlTailReaderOptions {\n  /** Bytes read per backward step. Defaults to 64 KiB. */\n  chunkSize?: number;\n  /** Number of (file, variant, tail) windows kept in the LRU cache. */\n  maxFiles?: number;\n}\n\ninterface TailState {\n  dev: number;\n  ino: number;\n  size: number;\n  mtimeMs: number;\n  /** Byte offset just past the last newline consumed; appends are read from here. */\n  offset: number;\n  /**\n   * Up to {@link ANCHOR_BYTES} bytes ending at `offset`. Re-checked before an\n   * incremental read so a same-inode truncate-and-regrow is detected.\n   */\n  anchor: Buffer;\n  /** Parsed items from complete (newline-terminated) lines, oldest first. */\n  items: unknown[];\n  /** Last computed result, returned as-is while the file is unchanged. */\n  result: ConversationMessage[];\n}\n\nexport class JsonlTailReader {\n  private readonly chunkSize: number;\n  private readonly maxFiles: number;\n  private readonly cache = new Map<string, TailState>();\n\n  constructor(options: JsonlTailReaderOptions = {}) {\n    this.chunkSize = Math.max(1, options.chunkSize ?? DEFAULT_TAIL_CHUNK_SIZE);\n    this.maxFiles = Math.max(1, options.maxFiles ?? DEFAULT_MAX_FILES);\n  }\n\n  /**\n   * Return the last `tail` messages of `filePath`.\n   *\n   * @param variant  Cache discriminator for sources whose output differs by\n   *                 option (e.g. verbose vs. non-verbose).\n   * @param overscan Extra messages collected beyond `tail` before trimming,\n   *                 for sources whose `finalize` looks at neighbouring lines.\n   */\n  read<Item>(\n    filePath: string,\n    tail: number,\n    source: JsonlTailSource<Item>,\n    variant = \"\",\n    overscan = 0,\n  ): ConversationMessage[] {\n    const key = `${variant}\\0${tail}\\0${filePath}`;\n    const threshold = tail + Math.max(0, overscan);\n\n    let stat: fs.Stats;\n    try {\n      stat = fs.statSync(filePath);\n    } catch {\n      this.cache.delete(key);\n      return [];\n    }\n\n    const cached = this.cache.get(key);\n    if (\n      cached &&\n      cached.dev === stat.dev &&\n      cached.ino === stat.ino &&\n      cached.size === stat.size &&\n      cached.mtimeMs === stat.mtimeMs\n    ) {\n      this.touch(key, cached);\n      return cached.result.slice();\n    }\n\n    let fd: number;\n    try {\n      fd = fs.openSync(filePath, \"r\");\n    } catch {\n      this.cache.delete(key);\n      return [];\n    }\n\n    try {\n      const current = fs.fstatSync(fd);\n      const canAppend =\n        cached !== undefined &&\n        cached.dev === current.dev &&\n        cached.ino === current.ino &&\n        current.size >= cached.offset &&\n        // A very large append is cheaper to re-read from the end.\n        current.size - cached.offset <= Math.max(this.chunkSize * 16, 1024 * 1024);\n\n      const state =\n        (canAppend && this.readAppended(fd, current, cached, tail, threshold, source)) ||\n        this.readBackward(fd, current, tail, threshold, source);\n      this.touch(key, state);\n      return state.result.slice();\n    } catch {\n      this.cache.delete(key);\n      return [];\n    } finally {\n      fs.closeSync(fd);\n    }\n  }\n\n  /** Forget all cached windows. */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  private readBackward<Item>(\n    fd: number,\n    stat: fs.Stats,\n    tail: number,\n    threshold: number,\n    source: JsonlTailSource<Item>,\n  ): TailState {\n    const reversed: Item[] = [];\n    let partial: Item | null = null;\n    let offset = 0;\n    let sawNewline = false;\n    // Pieces of the line currently being assembled, in file order.\n    let pending: Buffer[] = [];\n    let pos = stat.size;\n\n    const takeLine = (piece: Buffer): void => {\n      const lineBuf = pending.length === 0 ? piece : Buffer.concat([piece, ...pending]);\n      pending = [];\n      if (!sawNewline) {\n        // Bytes after the file's last newline: an unterminated (possibly\n        // still being written) line. Parsed tentatively, never cached.\n        sawNewline = true;\n        partial = this.parse(lineBuf, source);\n        return;\n      }\n      const item = this.parse(lineBuf, source);\n      if (item !== null) reversed.push(item);\n    };\n\n    while (pos > 0) {\n      const len = Math.min(this.chunkSize, pos);\n      pos -= len;\n      const buf = readExactly(fd, pos, len);\n\n      let end = len;\n      let nl = end > 0 ? buf.lastIndexOf(NEWLINE, end - 1) : -1;\n      while (nl !== -1) {\n        if (!sawNewline) offset = pos + nl + 1;\n        takeLine(buf.subarray(nl + 1, end));\n        end = nl;\n        nl = end > 0 ? buf.lastIndexOf(NEWLINE, end - 1) : -1;\n      }\n      if (end > 0) pending.unshift(buf.subarray(0, end));\n\n      if (this.countMessages(reversed, partial, source, threshold) >= threshold) break;\n    }\n\n    if (pos === 0 && pending.length > 0) {\n      // The first line of the file (no newline before it).\n      const first = pending.shift()!;\n      takeLine(first);\n    }\n\n    const items = reversed.reverse();\n    return {\n      dev: stat.dev,\n      ino: stat.ino,\n      size: stat.size,\n      mtimeMs: stat.mtimeMs,\n      offset,\n      anchor: readAnchor(fd, offset),\n      items,\n      result: this.finish(items, partial, source, tail),\n    };\n  }\n\n  /**\n   * Parse bytes appended since the cached offset. Returns null when the\n   * bytes before the offset no longer match (file rewritten in place).\n   */\n  private readAppended<Item>(\n    fd: number,\n    stat: fs.Stats,\n    cached: TailState,\n    tail: number,\n    threshold: number,\n    source: JsonlTailSource<Item>,\n  ): TailState | null {\n    let items = cached.items as Item[];\n    let offset = cached.offset;\n    let partial: Item | null = null;\n\n    const anchorLength = cached.anchor.length;\n    const raw = readExactly(fd, cached.offset - anchorLength, stat.size - offset + anchorLength);\n    if (!raw.subarray(0, anchorLength).equals(cached.anchor)) return null;\n    const buf = raw.subarray(anchorLength);\n    let anchor = cached.anchor;\n\n    if (buf.length > 0) {\n      const added: Item[] = [];\n      let start = 0;\n      let nl = buf.indexOf(NEWLINE, start);\n      while (nl !== -1) {\n        const item = this.parse(buf.subarray(start, nl), source);\n        if (item !== null) added.push(item);\n        start = nl + 1;\n        nl = buf.indexOf(NEWLINE, start);\n      }\n      offset = cached.offset + start;\n      if (start > 0) anchor = tailBytes(raw.subarray(0, anchorLength + start));\n      if (start < buf.length) partial = this.parse(buf.subarray(start), source);\n\n      if (added.length > 0) {\n        items = items.concat(added);\n        // Bound the retained window; keep a generous margin so sources whose\n        // finalize() drops items (e.g. de-duplication) still cover `tail`.\n        if (items.length > threshold * 4) items = items.slice(-threshold * 2);\n      }\n    }\n\n    return {\n      dev: stat.dev,\n      ino: stat.ino,\n      size: stat.size,\n      mtimeMs: stat.mtimeMs,\n      offset,\n      anchor,\n      items,\n      result: this.finish(items, partial, source, tail),\n    };\n  }\n\n  private parse<Item>(lineBuf: Buffer, source: JsonlTailSource<Item>): Item | null {\n    const line = lineBuf.toString(\"utf-8\");\n    if (line.trim().length === 0) return null;\n    return source.parseLine(line);\n  }\n\n  private countMessages<Item>(\n    reversed: Item[],\n    partial: Item | null,\n    source: JsonlTailSource<Item>,\n    threshold: number,\n  ): number {\n    const available = reversed.length + (partial === null ? 0 : 1);\n    if (!source.finalize || available < threshold) return available;\n    const window = reversed.slice().reverse();\n    if (partial !== null) window.push(partial);\n    return source.finalize(window).length;\n  }\n\n  private finish<Item>(\n    items: Item[],\n    partial: Item | null,\n    source: JsonlTailSource<Item>,\n    tail: number,\n  ): ConversationMessage[] {\n    const window = partial === null ? items : [...items, partial];\n    const messages = source.finalize\n      ? source.finalize(window)\n      : (window as unknown as ConversationMessage[]).slice();\n    return messages.length > tail ? messages.slice(-tail) : messages;\n  }\n\n  private touch(key: string, state: TailState): void {\n    this.cache.delete(key);\n    this.cache.set(key, state);\n    while (this.cache.size > this.maxFiles) {\n      const oldest = this.cache.keys().next().value;\n      if (oldest === undefined) break;\n      this.cache.delete(oldest);\n    }\n  }\n}\n\nfunction readExactly(fd: number, position: number, length: number): Buffer {\n  const buf = Buffer.allocUnsafe(length);\n  let filled = 0;\n  while (filled < length) {\n    const n = fs.readSync(fd, buf, filled, length - filled, position + filled);\n    if (n === 0) break;\n    filled += n;\n  }\n  return filled === length ? buf : buf.subarray(0, filled);\n}\n\nfunction readAnchor(fd: number, offset: number): Buffer {\n  const start = Math.max(0, offset - ANCHOR_BYTES);\n  return Buffer.from(readExactly(fd, start, offset - start));\n}\n\nfunction tailBytes(buf: Buffer): Buffer {\n  return Buffer.from(buf.subarray(Math.max(0, buf.length - ANCHOR_BYTES)));\n}\n"],"names":["fs","normalizeTail","tail","undefined","Number","isFinite","n","Math","floor","sliceTail","messages","length","slice","DEFAULT_TAIL_CHUNK_SIZE","DEFAULT_MAX_FILES","NEWLINE","ANCHOR_BYTES","JsonlTailReader","chunkSize","maxFiles","cache","Map","options","max","read","filePath","source","variant","overscan","key","threshold","stat","statSync","delete","cached","get","dev","ino","size","mtimeMs","touch","result","fd","openSync","current","fstatSync","canAppend","offset","state","readAppended","readBackward","closeSync","clear","reversed","partial","sawNewline","pending","pos","takeLine","piece","lineBuf","Buffer","concat","parse","item","push","len","min","buf","readExactly","end","nl","lastIndexOf","subarray","unshift","countMessages","first","shift","items","reverse","anchor","readAnchor","finish","anchorLength","raw","equals","added","start","indexOf","tailBytes","line","toString","trim","parseLine","available","finalize","window","set","oldest","keys","next","value","position","allocUnsafe","filled","readSync","from"],"mappings":"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"}

package/dist/utils/matching.d.ts

@@ -5,7 +5,9 @@
  * based on CWD and birth-time proximity to process start time.
  */
 import type { ProcessInfo } from "../adapters/AgentAdapter.js";
+import { MATCH_TOLERANCE_MS } from "./matchingConstants.js";
 import type { SessionFile } from "./session.js";
+export { MATCH_TOLERANCE_MS };
 /**
  * Result of matching a process to a session file.
  */

package/dist/utils/matching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matching.d.ts","sourceRoot":"","sources":["../../src/utils/matching.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKhD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0BAA0B;IAC1B,OAAO,EAAE,WAAW,CAAC;IAErB,+BAA+B;IAC/B,OAAO,EAAE,WAAW,CAAC;IAErB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,WAAW,EAAE,EACxB,QAAQ,EAAE,WAAW,EAAE,GACtB,WAAW,EAAE,CAsCf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOlE"}
+{"version":3,"file":"matching.d.ts","sourceRoot":"","sources":["../../src/utils/matching.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0BAA0B;IAC1B,OAAO,EAAE,WAAW,CAAC;IAErB,+BAA+B;IAC/B,OAAO,EAAE,WAAW,CAAC;IAErB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,WAAW,EAAE,EACxB,QAAQ,EAAE,WAAW,EAAE,GACtB,WAAW,EAAE,CAsCf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOlE"}

package/dist/utils/matching.js

@@ -4,7 +4,8 @@
  * Shared 1:1 greedy matching algorithm that pairs running processes with session files
  * based on CWD and birth-time proximity to process start time.
  */ import * as path from "path";
-/** Maximum allowed delta between process start time and session file birth time. */ const TOLERANCE_MS = 3 * 60 * 1000; // 3 minutes
+import { MATCH_TOLERANCE_MS } from "./matchingConstants.js";
+export { MATCH_TOLERANCE_MS };
 /**
  * Match processes to session files using 1:1 greedy assignment.
  *
@@ -26,7 +27,7 @@
             if (!session.resolvedCwd) continue;
             if (proc.cwd !== session.resolvedCwd) continue;
             const deltaMs = Math.abs(processStartMs - session.birthtimeMs);
-            if (deltaMs > TOLERANCE_MS) continue;
+            if (deltaMs > MATCH_TOLERANCE_MS) continue;
             candidates.push({
                 process: proc,
                 session,