@bbigbang/core 0.1.0

package/dist/web/agentRuntimePresence.js

@@ -0,0 +1,197 @@
+function toIso(timestamp) {
+    return typeof timestamp === 'number' && Number.isFinite(timestamp) && timestamp > 0
+        ? new Date(timestamp).toISOString()
+        : null;
+}
+function parseSurfaceKind(value) {
+    if (value === 'dm')
+        return 'dm';
+    if (value === 'dm_thread')
+        return 'dm_thread';
+    if (value === 'channel' || value === 'channel_root')
+        return 'channel';
+    if (value === 'channel_thread' || value === 'task_thread')
+        return 'channel_thread';
+    return null;
+}
+function compareHosts(a, b) {
+    const rank = (state) => {
+        switch (state) {
+            case 'active': return 0;
+            case 'idle': return 1;
+            case 'failed': return 2;
+            default: return 3;
+        }
+    };
+    const rankDelta = rank(a.state) - rank(b.state);
+    if (rankDelta !== 0)
+        return rankDelta;
+    return a.hostKey.localeCompare(b.hostKey);
+}
+export function collectAgentRuntimePresence(db, manager, agent, options) {
+    const machine = agent.nodeId ? manager.getMachine(agent.nodeId) : null;
+    const currentHostBinding = options?.conversationId ? manager.getConversationHostKey(options.conversationId) : null;
+    const hostBindings = manager.getAgentHostKeys(agent.agentId);
+    const bindingsOnNode = agent.nodeId
+        ? hostBindings.filter((binding) => binding.nodeId === agent.nodeId)
+        : [];
+    const conversationRows = agent.nodeId
+        ? db.prepare(`SELECT id as conversationId,
+                reply_target as replyTarget,
+                surface_kind as surfaceKind,
+                agent_type as agentType
+           FROM conversations
+          WHERE agent_id = ? AND node_id = ?`).all(agent.agentId, agent.nodeId)
+        : [];
+    const conversationByHostKey = new Map();
+    for (const row of conversationRows) {
+        conversationByHostKey.set(`conversation:${row.conversationId}:${row.agentType}`, {
+            replyTarget: row.replyTarget,
+            surfaceKind: parseSurfaceKind(row.surfaceKind),
+        });
+    }
+    const hostRows = bindingsOnNode.length > 0
+        ? db.prepare(`SELECT host_key as hostKey,
+                state,
+                current_run_id as currentRunId,
+                has_pending_approval as hasPendingApproval,
+                inbox_size as inboxSize,
+                pending_dispatch_count as pendingDispatchCount,
+                resumable,
+                last_wake_at as lastWakeAt,
+                last_sleep_at as lastSleepAt,
+                last_error as lastError
+           FROM node_host_snapshots
+          WHERE node_id = ? AND host_key IN (${bindingsOnNode.map(() => '?').join(', ')})`).all(agent.nodeId, ...bindingsOnNode.map((binding) => binding.hostKey))
+        : [];
+    const hosts = hostRows
+        .map((row) => {
+        const conversation = conversationByHostKey.get(row.hostKey);
+        const host = {
+            hostKey: row.hostKey,
+            replyTarget: conversation?.replyTarget ?? null,
+            surfaceKind: conversation?.surfaceKind ?? null,
+            state: row.state,
+            currentRunId: row.currentRunId,
+            hasPendingApproval: row.hasPendingApproval === 1,
+            inboxSize: row.inboxSize,
+            pendingDispatchCount: row.pendingDispatchCount,
+            resumable: row.resumable === 1,
+            lastWakeAt: toIso(row.lastWakeAt),
+            lastSleepAt: toIso(row.lastSleepAt),
+            lastError: row.lastError,
+        };
+        return host;
+    })
+        .sort(compareHosts);
+    const currentHostKey = currentHostBinding && currentHostBinding.nodeId === agent.nodeId
+        ? currentHostBinding.hostKey
+        : null;
+    const currentHost = currentHostKey ? hosts.find((host) => host.hostKey === currentHostKey) ?? null : null;
+    const otherHosts = hosts.filter((host) => host.hostKey !== currentHostKey).slice(0, 4);
+    const runtimeRow = agent.nodeId
+        ? db.prepare(`SELECT workspace_root as workspaceRoot,
+                terminal_backend_available as terminalBackendAvailable,
+                runtime_drivers_json as runtimeDriversJson,
+                capabilities_json as capabilitiesJson
+           FROM node_runtime_snapshots
+          WHERE node_id = ?`).get(agent.nodeId)
+        : undefined;
+    let runtimeDrivers = [];
+    if (runtimeRow?.runtimeDriversJson) {
+        try {
+            const parsed = JSON.parse(runtimeRow.runtimeDriversJson);
+            if (Array.isArray(parsed))
+                runtimeDrivers = parsed;
+        }
+        catch {
+            runtimeDrivers = [];
+        }
+    }
+    let capabilities = null;
+    if (runtimeRow?.capabilitiesJson) {
+        try {
+            const parsed = JSON.parse(runtimeRow.capabilitiesJson);
+            if (parsed && typeof parsed === 'object')
+                capabilities = parsed;
+        }
+        catch {
+            capabilities = null;
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        node: {
+            nodeId: agent.nodeId ?? null,
+            machineName: machine?.name ?? null,
+            hostname: machine?.hostname ?? null,
+            status: agent.nodeId ? (machine?.status ?? 'offline') : 'unassigned',
+            version: machine?.version ?? null,
+            lastSeen: toIso(machine?.lastSeen ?? null),
+        },
+        runtime: {
+            workspaceRoot: runtimeRow?.workspaceRoot ?? null,
+            terminalBackendAvailable: runtimeRow ? Boolean(runtimeRow.terminalBackendAvailable) : null,
+            runtimeDrivers,
+            capabilities,
+        },
+        summary: {
+            totalHosts: hosts.length,
+            activeHosts: hosts.filter((host) => host.state === 'active').length,
+            idleHosts: hosts.filter((host) => host.state === 'idle').length,
+            failedHosts: hosts.filter((host) => host.state === 'failed').length,
+            hostsWithPendingApproval: hosts.filter((host) => host.hasPendingApproval).length,
+            resumableHosts: hosts.filter((host) => host.resumable).length,
+        },
+        currentHost,
+        otherHosts,
+    };
+}
+export function buildAgentRuntimePresenceReport(presence) {
+    const driverNames = presence.runtime.runtimeDrivers.map((driver) => driver.agentType).join(', ') || 'none';
+    const capabilityParts = presence.runtime.capabilities
+        ? Object.entries(presence.runtime.capabilities)
+            .filter(([, enabled]) => Boolean(enabled))
+            .map(([name]) => name)
+        : [];
+    const lines = [
+        '[Runtime presence]',
+        `node: ${presence.node.nodeId ?? 'none'}${presence.node.machineName ? ` (${presence.node.machineName})` : ''} [${presence.node.status}]${presence.node.version ? ` version=${presence.node.version}` : ''}`,
+        `runtime: workspace_root=${presence.runtime.workspaceRoot ?? 'unknown'} | terminals=${presence.runtime.terminalBackendAvailable == null ? 'unknown' : (presence.runtime.terminalBackendAvailable ? 'yes' : 'no')} | drivers=${driverNames}`,
+        `hosts: total=${presence.summary.totalHosts}, active=${presence.summary.activeHosts}, idle=${presence.summary.idleHosts}, failed=${presence.summary.failedHosts}, approval=${presence.summary.hostsWithPendingApproval}, resumable=${presence.summary.resumableHosts}`,
+    ];
+    if (capabilityParts.length > 0) {
+        lines.push(`capabilities: ${capabilityParts.join(', ')}`);
+    }
+    if (presence.currentHost) {
+        const current = presence.currentHost;
+        const extras = [
+            `pending_dispatch=${current.pendingDispatchCount}`,
+            `inbox=${current.inboxSize}`,
+            `approval=${current.hasPendingApproval ? 'yes' : 'no'}`,
+            `resumable=${current.resumable ? 'yes' : 'no'}`,
+        ];
+        if (current.lastError)
+            extras.push(`last_error=${current.lastError}`);
+        lines.push(`current_host: ${(current.replyTarget ?? current.hostKey)} [${current.state}] | ${extras.join(' | ')}`);
+    }
+    else {
+        lines.push('current_host: none');
+    }
+    if (presence.otherHosts.length === 0) {
+        lines.push('other_hosts: none');
+    }
+    else {
+        lines.push('other_hosts:');
+        for (const host of presence.otherHosts) {
+            const extras = [
+                `pending_dispatch=${host.pendingDispatchCount}`,
+                `approval=${host.hasPendingApproval ? 'yes' : 'no'}`,
+            ];
+            if (host.lastError)
+                extras.push(`last_error=${host.lastError}`);
+            lines.push(`- ${(host.replyTarget ?? host.hostKey)} [${host.state}] | ${extras.join(' | ')}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/web/agentSelfState.js

@@ -0,0 +1,494 @@
+import { buildThreadShortId, } from '@bbigbang/protocol';
+import { formatConversationHandoff, listRecentConversationHandoffs } from './conversationHandoffs.js';
+import { AgentVisibility } from './agentVisibility.js';
+import { parseSurfaceKind } from './conversationSurfaceKinds.js';
+import { getAgentMessageCheckpoint } from './messageCheckpoints.js';
+import { TASK_LIFECYCLE_SOURCE } from './taskLifecycleMessages.js';
+import { buildTaskSourceTarget, buildTaskThreadTarget } from './taskStateViews.js';
+export function collectAgentSelfState(db, agent, options) {
+    const visibility = new AgentVisibility(db);
+    const joinedChannels = loadJoinedChannels(db, agent);
+    const conversationRows = db.prepare(`SELECT c.id as conversationId,
+            c.title,
+            c.status,
+            c.channel_id as channelId,
+            ch.name as channelName,
+            c.thread_kind as threadKind,
+            c.is_primary_thread as isPrimaryThread,
+            c.thread_root_id as threadRootId,
+            c.surface_kind as surfaceKind,
+            c.reply_target as replyTarget,
+            c.user_id as userId,
+            c.updated_at as updatedAt,
+            COALESCE(q.queueCount, 0) as queuedPromptCount,
+            ar.runId as activeRunId
+       FROM conversations c
+       LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+	       LEFT JOIN (
+	         SELECT conversation_id, COUNT(*) as queueCount
+	           FROM conversation_prompt_queue
+	          WHERE COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	          GROUP BY conversation_id
+	       ) q ON q.conversation_id = c.id
+       LEFT JOIN (
+         SELECT c2.id as conversationId, MIN(r.run_id) as runId
+           FROM conversations c2
+           JOIN runs r ON r.session_key = c2.session_key
+          WHERE r.ended_at IS NULL
+          GROUP BY c2.id
+       ) ar ON ar.conversationId = c.id
+      WHERE c.agent_id = ?
+      ORDER BY c.updated_at DESC, c.created_at DESC`).all(agent.agentId);
+    const visibleChannelIds = new Set(agent.channelIds ?? []);
+    const visibleTaskChannelIds = Array.from(new Set([`dm:${agent.agentId}`, ...visibleChannelIds]));
+    const visibleTaskChannelPlaceholders = visibleTaskChannelIds.map(() => '?').join(', ');
+    const conversations = conversationRows
+        .filter((row) => row.channelId.startsWith('dm:') || visibleChannelIds.has(row.channelId))
+        .map((row) => toConversationState(db, agent.agentId, row))
+        .sort(compareConversations(options?.conversationId ?? null));
+    const currentConversation = options?.conversationId
+        ? conversations.find((conversation) => conversation.conversationId === options.conversationId) ?? null
+        : null;
+    const taskLimit = Math.max(1, Math.min(options?.maxTasks ?? 6, 12));
+    const taskSummaryRow = db.prepare(`SELECT COUNT(DISTINCT t.task_id) as involvedTasks,
+            COUNT(DISTINCT CASE WHEN t.claimed_by_agent_id = ? THEN t.task_id END) as claimedTasks,
+            COUNT(DISTINCT CASE WHEN t.status = 'in_review' THEN t.task_id END) as inReviewTasks
+       FROM tasks t
+      LEFT JOIN task_participants tp
+              ON tp.task_id = t.task_id
+             AND tp.agent_id = ?
+      WHERE (
+              t.claimed_by_agent_id = ?
+          AND t.channel_id IN (${visibleTaskChannelPlaceholders})
+            )
+         OR (
+              tp.agent_id IS NOT NULL
+          AND t.channel_id IN (${visibleTaskChannelPlaceholders})
+            )`).get(agent.agentId, agent.agentId, agent.agentId, ...visibleTaskChannelIds, ...visibleTaskChannelIds);
+    const bufferedTaskLimit = Math.min(taskLimit * 2, 24);
+    const taskRows = db.prepare(`SELECT t.task_id as taskId,
+            t.agent_task_ref as agentTaskRef,
+            t.channel_id as channelId,
+            t.task_number as taskNumber,
+            t.title,
+            t.status,
+            t.updated_at as updatedAt,
+            t.message_id as messageId,
+            COALESCE(t.dm_target, cm.target) as sourceTarget,
+            ch.name as channelName,
+            CASE WHEN tp.agent_id IS NULL THEN 0 ELSE 1 END as participant,
+            t.claimed_by_agent_id as claimedByAgentId
+       FROM tasks t
+       LEFT JOIN task_participants tp
+              ON tp.task_id = t.task_id
+             AND tp.agent_id = ?
+       LEFT JOIN channel_messages cm
+              ON cm.message_id = t.message_id
+       LEFT JOIN channels ch
+              ON ch.channel_id = t.channel_id
+      WHERE (
+              t.claimed_by_agent_id = ?
+          AND t.channel_id IN (${visibleTaskChannelPlaceholders})
+            )
+         OR (
+              tp.agent_id IS NOT NULL
+          AND t.channel_id IN (${visibleTaskChannelPlaceholders})
+            )
+      ORDER BY t.updated_at DESC, t.created_at DESC
+      LIMIT ?`).all(agent.agentId, agent.agentId, ...visibleTaskChannelIds, ...visibleTaskChannelIds, bufferedTaskLimit);
+    const recentTasks = taskRows.slice(0, taskLimit).map((row) => ({
+        taskId: row.taskId,
+        agentTaskRef: row.agentTaskRef,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        status: row.status,
+        sourceTarget: buildTaskSourceTarget(row.channelId, row.sourceTarget, row.channelName),
+        threadTarget: buildTaskThreadTarget(buildTaskSourceTarget(row.channelId, row.sourceTarget, row.channelName), row.messageId),
+        claimedByMe: row.claimedByAgentId === agent.agentId,
+        participant: row.participant === 1,
+        updatedAt: new Date(row.updatedAt).toISOString(),
+    }));
+    const recentHandoffs = listRecentConversationHandoffs(db, agent.agentId, 5)
+        .filter((handoff) => visibility.canSeeHandoff(agent, {
+        handoffId: handoff.handoffId,
+        mode: handoff.mode,
+        status: handoff.status,
+        sourceConversationId: handoff.sourceConversationId,
+        targetConversationId: handoff.targetConversationId,
+        targetReplyTarget: handoff.targetReplyTarget,
+        sourceTarget: handoff.payload.sourceTarget,
+        goal: handoff.payload.goal,
+        error: handoff.payload.error,
+        updatedAt: handoff.updatedAt,
+    }))
+        .map((handoff) => ({
+        handoffId: handoff.handoffId,
+        mode: handoff.mode,
+        status: handoff.status,
+        sourceConversationId: handoff.sourceConversationId,
+        sourceTarget: handoff.payload.sourceTarget,
+        targetConversationId: handoff.targetConversationId,
+        targetReplyTarget: handoff.targetReplyTarget,
+        goal: handoff.payload.goal,
+        error: handoff.payload.error,
+        updatedAt: handoff.updatedAt,
+        summaryText: formatConversationHandoff(handoff),
+    }));
+    const summary = {
+        totalConversations: conversations.length,
+        activeConversations: conversations.filter((conversation) => conversation.status === 'active').length,
+        queuedConversations: conversations.filter((conversation) => conversation.status === 'queued').length,
+        recoveringConversations: conversations.filter((conversation) => conversation.status === 'recovering').length,
+        awaitingApprovalConversations: conversations.filter((conversation) => conversation.status === 'awaiting_approval').length,
+        failedConversations: conversations.filter((conversation) => conversation.status === 'failed').length,
+        totalUnreadMessages: conversations.reduce((sum, conversation) => sum + conversation.unreadCount, 0),
+        surfacesWithUnread: conversations.filter((conversation) => conversation.unreadCount > 0).length,
+        pendingPrompts: conversations.reduce((sum, conversation) => sum + conversation.queuedPromptCount, 0),
+        claimedTasks: Number(taskSummaryRow?.claimedTasks ?? 0),
+        involvedTasks: Number(taskSummaryRow?.involvedTasks ?? 0),
+        inReviewTasks: Number(taskSummaryRow?.inReviewTasks ?? 0),
+    };
+    return {
+        generatedAt: new Date().toISOString(),
+        agent: {
+            agentId: agent.agentId,
+            name: agent.name,
+            agentType: agent.agentType,
+            nodeId: agent.nodeId ?? null,
+            workspacePath: agent.workspacePath,
+            homeChannelId: agent.channelId,
+            joinedChannels,
+        },
+        summary,
+        currentConversation,
+        conversations,
+        recentTasks,
+        recentHandoffs,
+    };
+}
+export function buildAgentGlobalSnapshot(state) {
+    const current = state.currentConversation;
+    const currentSurface = current
+        ? `${current.replyTarget} [${current.surfaceKind}, status=${current.status}, unread=${current.unreadCount}, queued_prompts=${current.queuedPromptCount}]`
+        : 'unknown';
+    const otherLiveSurfaces = state.conversations
+        .filter((conversation) => !current || conversation.conversationId !== current.conversationId)
+        .filter((conversation) => conversation.status !== 'idle' || conversation.unreadCount > 0 || conversation.queuedPromptCount > 0)
+        .slice(0, 4);
+    const lines = [
+        '[Agent global snapshot]',
+        `agent: @${state.agent.name}`,
+        `current_surface: ${currentSurface}`,
+        `global: conversations=${state.summary.totalConversations}, active=${state.summary.activeConversations}, queued=${state.summary.queuedConversations}, awaiting_approval=${state.summary.awaitingApprovalConversations}, unread_messages=${state.summary.totalUnreadMessages} on ${state.summary.surfacesWithUnread} surfaces, pending_prompts=${state.summary.pendingPrompts}`,
+        `tasks: claimed=${state.summary.claimedTasks}, involved=${state.summary.involvedTasks}, in_review=${state.summary.inReviewTasks}`,
+    ];
+    if (otherLiveSurfaces.length > 0) {
+        lines.push('other_live_surfaces:');
+        for (const conversation of otherLiveSurfaces) {
+            lines.push(`- ${conversation.replyTarget} [${conversation.status}, unread=${conversation.unreadCount}, queued_prompts=${conversation.queuedPromptCount}]`);
+        }
+    }
+    else {
+        lines.push('other_live_surfaces: none');
+    }
+    if (state.recentHandoffs.length > 0) {
+        lines.push('recent_handoffs:');
+        for (const handoff of state.recentHandoffs.slice(0, 3)) {
+            lines.push(`- ${handoff.summaryText}`);
+        }
+    }
+    else {
+        lines.push('recent_handoffs: none');
+    }
+    return lines.join('\n');
+}
+export function buildAgentSelfStateReport(state, options) {
+    const current = state.currentConversation;
+    const joinedChannels = formatJoinedChannels(state.agent.joinedChannels.map((channel) => channel.target));
+    const currentSurface = current
+        ? formatSelfStateSurface(current)
+        : 'none';
+    const lines = [
+        '[Agent self state]',
+        `agent: @${state.agent.name} (${state.agent.agentType}) | current: ${currentSurface}`,
+        `joined_channels: ${joinedChannels.text}`,
+        `global: conv=${state.summary.totalConversations}, active=${state.summary.activeConversations}, queued=${state.summary.queuedConversations}, recovering=${state.summary.recoveringConversations}, approval=${state.summary.awaitingApprovalConversations}, failed=${state.summary.failedConversations}, new_activity=${state.summary.surfacesWithUnread}, pending=${state.summary.pendingPrompts} | tasks claimed=${state.summary.claimedTasks}, involved=${state.summary.involvedTasks}, review=${state.summary.inReviewTasks}`,
+    ];
+    if (options?.currentContext) {
+        if (options.currentContext.myRole)
+            lines.push(`role_here: ${options.currentContext.myRole}`);
+        if (options.currentContext.boundTask) {
+            lines.push(`bound_task: ${formatTaskIdentity(options.currentContext.boundTask.agentTaskRef, options.currentContext.boundTask.taskNumber)} [${options.currentContext.boundTask.status}]`);
+        }
+        if (options.currentContext.ownerName)
+            lines.push(`owner_here: @${options.currentContext.ownerName}`);
+        if (options.currentContext.participants.length > 0) {
+            lines.push(`participants_here: ${options.currentContext.participants.map((name) => `@${name}`).join(', ')}`);
+        }
+        if (options.currentContext.blockers.length > 0) {
+            lines.push(`blockers_here: ${truncateSelfStateValue(options.currentContext.blockers.join('; '), 96)}`);
+        }
+        if (options.currentContext.activeHandoff) {
+            lines.push(`active_handoff_here: ${options.currentContext.activeHandoff.handoffId} ${options.currentContext.activeHandoff.mode} [${options.currentContext.activeHandoff.status}] -> ${options.currentContext.activeHandoff.targetReplyTarget}`);
+        }
+    }
+    const currentConversationId = current?.conversationId ?? null;
+    const otherConversations = state.conversations
+        .filter((conversation) => conversation.conversationId !== currentConversationId);
+    const surfaces = otherConversations.slice(0, 4);
+    lines.push('other_surfaces:');
+    if (surfaces.length === 0) {
+        lines.push('- none');
+    }
+    else {
+        for (const conversation of surfaces) {
+            const context = options?.conversationContexts?.[conversation.conversationId];
+            const extras = [];
+            if (context?.myRole)
+                extras.push(`role=${context.myRole}`);
+            if (conversation.unreadCount > 0)
+                extras.push(`unread=${conversation.unreadCount}`);
+            if (context?.boundTask) {
+                extras.push(`task=${formatTaskIdentity(context.boundTask.agentTaskRef, context.boundTask.taskNumber)} [${context.boundTask.status}]`);
+            }
+            if (context?.blockers.length)
+                extras.push(`blockers=${truncateSelfStateValue(context.blockers.join('; '), 80)}`);
+            if (context?.activeHandoff) {
+                extras.push(`handoff=${context.activeHandoff.handoffId} ${context.activeHandoff.mode} [${context.activeHandoff.status}]`);
+            }
+            const teaser = buildSelfStateTeaser(context);
+            if (teaser)
+                extras.push(`teaser=${truncateSelfStateValue(teaser, 64)}`);
+            lines.push(`- ${formatSelfStateSurface(conversation)}${extras.length ? ` | ${extras.join(' | ')}` : ''}`);
+        }
+        const hiddenSurfaces = otherConversations.slice(surfaces.length);
+        const hiddenSurfaceCount = hiddenSurfaces.length;
+        if (hiddenSurfaceCount > 0) {
+            lines.push(`- hidden=${hiddenSurfaceCount}${formatHiddenSurfaceBreakdown(hiddenSurfaces)}`);
+        }
+    }
+    const currentBoundTaskId = options?.currentContext?.boundTask?.taskId ?? null;
+    const recentTasks = state.recentTasks
+        .filter((task) => task.taskId !== currentBoundTaskId)
+        .slice(0, 3);
+    const totalOtherTaskCount = Math.max(0, state.summary.involvedTasks - (currentBoundTaskId ? 1 : 0));
+    if (state.recentTasks.length === 0) {
+        lines.push('tasks: none');
+    }
+    else if (recentTasks.length > 0) {
+        lines.push('other_tasks:');
+        for (const task of recentTasks) {
+            const identity = formatTaskIdentity(task.agentTaskRef, task.taskNumber);
+            const source = task.threadTarget ?? task.sourceTarget ?? 'unknown';
+            const ownership = task.claimedByMe ? 'claimed' : (task.participant ? 'participant' : 'linked');
+            lines.push(`- ${identity} [${task.status}, ${ownership}] ${truncateSelfStateValue(task.title, 72)} @ ${source}`);
+        }
+        if (totalOtherTaskCount > recentTasks.length) {
+            lines.push(`- ... ${totalOtherTaskCount - recentTasks.length} more task(s) hidden`);
+        }
+    }
+    else {
+        lines.push(totalOtherTaskCount > 0 ? `other_tasks: ${totalOtherTaskCount} hidden` : 'other_tasks: none');
+    }
+    const recentHandoffs = state.recentHandoffs
+        .filter((handoff) => handoff.status !== 'completed')
+        .slice(0, 3);
+    if (recentHandoffs.length === 0) {
+        lines.push('recent_handoffs: none');
+    }
+    else {
+        lines.push('recent_handoffs:');
+        for (const handoff of recentHandoffs) {
+            lines.push(`- ${handoff.handoffId} ${truncateSelfStateValue(handoff.summaryText, 120)}`);
+        }
+        if (state.recentHandoffs.filter((handoff) => handoff.status !== 'completed').length > recentHandoffs.length) {
+            lines.push(`- ... ${state.recentHandoffs.filter((handoff) => handoff.status !== 'completed').length - recentHandoffs.length} more handoff(s) hidden`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatSelfStateSurface(conversation) {
+    return `${conversation.replyTarget} [${conversation.surfaceKind}, ${conversation.status}]`;
+}
+function buildSelfStateTeaser(context) {
+    if (!context)
+        return null;
+    const candidates = [
+        context.boundTask?.title,
+        context.goal,
+        context.lastMessage?.preview,
+    ];
+    for (const candidate of candidates) {
+        const trimmed = candidate?.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return null;
+}
+function formatHiddenSurfaceBreakdown(conversations) {
+    if (conversations.length === 0)
+        return '';
+    const order = ['active', 'queued', 'recovering', 'awaiting_approval', 'failed', 'idle'];
+    const counts = new Map();
+    for (const conversation of conversations) {
+        counts.set(conversation.status, (counts.get(conversation.status) ?? 0) + 1);
+    }
+    const parts = order
+        .map((status) => {
+        const count = counts.get(status) ?? 0;
+        return count > 0 ? `${status}=${count}` : null;
+    })
+        .filter((part) => Boolean(part));
+    return parts.length > 0 ? `(${parts.join(',')})` : '';
+}
+function formatTaskIdentity(agentTaskRef, taskNumber) {
+    if (agentTaskRef && taskNumber != null)
+        return `${agentTaskRef} · #t${taskNumber}`;
+    if (agentTaskRef)
+        return agentTaskRef;
+    if (taskNumber != null)
+        return `#t${taskNumber}`;
+    return 'task';
+}
+function truncateSelfStateValue(value, maxLength = 72) {
+    const trimmed = value?.trim() ?? '';
+    if (!trimmed)
+        return '';
+    if (trimmed.length <= maxLength)
+        return trimmed;
+    return `${trimmed.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function formatJoinedChannels(targets, maxChannels = 6) {
+    if (targets.length === 0)
+        return { text: '(none)', truncated: false };
+    const visibleTargets = targets.slice(0, maxChannels);
+    const hiddenCount = Math.max(0, targets.length - visibleTargets.length);
+    return {
+        text: hiddenCount > 0
+            ? `${visibleTargets.join(', ')} ... +${hiddenCount} more`
+            : visibleTargets.join(', '),
+        truncated: hiddenCount > 0,
+    };
+}
+function loadJoinedChannels(db, agent) {
+    const rows = db.prepare(`SELECT c.channel_id as channelId, ch.name as channelName
+       FROM agent_channel_memberships c
+       LEFT JOIN channels ch ON ch.channel_id = c.channel_id
+      WHERE c.agent_id = ?
+      ORDER BY CASE WHEN c.channel_id = ? THEN 0 ELSE 1 END, c.joined_at ASC`).all(agent.agentId, agent.channelId);
+    return rows.map((row) => ({
+        channelId: row.channelId,
+        name: row.channelName ?? null,
+        target: row.channelId.startsWith('dm:') ? row.channelId : `#${row.channelName ?? row.channelId}`,
+    }));
+}
+function toConversationState(db, agentId, row) {
+    const replyTarget = resolveConversationTarget(row);
+    const messageChannelId = row.threadKind === 'direct' ? `dm:${agentId}` : row.channelId;
+    return {
+        conversationId: row.conversationId,
+        title: row.title,
+        status: row.status,
+        channelId: messageChannelId,
+        channelName: row.channelName,
+        replyTarget,
+        surfaceKind: parseSurfaceKind(row.surfaceKind, {
+            threadKind: row.threadKind,
+            threadRootId: row.threadRootId,
+        }),
+        threadKind: row.threadKind,
+        isPrimaryThread: row.isPrimaryThread === 1,
+        threadRootId: row.threadRootId,
+        unreadCount: countUnreadMessages(db, agentId, row, messageChannelId, replyTarget),
+        queuedPromptCount: Number(row.queuedPromptCount ?? 0),
+        hasActiveRun: Boolean(row.activeRunId),
+        updatedAt: new Date(row.updatedAt).toISOString(),
+    };
+}
+function resolveConversationTarget(row) {
+    const trimmedReplyTarget = row.replyTarget?.trim();
+    if (trimmedReplyTarget)
+        return trimmedReplyTarget;
+    if (row.channelId.startsWith('dm:')) {
+        const peer = row.userId?.trim() ? `dm:@${row.userId.trim()}` : 'dm:@unknown';
+        if (row.threadRootId)
+            return `${peer}:${buildThreadShortId(row.threadRootId)}`;
+        return peer;
+    }
+    const baseTarget = `#${row.channelName ?? row.channelId}`;
+    if (row.threadRootId)
+        return `${baseTarget}:${buildThreadShortId(row.threadRootId)}`;
+    return baseTarget;
+}
+function countUnreadMessages(db, agentId, row, messageChannelId, replyTarget) {
+    const checkpoint = getAgentMessageCheckpoint(db, agentId, messageChannelId, row.threadRootId);
+    if (row.threadRootId) {
+        if ((row.threadKind === 'direct' || replyTarget.startsWith('dm:@')) && replyTarget.startsWith('dm:@')) {
+            const result = db.prepare(`SELECT COUNT(*) as count
+           FROM channel_messages
+          WHERE channel_id = ?
+            AND seq > ?
+            AND COALESCE(sender_id, '') != ?
+            AND COALESCE(message_source, '') != ?
+            AND (
+              thread_root_id = ?
+              OR (thread_root_id IS NULL AND target = ?)
+            )`).get(messageChannelId, checkpoint, agentId, TASK_LIFECYCLE_SOURCE, row.threadRootId, replyTarget);
+            return Number(result.count ?? 0);
+        }
+        const result = db.prepare(`SELECT COUNT(*) as count
+         FROM channel_messages
+        WHERE channel_id = ?
+          AND seq > ?
+          AND COALESCE(sender_id, '') != ?
+          AND COALESCE(message_source, '') != ?
+          AND thread_root_id = ?`).get(messageChannelId, checkpoint, agentId, TASK_LIFECYCLE_SOURCE, row.threadRootId);
+        return Number(result.count ?? 0);
+    }
+    const result = db.prepare(replyTarget.startsWith('dm:@')
+        ? `SELECT COUNT(*) as count
+           FROM channel_messages
+          WHERE channel_id = ?
+            AND seq > ?
+            AND COALESCE(sender_id, '') != ?
+            AND COALESCE(message_source, '') != ?
+            AND thread_root_id IS NULL
+            AND target = ?`
+        : `SELECT COUNT(*) as count
+           FROM channel_messages
+          WHERE channel_id = ?
+            AND seq > ?
+            AND COALESCE(sender_id, '') != ?
+            AND COALESCE(message_source, '') != ?
+            AND thread_root_id IS NULL`).get(...(replyTarget.startsWith('dm:@')
+        ? [messageChannelId, checkpoint, agentId, TASK_LIFECYCLE_SOURCE, replyTarget]
+        : [messageChannelId, checkpoint, agentId, TASK_LIFECYCLE_SOURCE]));
+    return Number(result.count ?? 0);
+}
+function compareConversations(currentConversationId) {
+    const statusWeight = {
+        active: 0,
+        recovering: 1,
+        awaiting_approval: 2,
+        queued: 3,
+        failed: 4,
+        idle: 5,
+    };
+    return (left, right) => {
+        if (currentConversationId) {
+            if (left.conversationId === currentConversationId && right.conversationId !== currentConversationId)
+                return -1;
+            if (right.conversationId === currentConversationId && left.conversationId !== currentConversationId)
+                return 1;
+        }
+        const leftWeight = statusWeight[left.status] ?? 99;
+        const rightWeight = statusWeight[right.status] ?? 99;
+        if (leftWeight !== rightWeight)
+            return leftWeight - rightWeight;
+        if (left.unreadCount !== right.unreadCount)
+            return right.unreadCount - left.unreadCount;
+        if (left.queuedPromptCount !== right.queuedPromptCount)
+            return right.queuedPromptCount - left.queuedPromptCount;
+        return right.updatedAt.localeCompare(left.updatedAt);
+    };
+}