@ai-devkit/agent-manager 0.35.0 → 0.37.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/agents.d.ts

@@ -1,5 +1,6 @@
-import type { AgentType } from "../adapters/AgentAdapter.js";
-export type StartableAgentType = Extract<AgentType, "claude" | "codex" | "copilot" | "gemini_cli" | "grok_cli" | "opencode" | "pi">;
+import type { AGENT_TYPES } from "../adapters/AgentAdapter.js";
+/** Every built-in harness can be started, so each needs an {@link AGENTS} entry. */
+export type StartableAgentType = (typeof AGENT_TYPES)[number];
 export interface AgentConfig {
     /** Shell command to launch the agent (sent to tmux via `send-keys`). */
     command: string;

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

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/utils/agents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,SAAS,EACT,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAC/E,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAQ1D,CAAC"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/utils/agents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAU1D,CAAC"}

package/dist/utils/agents.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { executablePath } from "./process.js";
 /**
  * Per-agent configuration: launch command plus a matcher that recognizes the
  * agent's process in `ps` output. Each matcher knows that agent's distribution
@@ -24,6 +25,10 @@ import path from "path";
         command: "grok",
         matches: matchArgv0("grok")
     },
+    antigravity_cli: {
+        command: "agy",
+        matches: matchArgv0("agy")
+    },
     opencode: {
         command: "opencode",
         matches: matchArgv0("opencode")
@@ -33,38 +38,79 @@ import path from "path";
         matches: matchAnyBasename([
             "pi"
         ])
+    },
+    kiro: {
+        command: "kiro-cli",
+        matches: matchAnyBasename([
+            "kiro-cli",
+            "kiro"
+        ])
     }
 };
+/**
+ * Matchers read a `ps` command line, where argv is joined with spaces. argv[0]
+ * is resolved with {@link executablePath} so executables installed under
+ * directories containing spaces are recognised, while arguments are never
+ * folded into the executable path unless that combined path is a real file.
+ *
+ * The filesystem is consulted only when a token after the first could be part
+ * of a matching argv[0]; commands whose first token already decides the match,
+ * or that contain no candidate token at all, are handled with string checks.
+ */ const ABSOLUTE_PATH = /^(?:\/|[a-zA-Z]:[\\/])/;
+const PATH_SEPARATOR = /[\\/]/;
+function basenameOf(token) {
+    return path.basename(token).toLowerCase();
+}
+function tokensOf(psCommand) {
+    return psCommand.trim().split(/\s+/).filter(Boolean);
+}
+/** Split a command line into its resolved argv[0] and the remaining argument tokens. */ function splitArgv0(psCommand) {
+    const command = psCommand.trim();
+    const argv0 = executablePath(command);
+    return {
+        argv0,
+        args: tokensOf(command.slice(argv0.length))
+    };
+}
+/** Whether argv[0] may span several tokens, i.e. a later path-like token satisfies `test`. */ function mayContinueArgv0(tokens, test) {
+    return ABSOLUTE_PATH.test(tokens[0]) && tokens.slice(1).some((token)=>PATH_SEPARATOR.test(token) && test(token));
+}
 function matchArgv0(name) {
     const lower = name.toLowerCase();
+    const test = (token)=>basenameOf(token) === lower;
     return (psCommand)=>{
-        const token = psCommand.trim().split(/\s+/)[0];
-        return token ? path.basename(token).toLowerCase() === lower : false;
+        const tokens = tokensOf(psCommand);
+        if (tokens.length === 0) return false;
+        if (test(tokens[0])) return true;
+        return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));
     };
 }
 function matchArgv0Name(name) {
     const lower = name.toLowerCase();
+    const test = (token)=>token.toLowerCase().includes(lower);
     return (psCommand)=>{
-        const token = psCommand.trim().split(/\s+/)[0];
-        return token ? token.toLowerCase().includes(lower) : false;
+        const tokens = tokensOf(psCommand);
+        if (tokens.length === 0) return false;
+        if (test(tokens[0])) return true;
+        return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));
     };
 }
 function matchAnyToken(name) {
-    const lower = name.toLowerCase();
-    return (psCommand)=>{
-        for (const token of psCommand.trim().split(/\s+/)){
-            if (path.basename(token).toLowerCase() === lower) return true;
-        }
-        return false;
-    };
+    return matchAnyBasename([
+        name
+    ]);
 }
 function matchAnyBasename(names) {
     const lowers = new Set(names.map((name)=>name.toLowerCase()));
+    const test = (token)=>lowers.has(basenameOf(token));
     return (psCommand)=>{
-        for (const token of psCommand.trim().split(/\s+/)){
-            if (lowers.has(path.basename(token).toLowerCase())) return true;
-        }
-        return false;
+        const tokens = tokensOf(psCommand);
+        if (tokens.length === 0) return false;
+        if (test(tokens[0])) return true;
+        if (!tokens.slice(1).some(test)) return false;
+        if (!ABSOLUTE_PATH.test(tokens[0])) return true;
+        const { argv0, args } = splitArgv0(psCommand);
+        return test(argv0) || args.some(test);
     };
 }
 

package/dist/utils/agents.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/agents.ts"],"sourcesContent":["import path from \"path\";\nimport type { AgentType } from \"../adapters/AgentAdapter.js\";\n\nexport type StartableAgentType = Extract<\n  AgentType,\n  \"claude\" | \"codex\" | \"copilot\" | \"gemini_cli\" | \"grok_cli\" | \"opencode\" | \"pi\"\n>;\n\nexport interface AgentConfig {\n  /** Shell command to launch the agent (sent to tmux via `send-keys`). */\n  command: string;\n  /** Returns true if the given `ps` command line belongs to this agent. */\n  matches: (psCommand: string) => boolean;\n}\n\n/**\n * Per-agent configuration: launch command plus a matcher that recognizes the\n * agent's process in `ps` output. Each matcher knows that agent's distribution\n * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).\n */\nexport const AGENTS: Record<StartableAgentType, AgentConfig> = {\n  claude: { command: \"claude\", matches: matchArgv0(\"claude\") },\n  codex: { command: \"codex\", matches: matchArgv0(\"codex\") },\n  copilot: { command: \"copilot\", matches: matchArgv0Name(\"copilot-cli\") },\n  gemini_cli: { command: \"gemini\", matches: matchAnyToken(\"gemini\") },\n  grok_cli: { command: \"grok\", matches: matchArgv0(\"grok\") },\n  opencode: { command: \"opencode\", matches: matchArgv0(\"opencode\") },\n  pi: { command: \"pi\", matches: matchAnyBasename([\"pi\"]) },\n};\n\nfunction matchArgv0(name: string): (psCommand: string) => boolean {\n  const lower = name.toLowerCase();\n  return (psCommand) => {\n    const token = psCommand.trim().split(/\\s+/)[0];\n    return token ? path.basename(token).toLowerCase() === lower : false;\n  };\n}\n\nfunction matchArgv0Name(name: string): (psCommand: string) => boolean {\n  const lower = name.toLowerCase();\n  return (psCommand) => {\n    const token = psCommand.trim().split(/\\s+/)[0];\n    return token ? token.toLowerCase().includes(lower) : false;\n  };\n}\n\nfunction matchAnyToken(name: string): (psCommand: string) => boolean {\n  const lower = name.toLowerCase();\n  return (psCommand) => {\n    for (const token of psCommand.trim().split(/\\s+/)) {\n      if (path.basename(token).toLowerCase() === lower) return true;\n    }\n    return false;\n  };\n}\n\nfunction matchAnyBasename(names: string[]): (psCommand: string) => boolean {\n  const lowers = new Set(names.map((name) => name.toLowerCase()));\n  return (psCommand) => {\n    for (const token of psCommand.trim().split(/\\s+/)) {\n      if (lowers.has(path.basename(token).toLowerCase())) return true;\n    }\n    return false;\n  };\n}\n"],"names":["path","AGENTS","claude","command","matches","matchArgv0","codex","copilot","matchArgv0Name","gemini_cli","matchAnyToken","grok_cli","opencode","pi","matchAnyBasename","name","lower","toLowerCase","psCommand","token","trim","split","basename","includes","names","lowers","Set","map","has"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAexB;;;;CAIC,GACD,OAAO,MAAMC,SAAkD;IAC7DC,QAAQ;QAAEC,SAAS;QAAUC,SAASC,WAAW;IAAU;IAC3DC,OAAO;QAAEH,SAAS;QAASC,SAASC,WAAW;IAAS;IACxDE,SAAS;QAAEJ,SAAS;QAAWC,SAASI,eAAe;IAAe;IACtEC,YAAY;QAAEN,SAAS;QAAUC,SAASM,cAAc;IAAU;IAClEC,UAAU;QAAER,SAAS;QAAQC,SAASC,WAAW;IAAQ;IACzDO,UAAU;QAAET,SAAS;QAAYC,SAASC,WAAW;IAAY;IACjEQ,IAAI;QAAEV,SAAS;QAAMC,SAASU,iBAAiB;YAAC;SAAK;IAAE;AACzD,EAAE;AAEF,SAAST,WAAWU,IAAY;IAC9B,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACN,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQnB,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,QAAQ;IAChE;AACF;AAEA,SAASR,eAAeO,IAAY;IAClC,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACN,MAAMC,QAAQD,UAAUE,IAAI,GAAGC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9C,OAAOF,QAAQA,MAAMF,WAAW,GAAGM,QAAQ,CAACP,SAAS;IACvD;AACF;AAEA,SAASN,cAAcK,IAAY;IACjC,MAAMC,QAAQD,KAAKE,WAAW;IAC9B,OAAO,CAACC;QACN,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YACjD,IAAIrB,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,OAAOD,OAAO,OAAO;QAC3D;QACA,OAAO;IACT;AACF;AAEA,SAASF,iBAAiBU,KAAe;IACvC,MAAMC,SAAS,IAAIC,IAAIF,MAAMG,GAAG,CAAC,CAACZ,OAASA,KAAKE,WAAW;IAC3D,OAAO,CAACC;QACN,KAAK,MAAMC,SAASD,UAAUE,IAAI,GAAGC,KAAK,CAAC,OAAQ;YACjD,IAAII,OAAOG,GAAG,CAAC5B,KAAKsB,QAAQ,CAACH,OAAOF,WAAW,KAAK,OAAO;QAC7D;QACA,OAAO;IACT;AACF"}
+{"version":3,"sources":["../../src/utils/agents.ts"],"sourcesContent":["import path from \"path\";\nimport type { AGENT_TYPES } from \"../adapters/AgentAdapter.js\";\nimport { executablePath } from \"./process.js\";\n\n/** Every built-in harness can be started, so each needs an {@link AGENTS} entry. */\nexport type StartableAgentType = (typeof AGENT_TYPES)[number];\n\nexport interface AgentConfig {\n  /** Shell command to launch the agent (sent to tmux via `send-keys`). */\n  command: string;\n  /** Returns true if the given `ps` command line belongs to this agent. */\n  matches: (psCommand: string) => boolean;\n}\n\n/**\n * Per-agent configuration: launch command plus a matcher that recognizes the\n * agent's process in `ps` output. Each matcher knows that agent's distribution\n * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).\n */\nexport const AGENTS: Record<StartableAgentType, AgentConfig> = {\n  claude: { command: \"claude\", matches: matchArgv0(\"claude\") },\n  codex: { command: \"codex\", matches: matchArgv0(\"codex\") },\n  copilot: { command: \"copilot\", matches: matchArgv0Name(\"copilot-cli\") },\n  gemini_cli: { command: \"gemini\", matches: matchAnyToken(\"gemini\") },\n  grok_cli: { command: \"grok\", matches: matchArgv0(\"grok\") },\n  antigravity_cli: { command: \"agy\", matches: matchArgv0(\"agy\") },\n  opencode: { command: \"opencode\", matches: matchArgv0(\"opencode\") },\n  pi: { command: \"pi\", matches: matchAnyBasename([\"pi\"]) },\n  kiro: { command: \"kiro-cli\", matches: matchAnyBasename([\"kiro-cli\", \"kiro\"]) },\n};\n\n/**\n * Matchers read a `ps` command line, where argv is joined with spaces. argv[0]\n * is resolved with {@link executablePath} so executables installed under\n * directories containing spaces are recognised, while arguments are never\n * folded into the executable path unless that combined path is a real file.\n *\n * The filesystem is consulted only when a token after the first could be part\n * of a matching argv[0]; commands whose first token already decides the match,\n * or that contain no candidate token at all, are handled with string checks.\n */\nconst ABSOLUTE_PATH = /^(?:\\/|[a-zA-Z]:[\\\\/])/;\nconst PATH_SEPARATOR = /[\\\\/]/;\n\nfunction basenameOf(token: string): string {\n  return path.basename(token).toLowerCase();\n}\n\nfunction tokensOf(psCommand: string): string[] {\n  return psCommand.trim().split(/\\s+/).filter(Boolean);\n}\n\n/** Split a command line into its resolved argv[0] and the remaining argument tokens. */\nfunction splitArgv0(psCommand: string): { argv0: string; args: string[] } {\n  const command = psCommand.trim();\n  const argv0 = executablePath(command);\n  return { argv0, args: tokensOf(command.slice(argv0.length)) };\n}\n\n/** Whether argv[0] may span several tokens, i.e. a later path-like token satisfies `test`. */\nfunction mayContinueArgv0(tokens: string[], test: (token: string) => boolean): boolean {\n  return (\n    ABSOLUTE_PATH.test(tokens[0]) &&\n    tokens.slice(1).some((token) => PATH_SEPARATOR.test(token) && test(token))\n  );\n}\n\nfunction matchArgv0(name: string): (psCommand: string) => boolean {\n  const lower = name.toLowerCase();\n  const test = (token: string) => basenameOf(token) === lower;\n  return (psCommand) => {\n    const tokens = tokensOf(psCommand);\n    if (tokens.length === 0) return false;\n    if (test(tokens[0])) return true;\n    return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));\n  };\n}\n\nfunction matchArgv0Name(name: string): (psCommand: string) => boolean {\n  const lower = name.toLowerCase();\n  const test = (token: string) => token.toLowerCase().includes(lower);\n  return (psCommand) => {\n    const tokens = tokensOf(psCommand);\n    if (tokens.length === 0) return false;\n    if (test(tokens[0])) return true;\n    return mayContinueArgv0(tokens, test) && test(executablePath(psCommand));\n  };\n}\n\nfunction matchAnyToken(name: string): (psCommand: string) => boolean {\n  return matchAnyBasename([name]);\n}\n\nfunction matchAnyBasename(names: string[]): (psCommand: string) => boolean {\n  const lowers = new Set(names.map((name) => name.toLowerCase()));\n  const test = (token: string) => lowers.has(basenameOf(token));\n  return (psCommand) => {\n    const tokens = tokensOf(psCommand);\n    if (tokens.length === 0) return false;\n    if (test(tokens[0])) return true;\n    if (!tokens.slice(1).some(test)) return false;\n    if (!ABSOLUTE_PATH.test(tokens[0])) return true;\n\n    const { argv0, args } = splitArgv0(psCommand);\n    return test(argv0) || args.some(test);\n  };\n}\n"],"names":["path","executablePath","AGENTS","claude","command","matches","matchArgv0","codex","copilot","matchArgv0Name","gemini_cli","matchAnyToken","grok_cli","antigravity_cli","opencode","pi","matchAnyBasename","kiro","ABSOLUTE_PATH","PATH_SEPARATOR","basenameOf","token","basename","toLowerCase","tokensOf","psCommand","trim","split","filter","Boolean","splitArgv0","argv0","args","slice","length","mayContinueArgv0","tokens","test","some","name","lower","includes","names","lowers","Set","map","has"],"mappings":"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"}

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
-export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses, captureProcessSnapshot, } from "./process.js";
+export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses, captureProcessSnapshot, createProcessSnapshotCapture, } from "./process.js";
+export type { ProcessExec, ProcessSnapshotCapture, ProcessSnapshotOptions } from "./process.js";
 export { getProcessTty } from "./process.js";
 export { batchGetSessionFileBirthtimes } from "./session.js";
 export type { SessionFile } from "./session.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EACf,sBAAsB,GACvB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC5E,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EACf,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC5E,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/utils/index.js

@@ -1,4 +1,4 @@
-export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses, captureProcessSnapshot } from "./process.js";
+export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses, captureProcessSnapshot, createProcessSnapshotCapture } from "./process.js";
 export { getProcessTty } from "./process.js";
 export { batchGetSessionFileBirthtimes } from "./session.js";
 export { matchProcessesToSessions, generateAgentName } from "./matching.js";

package/dist/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/index.ts"],"sourcesContent":["export {\n  listAgentProcesses,\n  batchGetProcessCwds,\n  batchGetProcessStartTimes,\n  enrichProcesses,\n  captureProcessSnapshot,\n} from \"./process.js\";\nexport { getProcessTty } from \"./process.js\";\nexport { batchGetSessionFileBirthtimes } from \"./session.js\";\nexport type { SessionFile } from \"./session.js\";\nexport { matchProcessesToSessions, generateAgentName } from \"./matching.js\";\nexport type { MatchResult } from \"./matching.js\";\n"],"names":["listAgentProcesses","batchGetProcessCwds","batchGetProcessStartTimes","enrichProcesses","captureProcessSnapshot","getProcessTty","batchGetSessionFileBirthtimes","matchProcessesToSessions","generateAgentName"],"mappings":"AAAA,SACEA,kBAAkB,EAClBC,mBAAmB,EACnBC,yBAAyB,EACzBC,eAAe,EACfC,sBAAsB,QACjB,eAAe;AACtB,SAASC,aAAa,QAAQ,eAAe;AAC7C,SAASC,6BAA6B,QAAQ,eAAe;AAE7D,SAASC,wBAAwB,EAAEC,iBAAiB,QAAQ,gBAAgB"}
+{"version":3,"sources":["../../src/utils/index.ts"],"sourcesContent":["export {\n  listAgentProcesses,\n  batchGetProcessCwds,\n  batchGetProcessStartTimes,\n  enrichProcesses,\n  captureProcessSnapshot,\n  createProcessSnapshotCapture,\n} from \"./process.js\";\nexport type { ProcessExec, ProcessSnapshotCapture, ProcessSnapshotOptions } from \"./process.js\";\nexport { getProcessTty } from \"./process.js\";\nexport { batchGetSessionFileBirthtimes } from \"./session.js\";\nexport type { SessionFile } from \"./session.js\";\nexport { matchProcessesToSessions, generateAgentName } from \"./matching.js\";\nexport type { MatchResult } from \"./matching.js\";\n"],"names":["listAgentProcesses","batchGetProcessCwds","batchGetProcessStartTimes","enrichProcesses","captureProcessSnapshot","createProcessSnapshotCapture","getProcessTty","batchGetSessionFileBirthtimes","matchProcessesToSessions","generateAgentName"],"mappings":"AAAA,SACEA,kBAAkB,EAClBC,mBAAmB,EACnBC,yBAAyB,EACzBC,eAAe,EACfC,sBAAsB,EACtBC,4BAA4B,QACvB,eAAe;AAEtB,SAASC,aAAa,QAAQ,eAAe;AAC7C,SAASC,6BAA6B,QAAQ,eAAe;AAE7D,SAASC,wBAAwB,EAAEC,iBAAiB,QAAQ,gBAAgB"}

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"}