@agentex/agent 0.0.27 → 0.0.29

package/src/history/types.ts

@@ -0,0 +1,104 @@
+import type { BaseStreamEventFields, StreamEvent } from "../types.js";
+
+export interface LocalHistoryDiscoverOptions {
+  includeArchived?: boolean;
+  mainSessionsOnly?: boolean;
+  requireUserMessage?: boolean;
+  cwd?: string;
+  limit?: number;
+  env?: Record<string, string>;
+}
+
+export interface LocalHistoryProbeOptions {
+  limit?: number;
+  env?: Record<string, string>;
+}
+
+export interface LocalHistoryProbeResult {
+  providerType: string;
+  homeAvailable: boolean;
+  historyAvailable: boolean;
+  /** A file count only. It is not an eligible-session count. */
+  approximateCount?: number;
+}
+
+export type LocalHistoryArchiveState = "active" | "archived" | "unknown";
+
+export interface LocalHistorySourceFingerprint {
+  size: number;
+  /** String because nanosecond timestamps can exceed Number.MAX_SAFE_INTEGER. */
+  modifiedAtNs: string;
+  sha256?: string;
+}
+
+export interface LocalHistorySession {
+  version: 1;
+  providerType: string;
+  externalSessionId: string;
+  /** Local-runtime detail. Network hosts must not serialize this to clients. */
+  transcriptPath: string;
+  cwd: string | null;
+  title: string | null;
+  startedAt: string | null;
+  updatedAt: string;
+  branch: string | null;
+  gitOriginUrl: string | null;
+  archiveState: LocalHistoryArchiveState;
+  hasUserMessage: boolean;
+  source: LocalHistorySourceFingerprint;
+}
+
+export type LocalHistoryUserEvent = {
+  type: "user";
+  text: string;
+} & BaseStreamEventFields;
+
+export type LocalHistoryEvent = StreamEvent | LocalHistoryUserEvent;
+
+export interface LocalHistoryYield {
+  event: LocalHistoryEvent & { eventId: string };
+  lineStartOffset: number;
+  nextOffset: number;
+  /** Disambiguates several normalized events produced from one source record. */
+  partIndex: number;
+}
+
+export interface LocalHistoryReadOptions {
+  fromOffset?: number;
+}
+
+export interface LocalHistoryFingerprintOptions {
+  sha256?: boolean;
+}
+
+export type LocalHistoryErrorCode =
+  | "home_missing"
+  | "permission_denied"
+  | "source_missing"
+  | "unsupported_format"
+  | "source_changed_during_read"
+  | "invalid_session"
+  | "io_error";
+
+export class LocalHistoryError extends Error {
+  readonly code: LocalHistoryErrorCode;
+
+  constructor(code: LocalHistoryErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "LocalHistoryError";
+    this.code = code;
+  }
+}
+
+export interface LocalHistoryOps {
+  probe(options?: LocalHistoryProbeOptions): Promise<LocalHistoryProbeResult>;
+  discover(options?: LocalHistoryDiscoverOptions): AsyncIterable<LocalHistorySession>;
+  read(
+    session: LocalHistorySession,
+    options?: LocalHistoryReadOptions,
+  ): AsyncIterable<LocalHistoryYield>;
+  fingerprint(
+    session: LocalHistorySession,
+    options?: LocalHistoryFingerprintOptions,
+  ): Promise<LocalHistorySourceFingerprint>;
+}

package/src/index.ts

@@ -141,6 +141,9 @@ export {
 export type {
   ProviderModule,
   ProviderCapabilities,
+  ProviderRuntimeContext,
+  ProviderRuntimeReport,
+  CapabilityStatus,
   AgentMode,
   ListModesOptions,
   ExecutionContext,
@@ -168,6 +171,11 @@ export type {
   AuthRequiredReason,
   BinaryStatus,
   ProviderModel,
+  ListModelsOptions,
+  ProviderAuthMethod,
+  ProviderAuthFlow,
+  UpstreamProvider,
+  UpstreamProviderManager,
   SessionContext,
   AgentSession,
   SendHandle,
@@ -198,6 +206,24 @@ export type {
   GoalSentinelContext,
 } from "./types.js";
 
+// Local persisted session discovery. Runtime errors are exported from the
+// `@agentex/agent/history` subpath to keep the root barrel lazy.
+export type {
+  LocalHistoryArchiveState,
+  LocalHistoryDiscoverOptions,
+  LocalHistoryErrorCode,
+  LocalHistoryEvent,
+  LocalHistoryFingerprintOptions,
+  LocalHistoryOps,
+  LocalHistoryProbeOptions,
+  LocalHistoryProbeResult,
+  LocalHistoryReadOptions,
+  LocalHistorySession,
+  LocalHistorySourceFingerprint,
+  LocalHistoryUserEvent,
+  LocalHistoryYield,
+} from "./history/index.js";
+
 // Goals
 export {
   GoalController,
@@ -235,6 +261,11 @@ export type {
   CatchUpOptions,
   AttachOptions,
   SessionAttachment,
+  HistoryCheckpoint,
+  HistorySource,
+  HistoryCatchUpYield,
+  HistoryCatchUpOptions,
+  HistoryAttachment,
 } from "./types.js";
 
 export type {

package/src/providers/claude/attach.ts

@@ -1,4 +1,6 @@
+import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
+import * as readline from "node:readline";
 import type {
   AttachOptions,
   CatchUpOptions,
@@ -19,7 +21,6 @@ import { claudeSessionCodec } from "./codec.js";
 import {
   findClaudeTranscriptBySessionId,
   getClaudeTranscriptPath,
-  peekClaudeTranscript,
   readClaudeTranscript,
 } from "./transcript.js";
 // Heavy-on-heavy is fine: this whole module loads lazily via
@@ -77,6 +78,44 @@ const EMPTY: AsyncIterable<CatchUpYield> = {
   },
 };
 
+/**
+ * Classify lifecycle boundaries from the raw transcript rather than replay's
+ * normalized events. Ordinary Claude `user` prompt records intentionally
+ * normalize to no StreamEvent, but still start a new turn. Looking only at
+ * normalized output can therefore mistake an interrupted new turn for the
+ * preceding completed one.
+ */
+async function classifyLastTurn(filePath: string): Promise<LastTurnStatus> {
+  const stream = createReadStream(filePath, { encoding: "utf8" });
+  stream.on("error", () => {});
+  const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  let lastTurn: LastTurnStatus = "unknown";
+
+  try {
+    for await (const line of lines) {
+      let raw: unknown;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) continue;
+      const type = (raw as Record<string, unknown>)["type"];
+      if (type === "result") lastTurn = "completed";
+      else if (type === "user" || type === "assistant") lastTurn = "interrupted";
+    }
+  } catch (error) {
+    const fsError = error as NodeJS.ErrnoException;
+    if (fsError?.code !== "ENOENT") throw error;
+    return "unknown";
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+
+  return lastTurn;
+}
+
 /**
  * Read-only reattachment to a durable Claude session. Composition of existing
  * primitives (codec + transcript ops + `createClaudeSession` resume) — spawns
@@ -87,6 +126,12 @@ export async function attachClaudeSession(
   opts?: AttachOptions,
 ): Promise<SessionAttachment> {
   assertSessionRecord(record);
+  if (record.providerType !== "claude") {
+    throw new MalformedSessionRecordError(
+      `claude attach requires providerType "claude"; got ${JSON.stringify(record.providerType)}`,
+      "providerType",
+    );
+  }
 
   // 1. Normalize params through the codec.
   const params = claudeSessionCodec.deserialize(record.params);
@@ -113,10 +158,7 @@ export async function attachClaudeSession(
   // 3. Classify how the last persisted turn ended.
   let lastTurn: LastTurnStatus = "unknown";
   if (transcript) {
-    const { lastEvent } = await peekClaudeTranscript(transcript.filePath);
-    if (lastEvent === null) lastTurn = "unknown";
-    else if (lastEvent.type === "result") lastTurn = "completed";
-    else lastTurn = "interrupted";
+    lastTurn = await classifyLastTurn(transcript.filePath);
   }
 
   return {
@@ -141,7 +183,7 @@ export async function attachClaudeSession(
     },
     // 5. Continue live — exactly `createSession` with the record's params.
     resume(ctx?: SessionContext) {
-      return createClaudeSession({ ...ctx, sessionParams: params });
+      return createClaudeSession({ ...ctx, cwd: ctx?.cwd ?? cwd ?? undefined, sessionParams: params });
     },
   };
 }

package/src/providers/claude/history.ts

@@ -0,0 +1,290 @@
+import * as path from "node:path";
+import { readdir } from "node:fs/promises";
+
+import type { BaseStreamEventFields, StreamEvent } from "../../types.js";
+import type {
+  LocalHistoryDiscoverOptions,
+  LocalHistoryOps,
+  LocalHistoryProbeOptions,
+  LocalHistorySession,
+  LocalHistoryYield,
+} from "../../history/types.js";
+import {
+  UUID_JSONL_RE,
+  asRecord,
+  asString,
+  cleanTitle,
+  isDirectory,
+  isoDate,
+  meaningfulHumanText,
+  readJsonlRecords,
+  recentEligible,
+  sourceFingerprint,
+  textFromContent,
+} from "../../history/fs.js";
+import { parseStreamLine } from "./parse.js";
+import { resolveClaudeHome } from "./transcript.js";
+
+const TITLE_SCAN_BYTES = 64 * 1024;
+const MAX_DISCOVERY_SCAN_BYTES = 4 * 1024 * 1024;
+const DEFAULT_PROBE_LIMIT = 100;
+const DISCOVERY_CONCURRENCY = 16;
+const DROP_EVENT_TYPES = new Set([
+  "assistant_delta",
+  "thinking_delta",
+  "permission_mode",
+  "rate_limit",
+  "unknown",
+]);
+
+function claudeHome(options?: { env?: Record<string, string> }): string {
+  return resolveClaudeHome(options?.env?.["CLAUDE_CONFIG_DIR"]);
+}
+
+async function listClaudeSessionFiles(
+  home: string,
+  options: { limit?: number; includeSubagents?: boolean } = {},
+): Promise<string[]> {
+  const projectsRoot = path.join(home, "projects");
+  let projects;
+  try {
+    projects = await readdir(projectsRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  projects.sort((a, b) => a.name.localeCompare(b.name));
+  const files: string[] = [];
+  const cap = Math.max(1, options.limit ?? Number.MAX_SAFE_INTEGER);
+  for (const project of projects) {
+    if (files.length >= cap) break;
+    if (!project.isDirectory()) continue;
+    let entries;
+    try {
+      entries = await readdir(path.join(projectsRoot, project.name), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (files.length >= cap) break;
+      // Top-level UUID files are main sessions. Nested subagent directories and
+      // symlinks are deliberately ignored.
+      if (entry.isFile() && UUID_JSONL_RE.test(entry.name)) {
+        files.push(path.join(projectsRoot, project.name, entry.name));
+      }
+      if (options.includeSubagents && entry.isDirectory() && UUID_JSONL_RE.test(`${entry.name}.jsonl`)) {
+        const subagentsDir = path.join(projectsRoot, project.name, entry.name, "subagents");
+        let subagents;
+        try {
+          subagents = await readdir(subagentsDir, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        subagents.sort((a, b) => a.name.localeCompare(b.name));
+        for (const subagent of subagents) {
+          if (files.length >= cap) break;
+          if (subagent.isFile() && /^agent-[a-z0-9]+\.jsonl$/i.test(subagent.name)) {
+            files.push(path.join(subagentsDir, subagent.name));
+          }
+        }
+      }
+    }
+  }
+  return files;
+}
+
+function subagentParentId(transcriptPath: string): string | null {
+  if (path.basename(path.dirname(transcriptPath)) !== "subagents") return null;
+  return path.basename(path.dirname(path.dirname(transcriptPath))) || null;
+}
+
+async function parentSessionMetadata(
+  transcriptPath: string,
+): Promise<{ cwd: string | null; branch: string | null }> {
+  const parentId = subagentParentId(transcriptPath);
+  if (!parentId) return { cwd: null, branch: null };
+  const projectDir = path.dirname(path.dirname(path.dirname(transcriptPath)));
+  const parentTranscript = path.join(projectDir, `${parentId}.jsonl`);
+  for await (const line of readJsonlRecords(parentTranscript)) {
+    const cwd = absoluteCwd(asString(line.raw["cwd"]));
+    const branch = asString(line.raw["gitBranch"]);
+    if (cwd) return { cwd, branch };
+    if (line.nextOffset >= TITLE_SCAN_BYTES) break;
+  }
+  return { cwd: null, branch: null };
+}
+
+function claudeUserText(record: Record<string, unknown>): string | null {
+  if (record["type"] !== "user") return null;
+  const message = asRecord(record["message"]);
+  if (!message || message["role"] !== "user") return null;
+  return meaningfulHumanText(textFromContent(
+    message["content"],
+    new Set(["text", "input_text"]),
+  ));
+}
+
+function absoluteCwd(value: string | null): string | null {
+  return value && path.isAbsolute(value) ? value : null;
+}
+
+async function inspectClaudeSession(
+  transcriptPath: string,
+  options: LocalHistoryDiscoverOptions,
+): Promise<LocalHistorySession | null> {
+  const fileIdentity = path.basename(transcriptPath, ".jsonl");
+  const parentId = subagentParentId(transcriptPath);
+  const externalSessionId = parentId
+    ? `subagent:${parentId}:${fileIdentity}`
+    : fileIdentity;
+  let cwd: string | null = null;
+  let title: string | null = null;
+  let firstPrompt: string | null = null;
+  let startedAt: string | null = null;
+  let branch: string | null = null;
+  let sidechain = false;
+
+  for await (const line of readJsonlRecords(transcriptPath)) {
+    const record = line.raw;
+    if (record["isSidechain"] === true) sidechain = true;
+    cwd ??= absoluteCwd(asString(record["cwd"]));
+    startedAt ??= isoDate(record["timestamp"]);
+    branch ??= asString(record["gitBranch"]);
+    if (record["type"] === "ai-title") title ??= cleanTitle(asString(record["aiTitle"]));
+    firstPrompt ??= claudeUserText(record);
+    if (cwd && firstPrompt && (title || line.nextOffset >= TITLE_SCAN_BYTES)) break;
+    if (line.nextOffset >= MAX_DISCOVERY_SCAN_BYTES) break;
+  }
+
+  if (!cwd && parentId) {
+    const parent = await parentSessionMetadata(transcriptPath);
+    cwd = parent.cwd;
+    branch ??= parent.branch;
+  }
+
+  if ((options.mainSessionsOnly ?? true) && sidechain) return null;
+  const hasUserMessage = firstPrompt !== null;
+  if ((options.requireUserMessage ?? true) && !hasUserMessage) return null;
+  if ((options.mainSessionsOnly ?? true) && !cwd) return null;
+  if (options.cwd && (!cwd || path.normalize(cwd) !== path.normalize(options.cwd))) return null;
+
+  const source = await sourceFingerprint(transcriptPath);
+  return {
+    version: 1,
+    providerType: "claude",
+    externalSessionId,
+    transcriptPath,
+    cwd,
+    title: title ?? cleanTitle(firstPrompt),
+    startedAt,
+    updatedAt: new Date(Number(BigInt(source.modifiedAtNs) / 1_000_000n)).toISOString(),
+    branch,
+    gitOriginUrl: null,
+    archiveState: "unknown",
+    hasUserMessage,
+    source,
+  };
+}
+
+function baseFields(
+  session: LocalHistorySession,
+  raw: Record<string, unknown>,
+  eventId: string,
+): BaseStreamEventFields & { eventId: string } {
+  const message = asRecord(raw["message"]);
+  return {
+    timestamp: isoDate(raw["timestamp"], session.startedAt ?? new Date(0).toISOString())!,
+    providerType: "claude",
+    sessionId: session.externalSessionId,
+    messageId: asString(message?.["id"]),
+    eventId,
+    turnId: null,
+    parentToolCallId: asString(raw["parent_tool_use_id"]),
+    raw,
+  };
+}
+
+function normalizedClaudeEvents(
+  session: LocalHistorySession,
+  raw: Record<string, unknown>,
+  text: string,
+  eventId: string,
+): Array<StreamEvent & { eventId: string }> {
+  return parseStreamLine(text)
+    .filter((event) => !DROP_EVENT_TYPES.has(event.type))
+    .map((event) => ({
+      ...event,
+      timestamp: isoDate(raw["timestamp"], event.timestamp)!,
+      providerType: "claude",
+      sessionId: session.externalSessionId,
+      eventId,
+      raw,
+    } as StreamEvent & { eventId: string }));
+}
+
+export const claudeLocalHistory: LocalHistoryOps = {
+  async probe(options?: LocalHistoryProbeOptions) {
+    const home = claudeHome(options);
+    const homeAvailable = await isDirectory(home);
+    const files = homeAvailable
+      ? await listClaudeSessionFiles(home, { limit: options?.limit ?? DEFAULT_PROBE_LIMIT })
+      : [];
+    return {
+      providerType: "claude",
+      homeAvailable,
+      historyAvailable: files.length > 0,
+      approximateCount: files.length,
+    };
+  },
+
+  async *discover(options: LocalHistoryDiscoverOptions = {}) {
+    const files = await listClaudeSessionFiles(claudeHome(options), {
+      includeSubagents: options.mainSessionsOnly === false,
+    });
+    const sessions = await recentEligible(
+      files,
+      { limit: options.limit, concurrency: DISCOVERY_CONCURRENCY },
+      async (filePath) => {
+        try {
+          return await inspectClaudeSession(filePath, options);
+        } catch {
+          return null;
+        }
+      },
+    );
+    for (const session of sessions) yield session;
+  },
+
+  async *read(session, options = {}): AsyncIterable<LocalHistoryYield> {
+    if (session.providerType !== "claude" || !path.isAbsolute(session.transcriptPath)) {
+      throw new Error("Invalid Claude local history session");
+    }
+    for await (const line of readJsonlRecords(
+      session.transcriptPath,
+      options.fromOffset ?? 0,
+      { rejectChanges: true },
+    )) {
+      const eventId = asString(line.raw["uuid"])
+        ?? `claude:${session.externalSessionId}:${line.lineStartOffset}`;
+      const events: LocalHistoryYield["event"][] = [];
+      const userText = claudeUserText(line.raw);
+      if (userText) {
+        events.push({ type: "user", text: userText, ...baseFields(session, line.raw, eventId) });
+      }
+      events.push(...normalizedClaudeEvents(session, line.raw, line.text, eventId));
+      for (let partIndex = 0; partIndex < events.length; partIndex++) {
+        yield {
+          event: events[partIndex]!,
+          lineStartOffset: line.lineStartOffset,
+          nextOffset: line.nextOffset,
+          partIndex,
+        };
+      }
+    }
+  },
+
+  fingerprint(session, options) {
+    if (session.providerType !== "claude") throw new Error("Invalid Claude local history session");
+    return sourceFingerprint(session.transcriptPath, options?.sha256 ?? false);
+  },
+};

package/src/providers/claude/index.ts

@@ -35,6 +35,8 @@ export const claudeProvider: ProviderModule = {
     modes: false,
     goals: claudeGoalCapability,
     durableSessions: true,
+    durableHistory: true,
+    localHistory: true,
   },
   // Heavy machinery (execute.ts, session.ts, attach.ts) loads lazily on first
   // use — every ProviderModule method is already async, so this is invisible to
@@ -48,6 +50,30 @@ export const claudeProvider: ProviderModule = {
   transcript: claudeTranscriptOps,
   attachSession: async (record, opts) =>
     (await import("./attach.js")).attachClaudeSession(record, opts),
+  attachHistory: async (record, opts) => {
+    const [{ attachClaudeSession }, { historyFromSessionAttachment }] = await Promise.all([
+      import("./attach.js"),
+      import("../../sessions/history.js"),
+    ]);
+    return historyFromSessionAttachment("claude", await attachClaudeSession(record, opts));
+  },
+  localHistory: {
+    probe: (options) => import("./history.js").then((module) => module.claudeLocalHistory.probe(options)),
+    discover: (options) => ({
+      async *[Symbol.asyncIterator]() {
+        const module = await import("./history.js");
+        yield* module.claudeLocalHistory.discover(options);
+      },
+    }),
+    read: (session, options) => ({
+      async *[Symbol.asyncIterator]() {
+        const module = await import("./history.js");
+        yield* module.claudeLocalHistory.read(session, options);
+      },
+    }),
+    fingerprint: (session, options) => import("./history.js")
+      .then((module) => module.claudeLocalHistory.fingerprint(session, options)),
+  },
 };
 
 export {

package/src/providers/claude/session.ts

@@ -216,11 +216,7 @@ export async function createClaudeSession(ctx: SessionContext): Promise<AgentSes
     throw new Error("Failed to open stdio on Claude process");
   }
 
-  const session = new ClaudeSessionImpl(proc, ctx, skillsDir, mcpConfigPath);
-
-  // On resume, restore an unmet native goal from the transcript (best-effort,
-  // non-blocking so session creation isn't delayed by a transcript read).
-  if (resumeId) void session.hydrateGoalFromTranscript(resumeId);
+  const session = new ClaudeSessionImpl(proc, { ...ctx, cwd }, skillsDir, mcpConfigPath);
 
   // Wire up AbortSignal to close the session
   if (ctx.signal) {
@@ -231,6 +227,10 @@ export async function createClaudeSession(ctx: SessionContext): Promise<AgentSes
     }
   }
 
+  // Finish historical hydration before exposing the session. This prevents a
+  // late transcript read from overwriting a goal the caller sets immediately.
+  if (resumeId && session.state !== "closed") await session.hydrateGoalFromTranscript(resumeId);
+
   return session;
 }
 
@@ -307,6 +307,7 @@ export class ClaudeSessionImpl implements AgentSession {
   /** Tail state for observing native goal_status (transcript-only, not on stdout). */
   private _goalScanOffset = 0;
   private _goalPoll: ReturnType<typeof setInterval> | null = null;
+  private readonly cwd: string;
 
   constructor(
     private readonly proc: ChildProcess,
@@ -314,6 +315,7 @@ export class ClaudeSessionImpl implements AgentSession {
     private readonly skillsDir: string | null,
     private readonly mcpConfigPath: string | null = null,
   ) {
+    this.cwd = ctx.cwd ?? process.cwd();
     this._goals = new GoalController({
       providerType: "claude",
       capability: claudeGoalCapability,
@@ -384,6 +386,7 @@ export class ClaudeSessionImpl implements AgentSession {
 
   get sessionId(): string | null { return this._sessionId; }
   get state(): SessionState { return this._state; }
+  private isClosed(): boolean { return this._state === "closed"; }
 
   /**
    * Durable identity for persistence + later `attachSession`. Null until Claude
@@ -392,7 +395,7 @@ export class ClaudeSessionImpl implements AgentSession {
    */
   describe(): SessionRecord | null {
     if (!this._sessionId) return null;
-    const cwd = this.ctx.cwd ?? null;
+    const cwd = this.cwd;
     const params = claudeSessionCodec.serialize({
       sessionId: this._sessionId,
       ...(cwd ? { cwd } : {}),
@@ -1144,7 +1147,7 @@ export class ClaudeSessionImpl implements AgentSession {
     try {
       const found = await claudeTranscriptOps.find({
         sessionId,
-        cwd: this.ctx.cwd ?? process.cwd(),
+        cwd: this.cwd,
       });
       if (found) this._transcriptPath = found.filePath;
     } catch { /* best effort */ } finally {
@@ -1166,20 +1169,22 @@ export class ClaudeSessionImpl implements AgentSession {
    */
   async hydrateGoalFromTranscript(sessionId: string): Promise<void> {
     try {
+      if (this.isClosed()) return;
       const found = await claudeTranscriptOps.find({
         sessionId,
-        cwd: this.ctx.cwd ?? process.cwd(),
+        cwd: this.cwd,
       });
-      if (!found) return;
+      if (!found || this.isClosed()) return;
       this._transcriptPath = found.filePath;
       const events: StreamEvent[] = [];
       let endOffset = 0;
       for await (const { event, offset } of claudeTranscriptOps.read({ filePath: found.filePath })) {
+        if (this.isClosed()) return;
         endOffset = offset;
         if (event.type === "goal_status") events.push(event);
       }
       const last = latestGoalFromEvents(events);
-      if (last && !isTerminalGoalStatus(last.status)) {
+      if (!this.isClosed() && last && !isTerminalGoalStatus(last.status)) {
         // Start observing from the END of the historical transcript so the poller
         // surfaces only post-resume transitions (we already hydrated the state).
         this._goalScanOffset = endOffset;