@astralform/js 5.1.0 → 6.0.1

package/dist/index.d.cts

@@ -1400,11 +1400,12 @@ declare class ChatSession {
     /**
      * Rename a conversation, server first.
      *
-     * Deliberately NOT optimistic, unlike the delete below. A failed delete is
-     * self-correcting (the row is still there on the next page fetch), but a
-     * failed rename that had already been written locally would leave the
-     * sidebar showing a title the server never accepted — and nothing refetches
-     * a conversation that is already in the loaded list.
+     * Server first, like the delete below: a failed rename written locally would
+     * leave the sidebar showing a title the server never accepted, and nothing
+     * refetches a conversation that is already in the loaded list. (The delete
+     * used to be the counter-example here — it dropped the row whatever the
+     * server said, on the theory that a failed one was self-correcting. It was
+     * not: the row stayed deleted locally and alive on the server.)
      *
      * Mirrors the `title_generated` path: the entry in `conversations` is
      * mutated in place, which is what every consumer of the list reads.
@@ -1444,7 +1445,21 @@ declare class LLMNotConfiguredError extends AstralformError {
     constructor(message?: string);
 }
 declare class ServerError extends AstralformError {
-    constructor(message?: string);
+    /**
+     * The HTTP status, when this came from a response.
+     *
+     * Every status except 401 and 429 collapses into this one class, so without
+     * it a caller cannot tell "the thing is already gone" (404) from "the server
+     * broke" (500) or "this is not yours" (403) — the message is the only other
+     * signal and it is prose. `deleteConversation` is the case that forced it:
+     * it read EVERY failure as already-deleted and dropped the conversation
+     * locally regardless, so a 500 looked exactly like success and the row came
+     * back on the next device.
+     *
+     * Undefined when a ServerError is constructed without a response.
+     */
+    readonly status?: number;
+    constructor(message?: string, status?: number);
 }
 declare class ConnectionError extends AstralformError {
     constructor(message?: string);
@@ -1517,6 +1532,13 @@ declare class StreamManager {
      * one the user is waiting on — see ``restore``.
      */
     private generation;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    private turnCounter;
     constructor(session: ChatSession);
     get state(): StreamState;
     get activeConversationId(): string | null;
@@ -1593,6 +1615,45 @@ declare class StreamManager {
     private settleIdle;
     private finalizeStream;
     private restore;
+    /**
+     * Has a live turn taken the block view over?
+     *
+     * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+     * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+     * while the session only raises its flag inside ``processStream``, behind the
+     * ``storage.addMessage`` write. For that whole window a send is underway —
+     * composer cleared, optimistic bubble drawn — and the session flag still
+     * reads false. Reading both closes the window from either end, since
+     * ``reconnectToJob`` is the mirror case: it raises the session flag without
+     * ever moving ``_state``.
+     */
+    private viewTakenOverByLiveTurn;
+    /**
+     * Has a turn STARTED since ``turn`` was captured?
+     *
+     * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+     * turn that both started and ENDED inside one of the restore's awaits — a
+     * send that fails fast (auth, rate limit) resolves in about the time the job
+     * list takes, and leaves `_state` back at idle with its blocks already
+     * rendered. A monotonic count is the only thing that survives a state that
+     * has returned to where it started.
+     */
+    private turnStarted;
+    /**
+     * Replay a conversation's persisted history into the consumer's block view.
+     *
+     * Returns false when this restore lost the right to finish — a newer switch
+     * superseded it, or a send took the view over — in which case the caller
+     * must stop rather than finish. See ``restore``.
+     *
+     * ``activeJobId`` names the turn that is still running, if any. Its events
+     * are NOT fetched here: they are the live stream the caller reconnects to
+     * straight after. It is passed so ``planRestore`` can pair it with the prompt
+     * that started it, which is emitted as a bubble with no events — the whole
+     * reason a conversation reopened mid-turn now shows the message that started
+     * that turn.
+     */
+    private replayHistory;
     private setActiveConversation;
 }
 

package/dist/index.d.ts

@@ -1400,11 +1400,12 @@ declare class ChatSession {
     /**
      * Rename a conversation, server first.
      *
-     * Deliberately NOT optimistic, unlike the delete below. A failed delete is
-     * self-correcting (the row is still there on the next page fetch), but a
-     * failed rename that had already been written locally would leave the
-     * sidebar showing a title the server never accepted — and nothing refetches
-     * a conversation that is already in the loaded list.
+     * Server first, like the delete below: a failed rename written locally would
+     * leave the sidebar showing a title the server never accepted, and nothing
+     * refetches a conversation that is already in the loaded list. (The delete
+     * used to be the counter-example here — it dropped the row whatever the
+     * server said, on the theory that a failed one was self-correcting. It was
+     * not: the row stayed deleted locally and alive on the server.)
      *
      * Mirrors the `title_generated` path: the entry in `conversations` is
      * mutated in place, which is what every consumer of the list reads.
@@ -1444,7 +1445,21 @@ declare class LLMNotConfiguredError extends AstralformError {
     constructor(message?: string);
 }
 declare class ServerError extends AstralformError {
-    constructor(message?: string);
+    /**
+     * The HTTP status, when this came from a response.
+     *
+     * Every status except 401 and 429 collapses into this one class, so without
+     * it a caller cannot tell "the thing is already gone" (404) from "the server
+     * broke" (500) or "this is not yours" (403) — the message is the only other
+     * signal and it is prose. `deleteConversation` is the case that forced it:
+     * it read EVERY failure as already-deleted and dropped the conversation
+     * locally regardless, so a 500 looked exactly like success and the row came
+     * back on the next device.
+     *
+     * Undefined when a ServerError is constructed without a response.
+     */
+    readonly status?: number;
+    constructor(message?: string, status?: number);
 }
 declare class ConnectionError extends AstralformError {
     constructor(message?: string);
@@ -1517,6 +1532,13 @@ declare class StreamManager {
      * one the user is waiting on — see ``restore``.
      */
     private generation;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    private turnCounter;
     constructor(session: ChatSession);
     get state(): StreamState;
     get activeConversationId(): string | null;
@@ -1593,6 +1615,45 @@ declare class StreamManager {
     private settleIdle;
     private finalizeStream;
     private restore;
+    /**
+     * Has a live turn taken the block view over?
+     *
+     * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+     * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+     * while the session only raises its flag inside ``processStream``, behind the
+     * ``storage.addMessage`` write. For that whole window a send is underway —
+     * composer cleared, optimistic bubble drawn — and the session flag still
+     * reads false. Reading both closes the window from either end, since
+     * ``reconnectToJob`` is the mirror case: it raises the session flag without
+     * ever moving ``_state``.
+     */
+    private viewTakenOverByLiveTurn;
+    /**
+     * Has a turn STARTED since ``turn`` was captured?
+     *
+     * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+     * turn that both started and ENDED inside one of the restore's awaits — a
+     * send that fails fast (auth, rate limit) resolves in about the time the job
+     * list takes, and leaves `_state` back at idle with its blocks already
+     * rendered. A monotonic count is the only thing that survives a state that
+     * has returned to where it started.
+     */
+    private turnStarted;
+    /**
+     * Replay a conversation's persisted history into the consumer's block view.
+     *
+     * Returns false when this restore lost the right to finish — a newer switch
+     * superseded it, or a send took the view over — in which case the caller
+     * must stop rather than finish. See ``restore``.
+     *
+     * ``activeJobId`` names the turn that is still running, if any. Its events
+     * are NOT fetched here: they are the live stream the caller reconnects to
+     * straight after. It is passed so ``planRestore`` can pair it with the prompt
+     * that started it, which is emitted as a bubble with no events — the whole
+     * reason a conversation reopened mid-turn now shows the message that started
+     * that turn.
+     */
+    private replayHistory;
     private setActiveConversation;
 }
 

package/dist/index.js

@@ -26,9 +26,10 @@ var LLMNotConfiguredError = class extends AstralformError {
   }
 };
 var ServerError = class extends AstralformError {
-  constructor(message = "Internal server error") {
+  constructor(message = "Internal server error", status) {
     super(message, "server_error");
     this.name = "ServerError";
+    if (status !== void 0) Object.assign(this, { status });
   }
 };
 var ConnectionError = class extends AstralformError {
@@ -58,6 +59,16 @@ function generateId() {
     return v.toString(16);
   });
 }
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelizeKeys(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[snakeToCamel(key)] = obj[key];
+  }
+  return result;
+}
 
 // src/rate-limit.ts
 var DEFAULT_MESSAGE = "Rate limit exceeded";
@@ -208,7 +219,7 @@ async function* streamJobSSE(options) {
       case 429:
         throw createRateLimitErrorFromHttp(response, rawText);
       default:
-        throw new ServerError(text || `HTTP ${response.status}`);
+        throw new ServerError(text || `HTTP ${response.status}`, response.status);
     }
   }
   if (!response.body) {
@@ -479,7 +490,10 @@ var AstralformClient = class {
         throw createRateLimitErrorFromHttp(response, text);
       default: {
         const safeText = text ? sanitizeErrorText(text) : "";
-        throw new ServerError(safeText || `HTTP ${response.status}`);
+        throw new ServerError(
+          safeText || `HTTP ${response.status}`,
+          response.status
+        );
       }
     }
   }
@@ -516,13 +530,7 @@ var AstralformClient = class {
     const safeLimit = Math.max(1, Math.min(200, Math.floor(Number(limit))));
     const safeOffset = Math.max(0, Math.floor(Number(offset)));
     const raw = await this.get(`/v1/conversations?limit=${safeLimit}&offset=${safeOffset}`);
-    return raw.map((c) => ({
-      id: c.id,
-      title: c.title,
-      messageCount: c.message_count,
-      createdAt: c.created_at,
-      updatedAt: c.updated_at
-    }));
+    return raw.map((c) => camelizeKeys(c));
   }
   async getMessages(conversationId) {
     const raw = await this.get(`/v1/conversations/${encodeURIComponent(conversationId)}/messages`);
@@ -547,13 +555,7 @@ var AstralformClient = class {
    */
   async renameConversation(id, title) {
     const c = await this.patch(`/v1/conversations/${encodeURIComponent(id)}`, { title });
-    return {
-      id: c.id,
-      title: c.title,
-      messageCount: c.message_count,
-      createdAt: c.created_at,
-      updatedAt: c.updated_at
-    };
+    return camelizeKeys(c);
   }
   async deleteConversation(id) {
     await this.del(`/v1/conversations/${encodeURIComponent(id)}`);
@@ -566,14 +568,7 @@ var AstralformClient = class {
    */
   async getAgents() {
     const raw = await this.get("/v1/agents");
-    return raw.map((a) => ({
-      name: a.name,
-      displayName: a.display_name,
-      description: a.description,
-      isOrchestrator: a.is_orchestrator,
-      isEnabled: a.is_enabled,
-      avatarUrl: a.avatar_url
-    }));
+    return raw.map((a) => camelizeKeys(a));
   }
   /**
    * List the models the caller may pick this turn — expanded from the curated
@@ -600,12 +595,7 @@ var AstralformClient = class {
   }
   async getSkills() {
     const raw = await this.get("/v1/skills");
-    return raw.map((s) => ({
-      name: s.name,
-      displayName: s.display_name,
-      description: s.description,
-      isEnabled: s.is_enabled
-    }));
+    return raw.map((s) => camelizeKeys(s));
   }
   async getConversationEvents(conversationId, jobId) {
     let url = `/v1/conversations/${encodeURIComponent(conversationId)}/events`;
@@ -722,13 +712,7 @@ var AstralformClient = class {
   // sending them in API-key mode yields 401.
   async listTeams() {
     const raw = await this.get("/v1/teams");
-    return raw.map((t) => ({
-      id: t.id,
-      name: t.name,
-      slug: t.slug,
-      isDefault: t.is_default,
-      role: t.role
-    }));
+    return raw.map((t) => camelizeKeys(t));
   }
   /**
    * List the team-level agents (formerly "projects") the signed-in user can
@@ -737,14 +721,7 @@ var AstralformClient = class {
    */
   async listAgents(teamId) {
     const raw = await this.get(`/v1/teams/${encodeURIComponent(teamId)}/agents`);
-    return raw.map((a) => ({
-      id: a.id,
-      name: a.name,
-      teamId: a.team_id,
-      createdAt: a.created_at,
-      updatedAt: a.updated_at,
-      avatarUrl: a.avatar_url ?? null
-    }));
+    return raw.map((a) => camelizeKeys(a));
   }
   // --- Jobs API ---
   async createJob(request) {
@@ -781,13 +758,7 @@ var AstralformClient = class {
     };
     if (request.comment != null) body.comment = request.comment;
     const raw = await this.post(`/v1/jobs/${encodeURIComponent(jobId)}/feedback`, body);
-    return {
-      id: raw.id,
-      jobId: raw.job_id,
-      rating: raw.rating,
-      comment: raw.comment,
-      createdAt: raw.created_at
-    };
+    return camelizeKeys(raw);
   }
   async getActiveJob(conversationId) {
     const raw = await this.get(`/v1/conversations/${encodeURIComponent(conversationId)}/active-job`);
@@ -2175,11 +2146,12 @@ var ChatSession = class {
   /**
    * Rename a conversation, server first.
    *
-   * Deliberately NOT optimistic, unlike the delete below. A failed delete is
-   * self-correcting (the row is still there on the next page fetch), but a
-   * failed rename that had already been written locally would leave the
-   * sidebar showing a title the server never accepted — and nothing refetches
-   * a conversation that is already in the loaded list.
+   * Server first, like the delete below: a failed rename written locally would
+   * leave the sidebar showing a title the server never accepted, and nothing
+   * refetches a conversation that is already in the loaded list. (The delete
+   * used to be the counter-example here — it dropped the row whatever the
+   * server said, on the theory that a failed one was self-correcting. It was
+   * not: the row stayed deleted locally and alive on the server.)
    *
    * Mirrors the `title_generated` path: the entry in `conversations` is
    * mutated in place, which is what every consumer of the list reads.
@@ -2195,7 +2167,8 @@ var ChatSession = class {
   async deleteConversation(id) {
     try {
       await this.client.deleteConversation(id);
-    } catch {
+    } catch (err) {
+      if (!(err instanceof ServerError) || err.status !== 404) throw err;
     }
     await this.storage.deleteConversation(id);
     if (this.serverConversationIds.delete(id)) {
@@ -2221,9 +2194,10 @@ var ChatSession = class {
 
 // src/restore-plan.ts
 function planRestore(args) {
-  const { completedJobs, userMessages } = args;
+  const { completedJobs, runningJob, userMessages } = args;
+  const jobs = runningJob ? [...completedJobs, runningJob] : completedJobs;
   const claimed = new Set(
-    (args.claimedMessageIds ?? completedJobs.map((j) => j.message_id)).filter(
+    (args.claimedMessageIds ?? jobs.map((j) => j.message_id)).filter(
       (id) => !!id
     )
   );
@@ -2232,19 +2206,19 @@ function planRestore(args) {
     if (m.id) byId.set(m.id, i);
   });
   const linkOf = (j) => j.message_id ? byId.get(j.message_id) : void 0;
-  const positional = (jobs, msgs) => jobs.map((job, i) => ({
+  const positional = (slice, msgs) => slice.map((job, i) => ({
     kind: "turn",
     jobId: job.job_id,
     content: msgs[i]?.content,
     messageId: msgs[i]?.id
   }));
-  const firstLinked = completedJobs.findIndex((j) => linkOf(j) !== void 0);
+  const firstLinked = jobs.findIndex((j) => linkOf(j) !== void 0);
   if (firstLinked === -1) {
-    return positional(completedJobs, userMessages);
+    return positional(jobs, userMessages);
   }
-  const cutover = linkOf(completedJobs[firstLinked]);
+  const cutover = linkOf(jobs[firstLinked]);
   const steps = positional(
-    completedJobs.slice(0, firstLinked),
+    jobs.slice(0, firstLinked),
     userMessages.slice(0, cutover)
   );
   let cursor = cutover;
@@ -2258,7 +2232,7 @@ function planRestore(args) {
     }
     cursor = stopAt + 1;
   };
-  for (const job of completedJobs.slice(firstLinked)) {
+  for (const job of jobs.slice(firstLinked)) {
     const at = linkOf(job);
     if (at !== void 0) {
       drainTo(at);
@@ -2340,6 +2314,13 @@ var StreamManager = class {
      * one the user is waiting on — see ``restore``.
      */
     this.generation = 0;
+    /**
+     * Bumped every time a turn STARTS. `generation` does not move for a send
+     * (only a pointer move does), and the streaming state returns to idle when a
+     * turn ends — so neither can tell a restore that a turn ran inside one of
+     * its awaits. This can.
+     */
+    this.turnCounter = 0;
     this.session = session;
     this.attach();
   }
@@ -2408,6 +2389,7 @@ var StreamManager = class {
       target = await this.session.createNewConversation();
       this.setActiveConversation(target);
     }
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.send(content, {
@@ -2444,6 +2426,7 @@ var StreamManager = class {
     );
     const lastUserMsg = userMsgs[userMsgs.length - 1];
     if (!lastUserMsg) return;
+    this.turnCounter++;
     this.setState("streaming");
     try {
       await this.session.resendFromCheckpoint(
@@ -2644,7 +2627,9 @@ var StreamManager = class {
   async restore(conversationId, gen) {
     const superseded = () => gen !== this.generation;
     if (superseded()) return;
-    if (!this.session.isStreaming) this.setState("restoring");
+    const turn = this.turnCounter;
+    const announcedRestoring = !this.session.isStreaming;
+    if (announcedRestoring) this.setState("restoring");
     let activeJobId = null;
     try {
       const res = await this.session.client.getActiveJob(conversationId);
@@ -2652,9 +2637,12 @@ var StreamManager = class {
     } catch {
     }
     if (superseded()) return;
+    await this.session.loadConversation(conversationId);
+    if (superseded()) return;
+    if (announcedRestoring && this.viewTakenOverByLiveTurn()) return;
+    if (announcedRestoring && !await this.replayHistory(conversationId, gen, activeJobId, turn))
+      return;
     if (activeJobId) {
-      await this.session.loadConversation(conversationId);
-      if (superseded()) return;
       this.setState("streaming");
       try {
         await this.session.reconnectToJob(activeJobId);
@@ -2665,76 +2653,125 @@ var StreamManager = class {
         this.setState("idle");
       }
     } else {
-      await this.session.loadConversation(conversationId);
       if (superseded()) return;
-      try {
-        const jobs = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/jobs`);
-        if (superseded()) return;
-        const completedJobs = jobs.filter(
-          (j) => j.status === "completed"
-        );
-        const userMessages = this.session.messages.filter(
-          (m) => m.role === "user"
-        );
-        const plan = planRestore({
-          completedJobs: completedJobs.map((j) => ({
-            job_id: j.job_id,
-            message_id: j.message_id
-          })),
-          // Completed jobs PLUS the ones still going. A send landing in the
-          // probe window has a running job, so its prompt is claimed and does
-          // not read as a steer replayed over the bubble the live send already
-          // rendered. Failed and cancelled jobs are deliberately NOT claimed:
-          // they produce no `turn` step, so claiming them would delete the
-          // user's prompt from the restore entirely rather than show it as a
-          // steer.
-          claimedMessageIds: jobs.filter((j) => j.status !== "failed" && j.status !== "cancelled").map((j) => j.message_id),
-          userMessages: userMessages.map((m) => ({
-            id: m.id,
-            content: m.content
-          }))
-        });
-        const eventLists = await Promise.all(
-          completedJobs.map(
-            (job) => this.session.client.getConversationEvents(conversationId, job.job_id).catch(() => [])
-          )
-        );
-        if (superseded()) return;
-        const eventsByJobId = new Map(
-          completedJobs.map((job, i) => [job.job_id, eventLists[i] ?? []])
-        );
-        for (const step of plan) {
-          if (superseded()) return;
-          if (step.kind === "steer") {
-            this.session.replayTurn(
-              conversationId,
-              [],
-              step.content,
-              step.messageId,
-              true
-            );
-            continue;
-          }
+      this.settleIdle();
+    }
+  }
+  /**
+   * Has a live turn taken the block view over?
+   *
+   * ``_state`` is the SYNCHRONOUS authority and ``session.isStreaming`` lags it
+   * by an await: ``send`` sets ``_state = "streaming"`` before its first await,
+   * while the session only raises its flag inside ``processStream``, behind the
+   * ``storage.addMessage`` write. For that whole window a send is underway —
+   * composer cleared, optimistic bubble drawn — and the session flag still
+   * reads false. Reading both closes the window from either end, since
+   * ``reconnectToJob`` is the mirror case: it raises the session flag without
+   * ever moving ``_state``.
+   */
+  viewTakenOverByLiveTurn() {
+    return this._state === "streaming" || this.session.isStreaming;
+  }
+  /**
+   * Has a turn STARTED since ``turn`` was captured?
+   *
+   * ``viewTakenOverByLiveTurn`` reads the current state, so it cannot see a
+   * turn that both started and ENDED inside one of the restore's awaits — a
+   * send that fails fast (auth, rate limit) resolves in about the time the job
+   * list takes, and leaves `_state` back at idle with its blocks already
+   * rendered. A monotonic count is the only thing that survives a state that
+   * has returned to where it started.
+   */
+  turnStarted(since) {
+    return this.turnCounter !== since;
+  }
+  /**
+   * Replay a conversation's persisted history into the consumer's block view.
+   *
+   * Returns false when this restore lost the right to finish — a newer switch
+   * superseded it, or a send took the view over — in which case the caller
+   * must stop rather than finish. See ``restore``.
+   *
+   * ``activeJobId`` names the turn that is still running, if any. Its events
+   * are NOT fetched here: they are the live stream the caller reconnects to
+   * straight after. It is passed so ``planRestore`` can pair it with the prompt
+   * that started it, which is emitted as a bubble with no events — the whole
+   * reason a conversation reopened mid-turn now shows the message that started
+   * that turn.
+   */
+  async replayHistory(conversationId, gen, activeJobId, turn) {
+    const stopReplay = () => gen !== this.generation || this.viewTakenOverByLiveTurn() || this.turnStarted(turn);
+    try {
+      const jobs = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/jobs`);
+      if (stopReplay()) return false;
+      const completedJobs = jobs.filter(
+        (j) => j.status === "completed" && j.job_id !== activeJobId
+      );
+      const userMessages = this.session.messages.filter(
+        (m) => m.role === "user"
+      );
+      const runningJob = activeJobId ? jobs.find((j) => j.job_id === activeJobId) : void 0;
+      const plan = planRestore({
+        completedJobs: completedJobs.map((j) => ({
+          job_id: j.job_id,
+          message_id: j.message_id
+        })),
+        runningJob: runningJob && {
+          job_id: runningJob.job_id,
+          message_id: runningJob.message_id
+        },
+        // Completed jobs PLUS the ones still going. A send landing in the
+        // probe window has a running job, so its prompt is claimed and does
+        // not read as a steer replayed over the bubble the live send already
+        // rendered. Failed and cancelled jobs are deliberately NOT claimed:
+        // they produce no `turn` step, so claiming them would delete the
+        // user's prompt from the restore entirely rather than show it as a
+        // steer.
+        claimedMessageIds: jobs.filter((j) => j.status !== "failed" && j.status !== "cancelled").map((j) => j.message_id),
+        userMessages: userMessages.map((m) => ({
+          id: m.id,
+          content: m.content
+        }))
+      });
+      const eventLists = await Promise.all(
+        completedJobs.map(
+          (job) => this.session.client.getConversationEvents(conversationId, job.job_id).catch(() => [])
+        )
+      );
+      if (stopReplay()) return false;
+      const eventsByJobId = new Map(
+        completedJobs.map((job, i) => [job.job_id, eventLists[i] ?? []])
+      );
+      for (const step of plan) {
+        if (stopReplay()) return false;
+        if (step.kind === "steer") {
           this.session.replayTurn(
             conversationId,
-            eventsByJobId.get(step.jobId) ?? [],
+            [],
             step.content,
-            step.messageId
+            step.messageId,
+            true
           );
+          continue;
         }
-        if (superseded()) return;
-        if (completedJobs.length > 0) {
-          this.emit({
-            type: "versionsReady",
-            conversationId,
-            count: completedJobs.length
-          });
-        }
-      } catch {
+        this.session.replayTurn(
+          conversationId,
+          eventsByJobId.get(step.jobId) ?? [],
+          step.content,
+          step.messageId
+        );
       }
-      if (superseded()) return;
-      this.settleIdle();
+      if (stopReplay()) return false;
+      if (completedJobs.length > 0) {
+        this.emit({
+          type: "versionsReady",
+          conversationId,
+          count: completedJobs.length
+        });
+      }
+    } catch {
     }
+    return !stopReplay();
   }
   // ── Internal: set active conversation ─────────────────────────
   setActiveConversation(id) {