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

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.50",
+      "changes": [
+        "Delegated inner work can now proactively surface its completion back into the active BlueBubbles session instead of waiting for a later inbox drain.",
+        "Session recall now falls back to the raw transcript when summarization fails, so bridge attachment and cross-session inspection stay truthful instead of claiming the session is missing."
+      ]
+    },
     {
       "version": "0.1.0-alpha.49",
       "changes": [

package/dist/heart/active-work.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
+exports.buildActiveWorkFrame = buildActiveWorkFrame;
+exports.formatActiveWorkFrame = formatActiveWorkFrame;
+const runtime_1 = require("../nerves/runtime");
+const state_machine_1 = require("./bridges/state-machine");
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function compareActivity(a, b) {
+    const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+    if (sourceDiff !== 0)
+        return sourceDiff;
+    return b.lastActivityMs - a.lastActivityMs;
+}
+function summarizeLiveTasks(taskBoard) {
+    const live = [
+        ...taskBoard.byStatus.processing,
+        ...taskBoard.byStatus.validating,
+        ...taskBoard.byStatus.collaborating,
+    ];
+    return [...new Set(live)];
+}
+function isActiveBridge(bridge) {
+    return bridge.lifecycle === "active";
+}
+function hasSharedObligationPressure(input) {
+    return (typeof input.currentObligation === "string"
+        && input.currentObligation.trim().length > 0) || input.mustResolveBeforeHandoff
+        || summarizeLiveTasks(input.taskBoard).length > 0;
+}
+function suggestBridgeForActiveWork(input) {
+    const candidateSessions = input.friendSessions
+        .filter((session) => !input.currentSession
+        || session.friendId !== input.currentSession.friendId
+        || session.channel !== input.currentSession.channel
+        || session.key !== input.currentSession.key)
+        .sort(compareActivity);
+    const targetSession = candidateSessions[0] ?? null;
+    if (!targetSession || !hasSharedObligationPressure(input)) {
+        return null;
+    }
+    const activeBridge = input.bridges.find(isActiveBridge) ?? null;
+    if (activeBridge) {
+        const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
+            && session.channel === targetSession.channel
+            && session.key === targetSession.key);
+        if (alreadyAttached) {
+            return null;
+        }
+        return {
+            kind: "attach-existing",
+            bridgeId: activeBridge.id,
+            targetSession,
+            reason: "same-friend-shared-work",
+        };
+    }
+    return {
+        kind: "begin-new",
+        targetSession,
+        objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
+        reason: "same-friend-shared-work",
+    };
+}
+function formatSessionLabel(session) {
+    return `${session.channel}/${session.key}`;
+}
+function buildActiveWorkFrame(input) {
+    const friendSessions = input.currentSession
+        ? input.friendActivity
+            .filter((entry) => entry.friendId === input.currentSession?.friendId)
+            .sort(compareActivity)
+        : [];
+    const liveTaskNames = summarizeLiveTasks(input.taskBoard);
+    const activeBridgePresent = input.bridges.some(isActiveBridge);
+    const centerOfGravity = activeBridgePresent
+        ? "shared-work"
+        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff)
+            ? "inward-work"
+            : "local-turn";
+    const frame = {
+        currentSession: input.currentSession ?? null,
+        currentObligation: input.currentObligation?.trim() || null,
+        mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+        centerOfGravity,
+        inner: input.inner,
+        bridges: input.bridges,
+        taskPressure: {
+            compactBoard: input.taskBoard.compact,
+            liveTaskNames,
+            activeBridges: input.taskBoard.activeBridges,
+        },
+        friendActivity: {
+            freshestForCurrentFriend: friendSessions[0] ?? null,
+            otherLiveSessionsForCurrentFriend: friendSessions,
+        },
+        bridgeSuggestion: suggestBridgeForActiveWork({
+            currentSession: input.currentSession,
+            currentObligation: input.currentObligation,
+            mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+            bridges: input.bridges,
+            taskBoard: input.taskBoard,
+            friendSessions,
+        }),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.active_work_build",
+        message: "built shared active-work frame",
+        meta: {
+            centerOfGravity: frame.centerOfGravity,
+            friendId: frame.currentSession?.friendId ?? null,
+            bridges: frame.bridges.length,
+            liveTasks: frame.taskPressure.liveTaskNames.length,
+            liveSessions: frame.friendActivity.otherLiveSessionsForCurrentFriend.length,
+            hasBridgeSuggestion: frame.bridgeSuggestion !== null,
+        },
+    });
+    return frame;
+}
+function formatActiveWorkFrame(frame) {
+    const lines = ["## active work"];
+    if (frame.currentSession) {
+        lines.push(`current session: ${formatSessionLabel(frame.currentSession)}`);
+    }
+    lines.push(`center: ${frame.centerOfGravity}`);
+    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
+        lines.push(`obligation: ${frame.currentObligation.trim()}`);
+    }
+    if (frame.mustResolveBeforeHandoff) {
+        lines.push("handoff pressure: must resolve before handoff");
+    }
+    const innerStatus = frame.inner?.status ?? "idle";
+    const innerHasPending = frame.inner?.hasPending === true;
+    lines.push(`inner status: ${innerStatus}${innerHasPending ? " (pending queued)" : ""}`);
+    if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
+        lines.push(`live tasks: ${frame.taskPressure.liveTaskNames.join(", ")}`);
+    }
+    if ((frame.bridges ?? []).length > 0) {
+        const bridgeLabels = frame.bridges.map((bridge) => `${bridge.id} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]`);
+        lines.push(`bridges: ${bridgeLabels.join(", ")}`);
+    }
+    if (frame.friendActivity?.freshestForCurrentFriend) {
+        lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
+    }
+    if (frame.bridgeSuggestion) {
+        if (frame.bridgeSuggestion.kind === "attach-existing") {
+            lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+        }
+        else {
+            lines.push(`suggested bridge: begin -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+            lines.push(`bridge objective hint: ${frame.bridgeSuggestion.objectiveHint}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/heart/bridges/manager.js

@@ -74,6 +74,26 @@ function ensureRunnable(bridge, now, store) {
     }
     return bridge;
 }
+function sessionMatches(left, right) {
+    return left.friendId === right.friendId && left.channel === right.channel && left.key === right.key;
+}
+function hasAttachedSessionActivity(bridge, sessionActivity) {
+    return sessionActivity.some((activity) => activity.channel !== "inner"
+        && bridge.attachedSessions.some((session) => sessionMatches(activity, session)));
+}
+function hasLiveTaskStatus(bridge, taskBoard) {
+    const taskName = bridge.task?.taskName;
+    if (!taskName)
+        return false;
+    return (taskBoard.byStatus.processing.includes(taskName)
+        || taskBoard.byStatus.collaborating.includes(taskName)
+        || taskBoard.byStatus.validating.includes(taskName));
+}
+function isCurrentSessionAttached(bridge, currentSession) {
+    if (!currentSession)
+        return false;
+    return bridge.attachedSessions.some((session) => sessionMatches(session, currentSession));
+}
 function createBridgeManager(options = {}) {
     const store = options.store ?? (0, store_1.createBridgeStore)();
     const now = options.now ?? (() => new Date().toISOString());
@@ -165,6 +185,23 @@ function createBridgeManager(options = {}) {
             return store.findBySession(session)
                 .filter((bridge) => bridge.lifecycle !== "completed" && bridge.lifecycle !== "cancelled");
         },
+        reconcileLifecycles(input) {
+            return store.list().map((bridge) => {
+                const nextState = (0, state_machine_1.reconcileBridgeState)(bridge, {
+                    hasAttachedSessionActivity: hasAttachedSessionActivity(bridge, input.sessionActivity),
+                    hasLiveTask: hasLiveTaskStatus(bridge, input.taskBoard),
+                    currentSessionAttached: isCurrentSessionAttached(bridge, input.currentSession),
+                });
+                if (nextState.lifecycle === bridge.lifecycle && nextState.runtime === bridge.runtime) {
+                    return bridge;
+                }
+                return save({
+                    ...bridge,
+                    ...nextState,
+                    updatedAt: now(),
+                });
+            });
+        },
         promoteBridgeToTask(bridgeId, input = {}) {
             const bridge = requireBridge(bridgeId);
             assertBridgeMutable(bridge, "promote");

package/dist/heart/bridges/state-machine.js

@@ -9,6 +9,7 @@ exports.advanceBridgeAfterTurn = advanceBridgeAfterTurn;
 exports.suspendBridge = suspendBridge;
 exports.completeBridge = completeBridge;
 exports.cancelBridge = cancelBridge;
+exports.reconcileBridgeState = reconcileBridgeState;
 const runtime_1 = require("../../nerves/runtime");
 function transition(state, next, action) {
     (0, runtime_1.emitNervesEvent)({
@@ -113,3 +114,22 @@ function cancelBridge(state) {
     }
     return transition(state, { lifecycle: "cancelled", runtime: "idle" }, "cancel");
 }
+function reconcileBridgeState(state, input) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        return state;
+    }
+    if (state.runtime !== "idle") {
+        return state;
+    }
+    const hasLiveSignal = input.hasAttachedSessionActivity || input.hasLiveTask || input.currentSessionAttached;
+    if (state.lifecycle === "suspended") {
+        return hasLiveSignal ? activateBridge(state) : state;
+    }
+    if (state.lifecycle === "forming") {
+        return hasLiveSignal ? activateBridge(state) : suspendBridge(state);
+    }
+    if (state.lifecycle === "active") {
+        return hasLiveSignal ? state : suspendBridge(state);
+    }
+    return state;
+}

package/dist/heart/core.js

@@ -359,6 +359,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let overflowRetried = false;
     let retryCount = 0;
     let outcome = "complete";
+    let completion;
     let sawSteeringFollowUp = false;
     let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
@@ -453,6 +454,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     const validClosure = answer != null
                         && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
                     if (validClosure) {
+                        completion = {
+                            answer,
+                            intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
+                        };
                         if (result.finalAnswerStreamed) {
                             // The streaming layer already parsed and emitted the answer
                             // progressively via FinalAnswerParser. Skip clearing and
@@ -610,5 +615,5 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         message: "runAgent turn completed",
         meta: { done },
     });
-    return { usage: lastUsage, outcome };
+    return { usage: lastUsage, outcome, completion };
 }

package/dist/heart/daemon/daemon-cli.js

@@ -65,6 +65,7 @@ const thoughts_1 = require("./thoughts");
 const ouro_bot_global_installer_1 = require("./ouro-bot-global-installer");
 const launchd_1 = require("./launchd");
 const socket_client_1 = require("./socket-client");
+const session_activity_1 = require("../session-activity");
 function stringField(value) {
     return typeof value === "string" ? value : null;
 }
@@ -1026,6 +1027,20 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
             const { main } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
             await main(agentName);
         },
+        scanSessions: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            return (0, session_activity_1.listSessionActivity)({
+                sessionsDir: path.join(agentRoot, "state", "sessions"),
+                friendsDir: path.join(agentRoot, "friends"),
+                agentName,
+            }).map((entry) => ({
+                friendId: entry.friendId,
+                friendName: entry.friendName,
+                channel: entry.channel,
+                lastActivity: entry.lastActivityAt,
+            }));
+        },
     };
 }
 function toDaemonCommand(command) {

package/dist/heart/delegation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideDelegation = decideDelegation;
+const runtime_1 = require("../nerves/runtime");
+const CROSS_SESSION_TOOLS = new Set(["query_session", "send_message", "bridge_manage"]);
+const FAST_PATH_TOOLS = new Set(["final_answer"]);
+const REFLECTION_PATTERN = /\b(think|reflect|ponder|surface|surfaces|surfaced|sit with|metaboli[sz]e)\b/i;
+const CROSS_SESSION_PATTERN = /\b(other chat|other session|across chats?|across sessions?|keep .* aligned|relay|carry .* across)\b/i;
+function hasExplicitReflection(ingressTexts) {
+    return ingressTexts.some((text) => REFLECTION_PATTERN.test(text));
+}
+function hasCrossSessionPressure(ingressTexts, requestedToolNames) {
+    if (requestedToolNames.some((name) => CROSS_SESSION_TOOLS.has(name))) {
+        return true;
+    }
+    return ingressTexts.some((text) => CROSS_SESSION_PATTERN.test(text));
+}
+function hasNonFastPathToolRequest(requestedToolNames) {
+    return requestedToolNames.some((name) => !FAST_PATH_TOOLS.has(name));
+}
+function decideDelegation(input) {
+    const requestedToolNames = (input.requestedToolNames ?? [])
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+    const reasons = [];
+    if (hasExplicitReflection(input.ingressTexts)) {
+        reasons.push("explicit_reflection");
+    }
+    if (hasCrossSessionPressure(input.ingressTexts, requestedToolNames)) {
+        reasons.push("cross_session");
+    }
+    if (input.activeWork.centerOfGravity === "shared-work" || input.activeWork.bridges.some((bridge) => bridge.lifecycle === "active")) {
+        reasons.push("bridge_state");
+    }
+    if (input.activeWork.taskPressure.liveTaskNames.length > 0) {
+        reasons.push("task_state");
+    }
+    if (hasNonFastPathToolRequest(requestedToolNames)) {
+        reasons.push("non_fast_path_tool");
+    }
+    if (input.mustResolveBeforeHandoff || input.activeWork.mustResolveBeforeHandoff) {
+        reasons.push("unresolved_obligation");
+    }
+    const target = reasons.length === 0 ? "fast-path" : "delegate-inward";
+    const decision = {
+        target,
+        reasons,
+        outwardClosureRequired: target === "delegate-inward" && input.channel !== "inner",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.delegation_decide",
+        message: "computed delegation hint",
+        meta: {
+            channel: input.channel,
+            target: decision.target,
+            reasons: decision.reasons,
+            outwardClosureRequired: decision.outwardClosureRequired,
+        },
+    });
+    return decision;
+}

package/dist/heart/progress-story.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProgressStory = buildProgressStory;
+exports.renderProgressStory = renderProgressStory;
+const runtime_1 = require("../nerves/runtime");
+function labelForScope(scope) {
+    return scope === "inner-delegation" ? "inner work" : "shared work";
+}
+function compactDetail(text) {
+    if (typeof text !== "string")
+        return null;
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildProgressStory(input) {
+    const detailLines = [
+        compactDetail(input.objective),
+        compactDetail(input.outcomeText),
+        compactDetail(input.bridgeId ? `bridge: ${input.bridgeId}` : null),
+        compactDetail(input.taskName ? `task: ${input.taskName}` : null),
+    ].filter((line) => Boolean(line));
+    const story = {
+        statusLine: `${labelForScope(input.scope)}: ${input.phase}`,
+        detailLines,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.progress_story_build",
+        message: "built shared progress story",
+        meta: {
+            scope: input.scope,
+            phase: input.phase,
+            detailLines: detailLines.length,
+            hasBridge: Boolean(input.bridgeId),
+            hasTask: Boolean(input.taskName),
+        },
+    });
+    return story;
+}
+function renderProgressStory(story) {
+    return [story.statusLine, ...story.detailLines].join("\n");
+}

package/dist/heart/session-activity.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSessionActivity = listSessionActivity;
+exports.findFreshestFriendSession = findFreshestFriendSession;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function parseFriendActivity(sessionPath) {
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(sessionPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const explicit = parsed?.state?.lastFriendActivityAt;
+        if (typeof explicit === "string") {
+            const parsedMs = Date.parse(explicit);
+            if (Number.isFinite(parsedMs)) {
+                return {
+                    lastActivityMs: parsedMs,
+                    lastActivityAt: new Date(parsedMs).toISOString(),
+                    activitySource: "friend-facing",
+                };
+            }
+        }
+    }
+    catch {
+        // fall back to file mtime below
+    }
+    return {
+        lastActivityMs: mtimeMs,
+        lastActivityAt: new Date(mtimeMs).toISOString(),
+        activitySource: "mtime-fallback",
+    };
+}
+function listSessionActivity(query) {
+    const { sessionsDir, friendsDir, agentName, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, currentSession = null, } = query;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_activity_scan",
+        message: "scanning session activity",
+        meta: {
+            sessionsDir,
+            currentSession: currentSession ? `${currentSession.friendId}/${currentSession.channel}/${currentSession.key}` : null,
+        },
+    });
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const now = Date.now();
+    const results = [];
+    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$/, "");
+                if (currentSession && friendId === currentSession.friendId && channel === currentSession.channel && key === currentSession.key) {
+                    continue;
+                }
+                const sessionPath = path.join(channelPath, keyFile);
+                const activity = parseFriendActivity(sessionPath);
+                if (!activity)
+                    continue;
+                if (now - activity.lastActivityMs > activeThresholdMs)
+                    continue;
+                results.push({
+                    friendId,
+                    friendName: resolveFriendName(friendId, friendsDir, agentName),
+                    channel,
+                    key,
+                    sessionPath,
+                    lastActivityAt: activity.lastActivityAt,
+                    lastActivityMs: activity.lastActivityMs,
+                    activitySource: activity.activitySource,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => {
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function findFreshestFriendSession(query) {
+    const { activeOnly = false, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, ...rest } = query;
+    const currentSession = rest.currentSession ?? null;
+    const all = activeOnly
+        ? listSessionActivity({ ...rest, activeThresholdMs, currentSession })
+        : listSessionActivity({ ...rest, activeThresholdMs: Number.MAX_SAFE_INTEGER, currentSession });
+    return all.find((entry) => entry.friendId === query.friendId) ?? null;
+}

package/dist/mind/context.js

@@ -243,8 +243,11 @@ function saveSession(filePath, messages, lastUsage, state) {
     const envelope = { version: 1, messages };
     if (lastUsage)
         envelope.lastUsage = lastUsage;
-    if (state?.mustResolveBeforeHandoff === true) {
-        envelope.state = { mustResolveBeforeHandoff: true };
+    if (state?.mustResolveBeforeHandoff === true || typeof state?.lastFriendActivityAt === "string") {
+        envelope.state = {
+            ...(state?.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+            ...(typeof state?.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+        };
     }
     fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
@@ -266,10 +269,15 @@ function loadSession(filePath) {
             });
             messages = repairSessionMessages(messages);
         }
-        const state = data?.state && typeof data.state === "object" && data.state !== null
-            && typeof data.state.mustResolveBeforeHandoff === "boolean"
-            && data.state.mustResolveBeforeHandoff === true
-            ? { mustResolveBeforeHandoff: true }
+        const rawState = data?.state && typeof data.state === "object" && data.state !== null
+            ? data.state
+            : undefined;
+        const state = rawState && (rawState.mustResolveBeforeHandoff === true
+            || typeof rawState.lastFriendActivityAt === "string")
+            ? {
+                ...(rawState.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+                ...(typeof rawState.lastFriendActivityAt === "string" ? { lastFriendActivityAt: rawState.lastFriendActivityAt } : {}),
+            }
             : undefined;
         return { messages, lastUsage: data.lastUsage, state };
     }