@ouro.bot/cli 0.1.0-alpha.49 → 0.1.0-alpha.50

package/dist/mind/pending.js

@@ -35,8 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INNER_DIALOG_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
+exports.getDeferredReturnDir = getDeferredReturnDir;
 exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
 exports.hasPendingMessages = hasPendingMessages;
+exports.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -45,6 +48,9 @@ const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
     return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
+function getDeferredReturnDir(agentName, friendId) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending-returns", friendId);
+}
 /** Canonical inner-dialog pending path segments. */
 exports.INNER_DIALOG_PENDING = { friendId: "self", channel: "inner", key: "dialog" };
 /** Returns the pending dir for this agent's inner dialog. */
@@ -61,15 +67,22 @@ function hasPendingMessages(pendingDir) {
         return false;
     }
 }
-function drainPending(pendingDir) {
-    if (!fs.existsSync(pendingDir))
-        return [];
+function writeQueueFile(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
+    return filePath;
+}
+function drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
     let entries;
     try {
-        entries = fs.readdirSync(pendingDir);
+        entries = fs.readdirSync(queueDir);
     }
     catch {
-        return [];
+        return { messages: [], recovered: 0 };
     }
     // Collect both .json (new) and .processing (crash recovery)
     const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
@@ -81,9 +94,9 @@ function drainPending(pendingDir) {
     ].sort((a, b) => a.file.localeCompare(b.file));
     const messages = [];
     for (const { file, needsRename } of allFiles) {
-        const srcPath = path.join(pendingDir, file);
+        const srcPath = path.join(queueDir, file);
         const processingPath = needsRename
-            ? path.join(pendingDir, file + ".processing")
+            ? path.join(queueDir, file + ".processing")
             : srcPath;
         try {
             if (needsRename) {
@@ -102,11 +115,42 @@ function drainPending(pendingDir) {
             catch { /* ignore */ }
         }
     }
+    return {
+        messages,
+        recovered: processingFiles.length,
+    };
+}
+function enqueueDeferredReturn(agentName, friendId, message) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const filePath = writeQueueFile(queueDir, message);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_return_enqueued",
+        component: "mind",
+        message: "deferred return queued for later friend delivery",
+        meta: { friendId, queueDir },
+    });
+    return filePath;
+}
+function drainDeferredReturns(agentName, friendId) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const { messages } = drainQueue(queueDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_returns_drained",
+        component: "mind",
+        message: "deferred friend returns drained",
+        meta: { friendId, queueDir, count: messages.length },
+    });
+    return messages;
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    const { messages, recovered } = drainQueue(pendingDir);
     (0, runtime_1.emitNervesEvent)({
         event: "mind.pending_drained",
         component: "mind",
         message: "pending queue drained",
-        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+        meta: { pendingDir, count: messages.length, recovered },
     });
     return messages;
 }

package/dist/mind/prompt.js

@@ -56,6 +56,8 @@ const runtime_1 = require("../nerves/runtime");
 const bundle_manifest_1 = require("./bundle-manifest");
 const first_impressions_1 = require("./first-impressions");
 const tasks_1 = require("../repertoire/tasks");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
 let _senseStatusLinesCache = null;
@@ -85,80 +87,25 @@ function resetPsycheCache() {
     _senseStatusLinesCache = null;
 }
 const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
-function resolveFriendName(friendId, friendsDir, agentName) {
-    if (friendId === "self")
-        return agentName;
-    try {
-        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
-        const record = JSON.parse(raw);
-        return record.name ?? friendId;
-    }
-    catch {
-        return friendId;
-    }
-}
 function buildSessionSummary(options) {
     const { sessionsDir, friendsDir, agentName, currentFriendId, currentChannel, currentKey, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, } = options;
-    if (!fs.existsSync(sessionsDir))
-        return "";
     const now = Date.now();
-    const entries = [];
-    let friendDirs;
-    try {
-        friendDirs = fs.readdirSync(sessionsDir);
-    }
-    catch {
-        return "";
-    }
-    for (const friendId of friendDirs) {
-        const friendPath = path.join(sessionsDir, friendId);
-        let channels;
-        try {
-            channels = fs.readdirSync(friendPath);
-        }
-        catch {
-            continue;
-        }
-        for (const channel of channels) {
-            const channelPath = path.join(friendPath, channel);
-            let keys;
-            try {
-                keys = fs.readdirSync(channelPath);
-            }
-            catch {
-                continue;
-            }
-            for (const keyFile of keys) {
-                if (!keyFile.endsWith(".json"))
-                    continue;
-                const key = keyFile.replace(/\.json$/, "");
-                // Exclude current session
-                if (friendId === currentFriendId && channel === currentChannel && key === currentKey) {
-                    continue;
-                }
-                const filePath = path.join(channelPath, keyFile);
-                let mtimeMs;
-                try {
-                    mtimeMs = fs.statSync(filePath).mtimeMs;
-                }
-                catch {
-                    continue;
-                }
-                if (now - mtimeMs > activeThresholdMs)
-                    continue;
-                const displayName = resolveFriendName(friendId, friendsDir, agentName);
-                entries.push({ friendId, displayName, channel, key, lastActivityMs: mtimeMs });
-            }
-        }
-    }
+    const query = {
+        sessionsDir,
+        friendsDir,
+        agentName,
+        activeThresholdMs,
+        currentSession: currentFriendId && currentChannel && currentKey
+            ? { friendId: currentFriendId, channel: currentChannel, key: currentKey }
+            : null,
+    };
+    const entries = (0, session_activity_1.listSessionActivity)(query);
     if (entries.length === 0)
         return "";
-    // Sort by most recent first
-    entries.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
     const lines = ["## active sessions"];
     for (const entry of entries) {
         const ago = formatTimeAgo(now - entry.lastActivityMs);
-        lines.push(`- ${entry.displayName}/${entry.channel}/${entry.key} (last: ${ago})`);
+        lines.push(`- ${entry.friendName}/${entry.channel}/${entry.key} (last: ${ago})`);
     }
     return lines.join("\n");
 }
@@ -413,11 +360,29 @@ function memoryFriendToolContractSection() {
 - My task board is always loaded - I already know my work.`;
 }
 function bridgeContextSection(options) {
+    if (options?.activeWorkFrame)
+        return "";
     const bridgeContext = options?.bridgeContext?.trim() ?? "";
     if (!bridgeContext)
         return "";
     return bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
 }
+function activeWorkSection(options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame);
+}
+function delegationHintSection(options) {
+    if (!options?.delegationDecision)
+        return "";
+    const lines = [
+        "## delegation hint",
+        `target: ${options.delegationDecision.target}`,
+        `reasons: ${options.delegationDecision.reasons.length > 0 ? options.delegationDecision.reasons.join(", ") : "none"}`,
+        `outward closure: ${options.delegationDecision.outwardClosureRequired ? "required" : "not required"}`,
+    ];
+    return lines.join("\n");
+}
 function toolBehaviorSection(options) {
     if (!(options?.toolChoiceRequired ?? true))
         return "";
@@ -549,6 +514,8 @@ async function buildSystem(channel = "cli", options, context) {
         mixedTrustGroupSection(context),
         skillsSection(),
         taskBoardSection(),
+        activeWorkSection(options),
+        delegationHintSection(options),
         bridgeContextSection(options),
         buildSessionSummary({
             sessionsDir: path.join((0, identity_1.getAgentRoot)(), "state", "sessions"),

package/dist/repertoire/tools-base.js

@@ -49,6 +49,7 @@ const session_recall_1 = require("../heart/session-recall");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
 const pending_1 = require("../mind/pending");
+const progress_story_1 = require("../heart/progress-story");
 // Tracks which file paths have been read via read_file in this session.
 // edit_file requires a file to be read first (must-read-first guard).
 exports.editFileReadTracker = new Set();
@@ -65,14 +66,79 @@ function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
 }
 const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
 const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
+function findDelegatingBridgeId(ctx) {
+    const currentSession = ctx?.currentSession;
+    if (!currentSession)
+        return undefined;
+    return ctx?.activeBridges?.find((bridge) => bridge.lifecycle === "active"
+        && bridge.attachedSessions.some((session) => session.friendId === currentSession.friendId
+            && session.channel === currentSession.channel
+            && session.key === currentSession.key))?.id;
+}
 async function recallSessionSafely(options) {
     try {
         return await (0, session_recall_1.recallSession)(options);
     }
-    catch {
+    catch (error) {
+        if (options.summarize) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_recall_summary_fallback",
+                message: "session recall summarization failed; using raw transcript",
+                meta: {
+                    friendId: options.friendId,
+                    channel: options.channel,
+                    key: options.key,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            try {
+                return await (0, session_recall_1.recallSession)({
+                    ...options,
+                    summarize: undefined,
+                });
+            }
+            catch {
+                return { kind: "missing" };
+            }
+        }
         return { kind: "missing" };
     }
 }
+function normalizeProgressOutcome(text) {
+    const trimmed = text.trim();
+    if (!trimmed || trimmed === "nothing yet" || trimmed === "nothing recent") {
+        return null;
+    }
+    if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function renderInnerProgressStatus(status) {
+    if (status.processing === "pending") {
+        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+            scope: "inner-delegation",
+            phase: "queued",
+            objective: status.queue,
+            outcomeText: `wake: ${status.wake}`,
+        }));
+    }
+    if (status.processing === "started") {
+        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+            scope: "inner-delegation",
+            phase: "processing",
+            outcomeText: `wake: ${status.wake}`,
+        }));
+    }
+    const completedOutcome = normalizeProgressOutcome(status.surfaced) ?? status.surfaced;
+    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+        scope: "inner-delegation",
+        phase: "completed",
+        objective: null,
+        outcomeText: completedOutcome,
+    }));
+}
 exports.baseToolDefinitions = [
     {
         tool: {
@@ -725,7 +791,7 @@ exports.baseToolDefinitions = [
                 }
                 const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
                 const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
-                return (0, thoughts_1.formatInnerDialogStatus)((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
+                return renderInnerProgressStatus((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
             }
             const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
             const recall = await recallSessionSafely({
@@ -780,6 +846,17 @@ exports.baseToolDefinitions = [
             fs.mkdirSync(pendingDir, { recursive: true });
             const fileName = `${now}-${Math.random().toString(36).slice(2, 10)}.json`;
             const filePath = path.join(pendingDir, fileName);
+            const delegatingBridgeId = findDelegatingBridgeId(ctx);
+            const delegatedFrom = isSelf
+                && ctx?.currentSession
+                && !(ctx.currentSession.friendId === "self" && ctx.currentSession.channel === "inner")
+                ? {
+                    friendId: ctx.currentSession.friendId,
+                    channel: ctx.currentSession.channel,
+                    key: ctx.currentSession.key,
+                    ...(delegatingBridgeId ? { bridgeId: delegatingBridgeId } : {}),
+                }
+                : undefined;
             const envelope = {
                 from: agentName,
                 friendId,
@@ -787,6 +864,7 @@ exports.baseToolDefinitions = [
                 key,
                 content,
                 timestamp: now,
+                ...(delegatedFrom ? { delegatedFrom } : {}),
             };
             fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
             if (isSelf) {
@@ -803,7 +881,7 @@ exports.baseToolDefinitions = [
                         queueMicrotask(() => {
                             void runInnerDialogTurn({ reason: "instinct" });
                         });
-                        return (0, thoughts_1.formatInnerDialogStatus)({
+                        return renderInnerProgressStatus({
                             queue: "queued to inner/dialog",
                             wake: "inline scheduled",
                             processing: "pending",
@@ -812,15 +890,16 @@ exports.baseToolDefinitions = [
                     }
                     else {
                         const turnResult = await runInnerDialogTurn({ reason: "instinct" });
-                        return (0, thoughts_1.formatInnerDialogStatus)({
-                            queue: "queued to inner/dialog",
-                            wake: "inline fallback",
-                            processing: "processed",
-                            surfaced: (0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])),
-                        });
+                        const surfacedPreview = normalizeProgressOutcome((0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])));
+                        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                            scope: "inner-delegation",
+                            phase: "completed",
+                            objective: "queued to inner/dialog",
+                            outcomeText: `wake: inline fallback\n${surfacedPreview}`,
+                        }));
                     }
                 }
-                return (0, thoughts_1.formatInnerDialogStatus)({
+                return renderInnerProgressStatus({
                     queue: "queued to inner/dialog",
                     wake: "daemon requested",
                     processing: "pending",

package/dist/senses/bluebubbles.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
+exports.sendProactiveBlueBubblesMessageToSession = sendProactiveBlueBubblesMessageToSession;
 exports.drainAndSendPendingBlueBubbles = drainAndSendPendingBlueBubbles;
 exports.startBlueBubblesApp = startBlueBubblesApp;
 const fs = __importStar(require("node:fs"));
@@ -620,6 +621,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 hasExistingGroupWithFamily,
                 enforceTrustGate: trust_gate_1.enforceTrustGate,
                 drainPending: pending_1.drainPending,
+                drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
                 runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
                     ...opts,
                     toolContext: {
@@ -840,6 +842,114 @@ function findImessageHandle(friend) {
     }
     return undefined;
 }
+function extractChatIdentifierFromSessionKey(sessionKey) {
+    if (sessionKey.startsWith("chat:")) {
+        const chatGuid = sessionKey.slice("chat:".length).trim();
+        const parts = chatGuid.split(";");
+        return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
+    }
+    if (sessionKey.startsWith("chat_identifier:")) {
+        const identifier = sessionKey.slice("chat_identifier:".length).trim();
+        return identifier || undefined;
+    }
+    return undefined;
+}
+function buildChatRefForSessionKey(friend, sessionKey) {
+    if (sessionKey.startsWith("chat:")) {
+        const chatGuid = sessionKey.slice("chat:".length).trim();
+        if (!chatGuid)
+            return null;
+        return {
+            chatGuid,
+            chatIdentifier: extractChatIdentifierFromSessionKey(sessionKey) ?? findImessageHandle(friend),
+            isGroup: chatGuid.includes(";+;"),
+            sessionKey,
+            sendTarget: { kind: "chat_guid", value: chatGuid },
+            participantHandles: [],
+        };
+    }
+    const chatIdentifier = extractChatIdentifierFromSessionKey(sessionKey) ?? findImessageHandle(friend);
+    if (!chatIdentifier)
+        return null;
+    return {
+        chatIdentifier,
+        isGroup: false,
+        sessionKey,
+        sendTarget: { kind: "chat_identifier", value: chatIdentifier },
+        participantHandles: [],
+    };
+}
+async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const client = resolvedDeps.createClient();
+    const store = resolvedDeps.createFriendStore();
+    let friend;
+    try {
+        friend = await store.get(params.friendId);
+    }
+    catch {
+        friend = null;
+    }
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_no_friend",
+            message: "proactive send skipped: friend not found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "friend_not_found" };
+    }
+    if (!types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_trust_skip",
+            message: "proactive send skipped: trust level not allowed",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey, trustLevel: friend.trustLevel ?? "unknown" },
+        });
+        return { delivered: false, reason: "trust_skip" };
+    }
+    const chat = buildChatRefForSessionKey(friend, params.sessionKey);
+    if (!chat) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_no_handle",
+            message: "proactive send skipped: no iMessage handle found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "missing_target" };
+    }
+    try {
+        await client.sendText({ chat, text: params.text });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_sent",
+            message: "proactive bluebubbles message sent",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                chatGuid: chat.chatGuid ?? null,
+                chatIdentifier: chat.chatIdentifier ?? null,
+            },
+        });
+        return { delivered: true };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_send_error",
+            message: "proactive bluebubbles send failed",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return { delivered: false, reason: "send_error" };
+    }
+}
 function scanPendingBlueBubblesFiles(pendingRoot) {
     const results = [];
     let friendIds;

package/dist/senses/cli.js

@@ -740,11 +740,12 @@ async function main(agentName, options) {
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
     // Per-turn pipeline input: CLI capabilities and pending dir
     const cliCapabilities = (0, channel_1.getChannelCapabilities)("cli");
-    const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "cli", "session");
+    const currentAgentName = (0, identity_1.getAgentName)();
+    const pendingDir = (0, pending_1.getPendingDir)(currentAgentName, friendId, "cli", "session");
     const summarize = (0, core_1.createSummarize)();
     try {
         await runCliSession({
-            agentName: (0, identity_1.getAgentName)(),
+            agentName: currentAgentName,
             pasteDebounceMs,
             messages: sessionMessages,
             runTurn: async (messages, userInput, callbacks, signal) => {
@@ -765,6 +766,7 @@ async function main(agentName, options) {
                     externalId: localExternalId,
                     enforceTrustGate: trust_gate_1.enforceTrustGate,
                     drainPending: pending_1.drainPending,
+                    drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(currentAgentName, deferredFriendId),
                     runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
                         ...opts,
                         toolContext: {

package/dist/senses/debug-activity.js

@@ -4,6 +4,7 @@ exports.createDebugActivityController = createDebugActivityController;
 const format_1 = require("../mind/format");
 const phrases_1 = require("../mind/phrases");
 const runtime_1 = require("../nerves/runtime");
+const progress_story_1 = require("../heart/progress-story");
 function createDebugActivityController(options) {
     let queue = Promise.resolve();
     let statusMessageGuid;
@@ -81,19 +82,31 @@ function createDebugActivityController(options) {
                 nextPhrase(pool);
                 return;
             }
-            setStatus(`${nextPhrase(pool)}...`);
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `${nextPhrase(pool)}...`,
+            })));
         },
         onToolStart(name, args) {
             hadToolRun = true;
             followupShown = false;
             const argSummary = Object.values(args).join(", ");
             const detail = argSummary ? ` (${argSummary})` : "";
-            setStatus(`running ${name}${detail}...`);
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `running ${name}${detail}...`,
+            })));
         },
         onToolEnd(name, summary, success) {
             hadToolRun = true;
             followupShown = false;
-            setStatus((0, format_1.formatToolResult)(name, summary, success));
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: (0, format_1.formatToolResult)(name, summary, success),
+            })));
         },
         onTextChunk(text) {
             if (!text || !hadToolRun || followupShown) {
@@ -103,10 +116,18 @@ function createDebugActivityController(options) {
             if (options.suppressFollowupPhraseStatus) {
                 return;
             }
-            setStatus(`${nextPhrase(options.followupPhrases)}...`);
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `${nextPhrase(options.followupPhrases)}...`,
+            })));
         },
         onError(error) {
-            setStatus((0, format_1.formatError)(error));
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "errored",
+                outcomeText: (0, format_1.formatError)(error),
+            })));
             this.finish();
         },
         async drain() {