deepline 0.1.90 → 0.1.93

package/dist/repo/apps/play-runner-workers/src/coordinator-entry.ts

@@ -3211,8 +3211,22 @@ function formatTailLogPart(value: unknown): string {
   }
 }
 
+// Operator-diagnostic console lines that carry the [deepline-run:] prefix but
+// are not user-facing run output. The console scrape fans run-prefixed lines
+// back into the run's durable Run Log Stream ('system' channel), so harness/
+// coordinator plumbing noise is filtered at ingestion, never at read time.
+// User play log lines (runner-event echoes) intentionally pass through.
+const OPERATOR_NOISE_LOG_PATTERNS: readonly RegExp[] = [
+  /\[perf-trace\]/,
+  /\[harness-probe\]/,
+  /TenantWorkflow\.run entered/,
+  /TenantWorkflow\.run threw/,
+  /failed to forward runner perf trace/,
+  /failed to forward TenantWorkflow\.run error/,
+];
+
 function parseRunLogLine(line: string): { runId: string; line: string } | null {
-  if (line.includes('[perf-trace]')) {
+  if (OPERATOR_NOISE_LOG_PATTERNS.some((pattern) => pattern.test(line))) {
     return null;
   }
   const prefixed = line.match(RUN_LOG_PREFIX_RE);
@@ -3661,26 +3675,79 @@ async function handleWorkflowRoute(input: {
   }
   try {
     if (action === 'cancel') {
-      if (!instance) {
-        return Response.json({ runId, status: 'cancelled' });
+      if (instance) {
+        try {
+          await instance.terminate();
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          // Tolerate four classes of error here:
+          //   - already-terminal (complete / errored / terminated)
+          //   - "Cannot terminate instance since its on a finite state"
+          //     (the runtime's wording for "already finished")
+          //   - "not implemented" (wrangler dev local mode doesn't support
+          //     instance.terminate() yet — silently no-op there)
+          //   - "not found" (instance never existed)
+          if (
+            !/complete|terminated|errored|finite state|cannot[ _]terminate|not[ _]implemented|not[ _]found|404/i.test(
+              message,
+            )
+          ) {
+            throw error;
+          }
+        }
       }
-      try {
-        await instance.terminate();
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        // Tolerate four classes of error here:
-        //   - already-terminal (complete / errored / terminated)
-        //   - "Cannot terminate instance since its on a finite state"
-        //     (the runtime's wording for "already finished")
-        //   - "not implemented" (wrangler dev local mode doesn't support
-        //     instance.terminate() yet — silently no-op there)
-        //   - "not found" (instance never existed)
-        if (
-          !/complete|terminated|errored|finite state|cannot[ _]terminate|not[ _]implemented|not[ _]found|404/i.test(
-            message,
-          )
-        ) {
-          throw error;
+      // terminate() kills the dynamic worker before its run() wrapper can
+      // write terminal state (the only place completed/failed land), so
+      // without this write /tail reports 'running' forever and any
+      // start-stream watcher hangs after a cancel. Land the cancelled
+      // terminal state here — terminal-set appends a 'terminal' run event
+      // and wakes the dedup DO's long-poll waiters, which unblocks tails.
+      //
+      // Idempotency: first-wins from this side — if the run already went
+      // terminal (completed/failed/cancelled) we keep that state. The DO
+      // stores the cached terminal state under a single storage key
+      // (last-wins on raw writes), but the run-event log is append-only
+      // and /tail truncates at the FIRST terminal event, so a racing
+      // completed/failed write from a dying worker can at worst replace
+      // the cached key with another terminal status — it can never
+      // resurrect 'running'.
+      const existingTerminal = await readCoordinatorTerminalState(
+        env,
+        runId,
+      ).catch((error: unknown) => {
+        // Tolerated: better to risk a harmless terminal-over-terminal
+        // overwrite than to skip the cancelled write and hang watchers.
+        console.warn('[coordinator] terminal state read before cancel failed', {
+          runId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+      });
+      if (!existingTerminal) {
+        try {
+          await writeCoordinatorTerminalState(env, {
+            runId,
+            status: 'cancelled',
+            error: 'Run cancelled',
+          });
+        } catch (error) {
+          // Fail loudly: the workflow was terminated but watchers would
+          // hang on 'running' forever without the terminal event.
+          const message =
+            error instanceof Error ? error.message : String(error);
+          console.error('[coordinator] cancel terminal state write failed', {
+            runId,
+            error: message,
+          });
+          return Response.json(
+            {
+              runId,
+              status: 'error',
+              error: `workflow terminated but cancelled terminal state write failed: ${message}`,
+            },
+            { status: 500 },
+          );
         }
       }
       return Response.json({ runId, status: 'cancelled' });

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -1206,7 +1206,10 @@ async function waitForSyntheticIntegrationEvent(
       {
         type: 'log.appended',
         runId: req.runId,
-        source: 'worker',
+        // 'system' (windowed text-dedupe channel), NOT 'worker': this line is
+        // emitted outside the harness log buffer, so it has no positional
+        // channelOffset and must not pollute the worker channel cursor.
+        source: 'system',
         occurredAt: nowMs(),
         lines: [
           `Waiting for integration_event:${eventKey} for up to ${timeoutMs}ms.`,
@@ -5402,6 +5405,14 @@ async function executeRunRequest(
   const abortSignal = abortController.signal;
   let runLogBuffer: string[] = [];
   let pendingRunLogLines: string[] = [];
+  // Monotonic count of every line ever appended to this run's worker log
+  // channel. runLogBuffer/pendingRunLogLines are rotating tails of those
+  // lines (RUN_LOG_BUFFER_LIMIT is the coordinator transport cache only), so
+  // each log.appended batch can carry the absolute channelOffset of its first
+  // line: totalEmittedLogLines - pendingRunLogLines.length. Run Log Stream
+  // ingestion skips re-sent prefixes positionally (exactly-once, repeated
+  // identical lines preserved) instead of text-deduping.
+  let totalEmittedLogLines = 0;
   let stepProgressByNodeId: LiveNodeProgressMap = {};
   let dirtyProgressNodeIds = new Set<string>();
   let pendingLedgerEvents: PlayRunLedgerEvent[] = [
@@ -5424,6 +5435,7 @@ async function executeRunRequest(
   const appendRunLogLine = (line: string) => {
     const trimmed = redactSecretsFromLogString(line.trim());
     if (!trimmed) return;
+    totalEmittedLogLines += 1;
     runLogBuffer = [...runLogBuffer, trimmed].slice(-RUN_LOG_BUFFER_LIMIT);
     pendingRunLogLines = [...pendingRunLogLines, trimmed].slice(
       -RUN_LOG_BUFFER_LIMIT,
@@ -5614,6 +5626,12 @@ async function executeRunRequest(
         source: 'worker',
         occurredAt,
         lines: pendingRunLogLines,
+        // Positional cursor: pendingRunLogLines always holds the LAST
+        // pending lines emitted on this channel, so the offset of its first
+        // line is total-emitted minus pending length. This also covers the
+        // terminal full-buffer re-send (pending = runLogBuffer), which
+        // ingestion then skips positionally instead of via text dedupe.
+        channelOffset: totalEmittedLogLines - pendingRunLogLines.length,
       });
       pendingRunLogLines = [];
     }
@@ -5709,6 +5727,9 @@ async function executeRunRequest(
   ): Promise<void> => {
     if (!options?.persistResultDatasets) return;
     const now = nowMs();
+    // Terminal re-send of the full retained buffer. drainPendingLedgerEvents
+    // stamps it with channelOffset = totalEmitted - buffer length, so Run Log
+    // Stream ingestion drops the already-ingested prefix positionally.
     pendingRunLogLines = runLogBuffer;
     dirtyProgressNodeIds = new Set([
       ...dirtyProgressNodeIds,
@@ -5859,6 +5880,25 @@ async function executeRunRequest(
         ms: nowMs() - resultDatasetStartedAt,
       });
       const parentSignal = startParentTerminalSignal();
+      // Capped runs settle compute billing BEFORE declaring run.completed: a
+      // per-run cap denial (422 billing_cap_exceeded) must fail the run as
+      // its ONLY terminal. Flushing completed first opens a race — watchers
+      // stream the ledger snapshot and exit on the transient completed
+      // before the demoting run.failed lands.
+      const capped = extractMaxCreditsPerRun(req.contractSnapshot) !== null;
+      if (capped) {
+        const billingStartedAt = nowMs();
+        await finalizeWorkerComputeBilling({
+          req,
+          success: true,
+          actionEstimate: 4,
+        });
+        recordRunnerPerfTrace({
+          req,
+          phase: 'runner.compute_billing_finalize',
+          ms: nowMs() - billingStartedAt,
+        });
+      }
       const terminalOccurredAt = nowMs();
       const terminalUpdateStartedAt = nowMs();
       await flushTerminalLedgerEvents({
@@ -5874,21 +5914,19 @@ async function executeRunRequest(
         ms: nowMs() - terminalUpdateStartedAt,
       });
 
-      const billingStartedAt = nowMs();
-      const billingPromise = finalizeWorkerComputeBilling({
-        req,
-        success: true,
-        actionEstimate: 4,
-      }).then(() => {
-        recordRunnerPerfTrace({
+      if (!capped) {
+        const billingStartedAt = nowMs();
+        const billingPromise = finalizeWorkerComputeBilling({
           req,
-          phase: 'runner.compute_billing_finalize',
-          ms: nowMs() - billingStartedAt,
+          success: true,
+          actionEstimate: 4,
+        }).then(() => {
+          recordRunnerPerfTrace({
+            req,
+            phase: 'runner.compute_billing_finalize',
+            ms: nowMs() - billingStartedAt,
+          });
         });
-      });
-      if (extractMaxCreditsPerRun(req.contractSnapshot) !== null) {
-        await billingPromise;
-      } else {
         const nonBlockingBillingPromise = billingPromise.catch((error) => {
           console.error(
             `[play-harness] non-fatal compute billing finalize failed runId=${req.runId}: ${

package/dist/repo/sdk/src/client.ts

@@ -36,6 +36,15 @@
 import { resolveConfig } from './config.js';
 import { DeeplineError } from './errors.js';
 import { HttpClient } from './http.js';
+import {
+  STREAM_HEALTHY_CONNECTION_MS,
+  isTransientPlayStreamError,
+  streamReconnectDelayMs,
+} from './stream-reconnect.js';
+import {
+  observeRunEvents,
+  RunObserveTransportUnavailableError,
+} from './runs/observe-transport.js';
 import type {
   DeeplineClientOptions,
   ResolvedConfig,
@@ -129,11 +138,29 @@ export type RunsListOptions = {
 /** Streaming options for `client.runs.tail(...)`. */
 export type RunsTailOptions = {
   signal?: AbortSignal;
+  /**
+   * Called before each stream reconnect. Server stream windows are finite, so
+   * long runs reconnect with backoff until a terminal status is observed.
+   */
+  onReconnect?: (info: {
+    attempt: number;
+    delayMs: number;
+    reason: string;
+  }) => void;
+  /**
+   * Display-only transport notices: subscription-transport reconnects,
+   * staleness warnings, and the one-time fallback notice when the server
+   * cannot serve the Convex subscription transport (ADR-0008).
+   */
+  onNotice?: (message: string) => void;
 };
 
 /** Log fetch options for `client.runs.logs(...)`. */
 export type RunsLogsOptions = {
+  /** Return the LAST `limit` stored log lines (default 200). */
   limit?: number;
+  /** Fetch every stored log line, paginating to the full totalCount. */
+  all?: boolean;
 };
 
 /** Persisted log response for one play run. */
@@ -146,6 +173,28 @@ export type RunsLogsResult = {
   truncated: boolean;
   hasMore: boolean;
   entries: string[];
+  /**
+   * True when the run crossed the Run Log Stream retention cap: `totalCount`
+   * keeps counting, but stored line bodies end at a loud truncation marker.
+   */
+  logsTruncated?: boolean;
+};
+
+/** Server page cap for GET /api/v2/runs/:runId/logs (ADR-0009). */
+const RUN_LOGS_PAGE_LIMIT = 1_000;
+
+/** Wire shape of one GET /api/v2/runs/:runId/logs page. */
+type RunLogsPageResponse = {
+  runId: string;
+  totalLogCount: number;
+  logsTruncated: boolean;
+  lastStoredSeq: number;
+  afterSeq: number;
+  entries: Array<{ seq: number; line: string }>;
+  firstSeq: number | null;
+  lastSeq: number | null;
+  hasMore: boolean;
+  nextAfterSeq: number | null;
 };
 
 /** One persisted runtime-sheet row returned by `client.runs.exportDatasetRows(...)`. */
@@ -328,6 +377,13 @@ type PlayLiveStatusState = {
   runId: string;
   status: PlayStatus['status'];
   logs: string[];
+  /**
+   * Absolute (1-based) sequence number of the last log line appended to
+   * `logs`. play.run.log payloads carry `firstSeq` (ADR-0009), so overlapping
+   * re-deliveries are skipped positionally — repeated identical lines are
+   * preserved and snapshots never replace the accumulated log list.
+   */
+  lastLogSeq: number;
   result?: unknown;
   error?: string;
   latest: PlayStatus | null;
@@ -355,13 +411,52 @@ function normalizeLiveStatus(value: unknown): PlayStatus['status'] | null {
   return null;
 }
 
+function appendPlayLiveLogLines(
+  state: PlayLiveStatusState,
+  payload: Record<string, unknown>,
+): void {
+  const lines = readStringArray(payload.lines);
+  if (lines.length === 0) {
+    return;
+  }
+  const firstSeq =
+    typeof payload.firstSeq === 'number' &&
+    Number.isFinite(payload.firstSeq) &&
+    payload.firstSeq >= 1
+      ? Math.trunc(payload.firstSeq)
+      : null;
+  if (firstSeq === null) {
+    // Marker payloads (gap/unavailable notices) and pre-ADR-0009 servers
+    // carry no seq: append verbatim and advance the cursor by the payload's
+    // cumulative count when present so later seq-stamped lines line up.
+    state.logs.push(...lines);
+    const totalLogCount =
+      typeof payload.totalLogCount === 'number' &&
+      Number.isFinite(payload.totalLogCount)
+        ? Math.trunc(payload.totalLogCount)
+        : null;
+    if (totalLogCount !== null) {
+      state.lastLogSeq = Math.max(state.lastLogSeq, totalLogCount);
+    }
+    return;
+  }
+  // Positional append: skip the already-seen prefix of overlapping
+  // re-deliveries; repeated identical lines are preserved.
+  const skip = Math.max(0, state.lastLogSeq + 1 - firstSeq);
+  if (skip >= lines.length) {
+    return;
+  }
+  state.logs.push(...lines.slice(skip));
+  state.lastLogSeq = Math.max(state.lastLogSeq, firstSeq + lines.length - 1);
+}
+
 function updatePlayLiveStatusState(
   state: PlayLiveStatusState,
   event: PlayLiveEvent,
 ): PlayStatus | null {
   const payload = getPlayLiveEventPayload(event);
   if (event.type === 'play.run.log') {
-    state.logs.push(...readStringArray(payload.lines));
+    appendPlayLiveLogLines(state, payload);
     return null;
   }
   if (
@@ -385,15 +480,23 @@ function updatePlayLiveStatusState(
       : null) ??
     state.status;
   const progressPayload = isRecord(payload.progress) ? payload.progress : {};
-  const payloadLogs = readStringArray(payload.logs);
-  const progressLogs = readStringArray(progressPayload.logs);
-  const logs = payloadLogs.length > 0 ? payloadLogs : progressLogs;
+  // Snapshots no longer REPLACE accumulated logs (ADR-0009): the snapshot
+  // only retains a bounded tail, so replacing would clobber the seq-keyed
+  // log list built from play.run.log events (the stream differ always emits
+  // log lines through play.run.log, snapshot ticks included). A terminal
+  // final_status payload may still seed an EMPTY state — that is the only
+  // event some non-stream flows ever see.
   if (
-    logs.length > 0 ||
-    event.type === 'play.run.snapshot' ||
-    (event.type === 'play.run.final_status' && !isPlayRunPackage(payload))
+    event.type === 'play.run.final_status' &&
+    state.logs.length === 0 &&
+    state.lastLogSeq === 0
   ) {
-    state.logs = logs;
+    const payloadLogs = readStringArray(payload.logs);
+    const progressLogs = readStringArray(progressPayload.logs);
+    const seedLogs = payloadLogs.length > 0 ? payloadLogs : progressLogs;
+    if (seedLogs.length > 0) {
+      state.logs = seedLogs;
+    }
   }
   if ('result' in payload) {
     state.result = payload.result;
@@ -1560,44 +1663,161 @@ export class DeeplineClient {
     return response.runs ?? [];
   }
 
-  /** Read the canonical run stream and return the latest run snapshot. */
-  async tailRun(runId: string, options?: RunsTailOptions): Promise<PlayStatus> {
+  /**
+   * Observe one run's live events through the Convex Run Snapshot
+   * subscription transport (ADR-0008). Yields the same `play.*` event
+   * envelopes as {@link streamPlayRunEvents} and ends after the terminal
+   * snapshot. Throws {@link RunObserveTransportUnavailableError} when this
+   * server cannot serve the transport (older server, unconfigured grants, or
+   * unreachable Convex) — callers fall back to the SSE stream with a notice.
+   */
+  observeRunEvents(
+    runId: string,
+    options?: { signal?: AbortSignal; onNotice?: (message: string) => void },
+  ): AsyncGenerator<PlayLiveEvent> {
+    return observeRunEvents({
+      http: this.http,
+      runId,
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+    }) as AsyncGenerator<PlayLiveEvent>;
+  }
+
+  /**
+   * Tail one run through the subscription transport until terminal, then
+   * return one durable REST status read (the final Run Response Package).
+   */
+  private async tailRunViaObserveTransport(
+    runId: string,
+    options?: RunsTailOptions,
+  ): Promise<PlayStatus> {
     const state: PlayLiveStatusState = {
       runId,
       status: 'running',
       logs: [],
+      lastLogSeq: 0,
       latest: null,
     };
-    let terminal = false;
-    for await (const event of this.streamPlayRunEvents(runId, {
-      mode: 'cli',
+    for await (const event of this.observeRunEvents(runId, {
       signal: options?.signal,
+      onNotice: options?.onNotice,
     })) {
       const status = updatePlayLiveStatusState(state, event);
-      if (!status) {
+      if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
         continue;
       }
-      terminal = TERMINAL_PLAY_STATUSES.has(status.status);
-      if (terminal) {
-        break;
-      }
-    }
-    if (terminal && state.latest) {
-      return await this.getRunStatus(state.latest.runId || runId).catch(
+      return await this.getRunStatus(status.runId || runId).catch(
         () => state.latest ?? playRunStatusFromState(state),
       );
     }
-    if (state.latest) {
-      return state.latest;
+    if (options?.signal?.aborted) {
+      throw new DeeplineError('Run observation aborted.', undefined, 'ABORTED');
+    }
+    // The transport ends only after a terminal snapshot; the differ always
+    // emits a terminal `play.run.status` first, so reaching here means the
+    // terminal package read raced — re-check durable status once, loudly.
+    const refreshed = await this.getRunStatus(runId);
+    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
+      return refreshed;
     }
     throw new DeeplineError(
-      `Run stream for ${runId} ended before the initial snapshot.`,
+      `Run observation for ${runId} ended before a terminal status.`,
       undefined,
-      'PLAY_RUN_STREAM_EMPTY',
-      { runId },
+      'PLAY_LIVE_STREAM_ENDED',
     );
   }
 
+  /**
+   * Read the canonical run stream until a terminal run status is observed.
+   *
+   * Tries the Convex Run Snapshot subscription transport first (ADR-0008);
+   * when the server cannot serve it (grant endpoint missing/unconfigured or
+   * Convex unreachable) it falls back — with one `onNotice` message — to the
+   * support-window SSE stream below.
+   *
+   * Server stream windows are finite: they end cleanly at the function
+   * ceiling even while the run keeps executing. A window that ends (cleanly
+   * or via transient network error) without a terminal event triggers one
+   * durable-status re-check followed by a backed-off reconnect, so long runs
+   * tail to completion. Abort via `options.signal` to stop waiting.
+   */
+  async tailRun(runId: string, options?: RunsTailOptions): Promise<PlayStatus> {
+    try {
+      return await this.tailRunViaObserveTransport(runId, options);
+    } catch (error) {
+      if (!(error instanceof RunObserveTransportUnavailableError)) {
+        throw error;
+      }
+      options?.onNotice?.(
+        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`,
+      );
+    }
+    const state: PlayLiveStatusState = {
+      runId,
+      status: 'running',
+      logs: [],
+      lastLogSeq: 0,
+      latest: null,
+    };
+    let reconnectAttempt = 0;
+
+    for (;;) {
+      const connectedAt = Date.now();
+      let sawEvent = false;
+      let endedReason = 'stream window ended before a terminal event';
+      try {
+        for await (const event of this.streamPlayRunEvents(runId, {
+          mode: 'cli',
+          signal: options?.signal,
+        })) {
+          sawEvent = true;
+          const status = updatePlayLiveStatusState(state, event);
+          if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
+            continue;
+          }
+          return await this.getRunStatus(status.runId || runId).catch(
+            () => state.latest ?? playRunStatusFromState(state),
+          );
+        }
+      } catch (error) {
+        if (options?.signal?.aborted || !isTransientPlayStreamError(error)) {
+          throw error;
+        }
+        endedReason = error instanceof Error ? error.message : String(error);
+      }
+
+      // Window ended without a terminal event. The run may have finished
+      // during the gap — re-check durable status once before reconnecting.
+      // Non-transient status failures (e.g. 404 = run gone) fail loudly.
+      let refreshed: PlayStatus | null = null;
+      try {
+        refreshed = await this.getRunStatus(runId);
+      } catch (error) {
+        if (!isTransientPlayStreamError(error)) {
+          throw error;
+        }
+      }
+      if (refreshed && TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
+        return refreshed;
+      }
+
+      if (
+        sawEvent ||
+        Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS
+      ) {
+        reconnectAttempt = 0;
+      }
+      const delayMs = streamReconnectDelayMs(reconnectAttempt);
+      reconnectAttempt += 1;
+      options?.onReconnect?.({
+        attempt: reconnectAttempt,
+        delayMs,
+        reason: endedReason,
+      });
+      await sleep(delayMs);
+    }
+  }
+
   /**
    * Fetch persisted logs for a run using the public runs resource model.
    *
@@ -1611,23 +1831,51 @@ export class DeeplineClient {
     runId: string,
     options?: RunsLogsOptions,
   ): Promise<RunsLogsResult> {
-    const status = await this.getRunStatus(runId, { full: true });
-    const logs = status.progress?.logs ?? [];
-    const limit =
-      typeof options?.limit === 'number' && Number.isFinite(options.limit)
-        ? Math.max(0, Math.trunc(options.limit))
+    const limit = options?.all
+      ? Number.MAX_SAFE_INTEGER
+      : typeof options?.limit === 'number' &&
+          Number.isFinite(options.limit) &&
+          options.limit > 0
+        ? Math.trunc(options.limit)
         : 200;
-    const entries = logs.slice(Math.max(0, logs.length - limit));
+    const fetchPage = (afterSeq: number, pageLimit: number) =>
+      this.http.get<RunLogsPageResponse>(
+        `/api/v2/runs/${encodeURIComponent(runId)}/logs?afterSeq=${afterSeq}&limit=${pageLimit}`,
+      );
+    // Probe for the run's stored extent, then read the LAST `limit` stored
+    // lines (matching the historical tail-slice semantics), paginating in
+    // server-capped pages until the window is exhausted.
+    const probe = await fetchPage(0, 1);
+    const lastStoredSeq = probe.lastStoredSeq;
+    let afterSeq = options?.all ? 0 : Math.max(0, lastStoredSeq - limit);
+    const entries: Array<{ seq: number; line: string }> = [];
+    while (entries.length < limit) {
+      const page = await fetchPage(
+        afterSeq,
+        Math.min(RUN_LOGS_PAGE_LIMIT, limit - entries.length),
+      );
+      if (page.entries.length === 0) {
+        break;
+      }
+      entries.push(...page.entries);
+      afterSeq = page.entries[page.entries.length - 1]!.seq;
+      if (!page.hasMore) {
+        break;
+      }
+    }
+    const firstSequence = entries.length > 0 ? entries[0]!.seq : null;
+    const lastSequence =
+      entries.length > 0 ? entries[entries.length - 1]!.seq : null;
     return {
-      runId: status.runId,
-      totalCount: logs.length,
+      runId: probe.runId,
+      totalCount: probe.totalLogCount,
       returnedCount: entries.length,
-      firstSequence:
-        logs.length === 0 ? null : logs.length - entries.length + 1,
-      lastSequence: logs.length === 0 ? null : logs.length,
-      truncated: logs.length > entries.length,
-      hasMore: logs.length > entries.length,
-      entries,
+      firstSequence,
+      lastSequence,
+      truncated: entries.length < probe.totalLogCount,
+      hasMore: lastSequence !== null && lastSequence < lastStoredSeq,
+      entries: entries.map((entry) => entry.line),
+      ...(probe.logsTruncated ? { logsTruncated: true } : {}),
     };
   }
 
@@ -1993,6 +2241,7 @@ export class DeeplineClient {
       runId: workflowId,
       status: 'running',
       logs: [],
+      lastLogSeq: 0,
       latest: null,
     };
 

package/dist/repo/sdk/src/index.ts

@@ -55,6 +55,7 @@
 
 // ——— Client ———
 export { DeeplineClient } from './client.js';
+export { RunObserveTransportUnavailableError } from './runs/observe-transport.js';
 export type {
   PlayStatus,
   PlaySheetRow,