@songsid/agend 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/transcript-sources.d.ts

@@ -32,7 +32,44 @@ export interface TranscriptSource {
     checkpoint?(): Promise<TranscriptCheckpoint | null>;
     /** Release anything held between polls; the next poll may acquire it again. */
     close?(): void;
+    /**
+     * #1641: whether the last poll found and read this instance's own transcript. False before the first, after a reset,
+     * and whenever the last poll found none — then nothing it reports is evidence about the turn.
+     */
+    following?(): boolean;
+    /**
+     * #1641 R2: whether the source knows the state of the CURRENT turn: it read the transcript from its start, found the
+     * last turn boundary before its baseline, or has read one since. Until then an empty ledger proves nothing.
+     */
+    turnStateKnown?(): boolean;
+    /** #1641 R3: turn records a checkpoint decided (it moved the source past them), for the monitor to hand on at once. */
+    takeTurns?(): TranscriptTurnEvent[];
+    /** #1218: the transcript file being followed now (for the Log tab's on-demand read), or null. */
+    currentPath?(): string | null;
 }
+/**
+ * #1641 R3: the complete records in [from, to) that `keep` accepts — `to` is a line boundary (a checkpoint's), so
+ * nothing is cut. #1218 P0: read in READ_MAX_BYTES chunks (the range a checkpoint skips can be many MB), and only kept
+ * lines are held. A line over LINE_MAX_BYTES is judged by its head: kept, it is read whole (≤ WHOLE_LINE_MAX_BYTES —
+ * a turn's record must not be lost to the limit, #1786 review); otherwise it is skipped without being decoded.
+ */
+export declare function readLineRange(path: string, from: number, to: number, keep?: (line: string) => boolean): Promise<string[]>;
+/** #1641 R2: how far back from the baseline a rollout is scanned for the last turn boundary (a turn writes a lot). */
+export declare const ROLLOUT_TURN_SCAN_MAX_BYTES: number;
+/**
+ * #1641 R2: the last turn boundary (task_started / task_complete / turn_aborted) a codex rollout holds before `end`,
+ * scanning back at most ROLLOUT_TURN_SCAN_MAX_BYTES: `none` when the whole prefix holds none (no turn ever started),
+ * null when the bound ran out first (unknown). Nothing else is read or replayed.
+ */
+export declare function lastRolloutTurnBoundary(path: string, end: number, maxBytes?: number): Promise<{
+    kind: "start";
+    turnId: string;
+} | {
+    kind: "end";
+    turnId: string;
+} | {
+    kind: "none";
+} | null>;
 /**
  * Follows the newest rollout JSONL whose session_meta.cwd matches this
  * instance's working directory. Rollouts are date-sharded and shared across
@@ -42,7 +79,13 @@ export declare class CodexRolloutSource implements TranscriptSource {
     private workingDirectory;
     private sessionsDir;
     private currentFile;
+    /** #1218: the rollout followed now. */
+    currentPath(): string | null;
     private byteOffset;
+    /** #1218 P0: the offset is inside a long line being skipped (readNewLines `skipping`). */
+    private skipping;
+    /** #1218 P0: a long line being skipped that is to be read whole once its end is found. */
+    private pendingLong;
     /** EOF snapshots taken when the monitor attaches; existing history is skipped. */
     private initialOffsets;
     /** Files whose session_meta was read and did NOT match our cwd. */
@@ -57,8 +100,34 @@ export declare class CodexRolloutSource implements TranscriptSource {
     /** #1510: the turn the records being read belong to (its `task_started`), carried across polls of one file. */
     private openTurnId;
     constructor(workingDirectory: string, sessionsDir?: string, _now?: number, index?: RolloutIndex);
+    /** #1641: the last poll found this instance's rollout and read it (see TranscriptSource.following). */
+    private lastPollFollowed;
+    /** #1641 R2: the turn open in the current file (its task_started read, no end yet), and whether that is known. */
+    private openTurn;
+    private turnKnown;
+    /** #1641 R2: boundaries decided at adoption (the old file's open turn ended, the new file's open turn carried in). */
+    private pendingTurns;
+    following(): boolean;
+    turnStateKnown(): boolean;
+    /** #1641 R3: turn records decided outside a poll (a checkpoint's adoption or skipped range), handed over now. */
+    takeTurns(): TranscriptTurnEvent[];
     reset(): void;
     checkpoint(): Promise<TranscriptCheckpoint | null>;
+    /**
+     * Follow `path` from `offset` (#1641 R2). A baseline past an existing file's start skips its history — but not the
+     * state of its current turn: the last boundary before the baseline says whether a turn is running now (carried in as
+     * its start; no tool, user or text record is replayed), and none within the scan bound leaves it unknown until one is
+     * read. A turn left open in the file being replaced belongs to that file, no longer followed: its busy evidence is
+     * withdrawn (retracted, not ended — nothing says how it ended).
+     */
+    private adopt;
+    /**
+     * A turn record (a boundary, or a user message) into `turns`, keeping the open turn current; true when `entry` was
+     * one (or another event_msg), so the caller looks no further. #1510: codex 0.162 writes one task_started per turn and
+     * ends it with task_complete (last_agent_message null after a provider error) or turn_aborted; a steer lands inside
+     * the open turn as another user message.
+     */
+    private turnRecord;
     private snapshotExistingFiles;
     /**
      * Newest rollout files first.
@@ -72,6 +141,8 @@ export declare class CodexRolloutSource implements TranscriptSource {
      * Baselines and checkpoints ask for a fresh listing; the 2 s poll takes the shared one.
      */
     private candidateFiles;
+    /** The first of `files` that is ours (in order), or undefined. Verdicts are cached, so a known file costs no read. */
+    private firstOwned;
     private fileBelongsToUs;
     poll(): Promise<TranscriptEvents>;
 }
@@ -107,6 +178,9 @@ export declare class MuseSessionSource implements TranscriptSource {
     private baselineComplete;
     private rejected;
     private sizes;
+    /** #1218 P0: per log, whether its offset is inside a long line being skipped, and a long turn record held for its end. */
+    private skipping;
+    private pendingLong;
     private listedAt;
     private baselined;
     /** intent_id → its text and time, until it materializes (bounded). */
@@ -171,6 +245,10 @@ export declare class KiroSessionSource implements TranscriptSource {
     private lane;
     private currentFile;
     private byteOffset;
+    /** #1218 P0: the offset is inside a long line being skipped (readNewLines `skipping`). */
+    private skipping;
+    /** #1218 P0: a long line being skipped that is to be read whole once its end is found. */
+    private pendingLong;
     private readonly createdAt;
     private generation;
     private cursor;