fix(slack): Preserve progress across agent resumes

packages/junior/src/chat/agent/index.ts

@@ -501,6 +501,19 @@ async function executeAgentRunInPrivacyContext(
               const handoffThinkingLevel = toAgentThinkingLevel(
                 thinkingSelection!.thinkingLevel,
               );
+              void (async () => {
+                await observers.onStatus?.({ text: "Switching models" });
+              })().catch((error) => {
+                logWarn(
+                  "assistant_status_observer_failed",
+                  {},
+                  {
+                    "exception.message":
+                      error instanceof Error ? error.message : String(error),
+                  },
+                  "Failed to report assistant status",
+                );
+              });
               const handoffMessages = await compactContextForHandoff(
                 {
                   conversationContext: input.conversationContext,

packages/junior/src/chat/runtime/agent-continue-runner.ts

@@ -83,6 +83,7 @@ import {
   retainRuntimeTurnContext,
   stripRuntimeTurnContext,
 } from "@/chat/pi/transcript";
+import { latestReportedProgress } from "@/chat/runtime/report-progress";
 
 const AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS = [250, 1_000, 2_000] as const;
 
@@ -395,9 +396,17 @@ export async function continueSlackAgentRun(
           return false;
         }
 
+        const turnMessages =
+          activeSessionRecord.turnStartMessageIndex === undefined
+            ? []
+            : activeSessionRecord.piMessages.slice(
+                activeSessionRecord.turnStartMessageIndex,
+              );
+
         return {
           messageText: userMessage.text,
           messageTs: getTurnUserSlackMessageTs(userMessage),
+          initialStatus: latestReportedProgress(turnMessages),
           replyContext: {
             input: {
               conversationContext,

packages/junior/src/chat/runtime/reply-executor.ts

@@ -1018,7 +1018,7 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
                   channelId,
                   runId,
                 },
-                onCompactionStart: () => status.start(compactingStatus),
+                onCompactionStart: () => status.update(compactingStatus),
                 piMessages,
               });
             if (compaction.compacted) {
@@ -1077,7 +1077,7 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
             }
           }
 
-          status.start();
+          status.update();
           const assistantTitleTask = maybeUpdateAssistantTitle({
             assistantThreadContext,
             assistantUserName: botConfig.userName,
@@ -1726,7 +1726,7 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
               );
             }
           }
-          await status.stop();
+          await status.clear();
         }
       },
     );

packages/junior/src/chat/runtime/report-progress.ts

@@ -1,3 +1,4 @@
+import type { PiMessage } from "@/chat/pi/messages";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
 
 /** Convert a `reportProgress` tool payload into assistant status text. */
@@ -20,3 +21,45 @@ export function buildReportedProgressStatus(
 
   return { text };
 }
+
+/** Recover the latest explicit progress update from a resumable Pi transcript. */
+export function latestReportedProgress(
+  messages: readonly PiMessage[],
+): AssistantStatusSpec | undefined {
+  for (
+    let messageIndex = messages.length - 1;
+    messageIndex >= 0;
+    messageIndex -= 1
+  ) {
+    const message = messages[messageIndex] as {
+      role?: unknown;
+      content?: unknown;
+    };
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+      continue;
+    }
+    for (
+      let partIndex = message.content.length - 1;
+      partIndex >= 0;
+      partIndex -= 1
+    ) {
+      const part = message.content[partIndex];
+      if (!part || typeof part !== "object") {
+        continue;
+      }
+      const toolCall = part as {
+        type?: unknown;
+        name?: unknown;
+        arguments?: unknown;
+      };
+      if (toolCall.type !== "toolCall" || toolCall.name !== "reportProgress") {
+        continue;
+      }
+      const status = buildReportedProgressStatus(toolCall.arguments);
+      if (status) {
+        return status;
+      }
+    }
+  }
+  return undefined;
+}

packages/junior/src/chat/runtime/slack-resume.ts

@@ -25,6 +25,7 @@ import { persistThreadStateById } from "@/chat/runtime/thread-state";
 import {
   createSlackWebApiAssistantStatusSession,
   type AssistantStatusSession,
+  type AssistantStatusSpec,
 } from "@/chat/slack/assistant-thread/status";
 import {
   buildSlackReplyFooter,
@@ -136,6 +137,7 @@ interface ResumeSlackTurnArgs {
   replyContext?: ResumeReplyContext;
   lockKey?: string;
   initialText?: string;
+  initialStatus?: AssistantStatusSpec;
   agentRunner: AgentRunner;
   scheduleSessionCompletedPluginTasks?: (params: {
     conversationId: string;
@@ -406,7 +408,7 @@ export async function resumeSlackTurn(
         runArgs.initialText,
       );
     }
-    status.start();
+    status.update(runArgs.initialStatus);
 
     const replyContext = createResumeReplyContext(runArgs, status);
     const replyPromise = runArgs.agentRunner.run(replyContext);
@@ -431,7 +433,7 @@ export async function resumeSlackTurn(
     if (outcome.status !== "completed") {
       // Expected pauses defer their handlers until the lock is released,
       // mirroring the failure path below.
-      await status.stop();
+      await status.clear();
       const onAuthPause = runArgs.onAuthPause;
       const onTimeoutPause = runArgs.onTimeoutPause;
       if (outcome.status === "awaiting_auth" && onAuthPause) {
@@ -471,7 +473,7 @@ export async function resumeSlackTurn(
         context: getResumeLogContext(runArgs, lockKey),
       });
 
-      await status.stop();
+      await status.clear();
       const footer = buildSlackReplyFooter({
         conversationId: getResumeConversationId(runArgs, lockKey),
       });
@@ -541,7 +543,7 @@ export async function resumeSlackTurn(
       }
     }
   } catch (error) {
-    await status.stop();
+    await status.clear();
 
     if (finalReplyDelivered) {
       postDeliveryCommitError = error;

packages/junior/src/chat/slack/assistant-thread/status-scheduler.ts

@@ -12,9 +12,10 @@ const STATUS_ROTATION_INTERVAL_MS = 30_000;
 export type TimerHandle = ReturnType<typeof setTimeout>;
 
 export interface AssistantStatusSession {
-  start: (status?: AssistantStatusSpec) => void;
-  stop: () => Promise<void>;
-  update: (status: AssistantStatusSpec) => void;
+  /** Activate or replace the loading state; omit status to show generic loading. */
+  update: (status?: AssistantStatusSpec) => void;
+  /** Stop refresh scheduling and clear the loading state. */
+  clear: () => Promise<void>;
 }
 
 /**
@@ -59,7 +60,7 @@ export function createAssistantStatusScheduler(args: {
 
   const enqueueStatusUpdate = (task: () => Promise<void>): Promise<void> => {
     // Status writes are best effort, but they still need strict ordering so a
-    // slow "thinking" write cannot land after stop() already cleared the UI.
+    // slow "thinking" write cannot land after clear() already cleared the UI.
     const request = inflightStatusUpdate
       .catch(() => undefined)
       .then(async () => {
@@ -172,17 +173,7 @@ export function createAssistantStatusScheduler(args: {
   };
 
   return {
-    start(status?: AssistantStatusSpec) {
-      active = true;
-      clearPending();
-      if (status) {
-        void postRenderedStatus(status);
-        return;
-      }
-      currentKey = "initial";
-      void postStatus(getInitialStatusText(), loadingMessages);
-    },
-    async stop() {
+    async clear() {
       active = false;
       clearPending();
       if (rotationTimer) {
@@ -192,8 +183,22 @@ export function createAssistantStatusScheduler(args: {
       currentKey = "";
       await postStatus("");
     },
-    update(status: AssistantStatusSpec) {
+    update(status?: AssistantStatusSpec) {
       if (!active) {
+        active = true;
+        clearPending();
+        if (status) {
+          void postRenderedStatus(status);
+          return;
+        }
+        currentKey = "initial";
+        void postStatus(getInitialStatusText(), loadingMessages);
+        return;
+      }
+      if (!status) {
+        clearPending();
+        currentKey = "initial";
+        void postStatus(getInitialStatusText(), loadingMessages);
         return;
       }
       const presentation = renderAssistantStatus({