@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/commands-v2/handlers/session.js

@@ -0,0 +1,805 @@
+/**
+ * Session Commands for REPL V2
+ *
+ * Commands for managing session persistence and resumption.
+ * Sessions are now bound to projects - each project has its own session.
+ */
+import { ResumeOverlayV2, } from '../../ui/overlay/index.js';
+import { getProjectSessionManager, } from '../../session/index.js';
+import { getCurrentProject } from '../../tools/project-db.js';
+import { projectRepository } from '../../db/repositories/index.js';
+import { getTeamCheckpointer, setActiveSharedContext } from '../../multi-agent/index.js';
+import { getSessionRegistry, getActiveTerminalSessionId } from '../../multi-agent/session-registry.js';
+import { getFileLockManager } from '../../multi-agent/file-locks.js';
+import { stripThinkingBlocks } from '../../utils/message-utils.js';
+import { truncate } from '../../ui/base/index.js';
+// =============================================================================
+// Message → PrintableItem Conversion
+// =============================================================================
+/**
+ * Convert restored messages to PrintableItems for Ctrl+R history view.
+ * Filters out noise (thinking blocks, pure tool_result messages) and
+ * maps each message to the appropriate PrintableItem type.
+ */
+export function convertMessagesToItems(messages) {
+    const items = [];
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            if (typeof msg.content === 'string') {
+                items.push({ type: 'user-message', text: msg.content });
+            }
+            else if (Array.isArray(msg.content)) {
+                // Extract text blocks only — skip pure tool_result messages
+                const textBlocks = msg.content.filter((b) => b.type === 'text');
+                if (textBlocks.length > 0) {
+                    const text = textBlocks.map(b => b.text).join('\n');
+                    items.push({ type: 'user-message', text });
+                }
+                // Skip messages that are purely tool_result blocks (no human text)
+            }
+        }
+        else if (msg.role === 'assistant') {
+            if (typeof msg.content === 'string') {
+                items.push({ type: 'agent-text', text: msg.content });
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'text') {
+                        items.push({ type: 'agent-text', text: block.text });
+                    }
+                    else if (block.type === 'tool_use') {
+                        // Brief summary of tool params
+                        const params = summarizeToolParams(block.input);
+                        items.push({ type: 'tool-start', name: block.name, params });
+                    }
+                    // Skip thinking blocks — noise in history review
+                }
+            }
+        }
+    }
+    return items;
+}
+/**
+ * Create a brief summary of tool parameters for history display.
+ */
+function summarizeToolParams(input) {
+    const keys = Object.keys(input);
+    if (keys.length === 0)
+        return '';
+    const parts = [];
+    for (const key of keys.slice(0, 3)) {
+        const val = input[key];
+        if (typeof val === 'string') {
+            const display = truncate(val, 50);
+            parts.push(`${key}: ${display}`);
+        }
+        else if (typeof val === 'number' || typeof val === 'boolean') {
+            parts.push(`${key}: ${String(val)}`);
+        }
+    }
+    if (keys.length > 3) {
+        parts.push(`+${String(keys.length - 3)} more`);
+    }
+    return parts.join(', ');
+}
+// =============================================================================
+// Session Management Helpers
+// =============================================================================
+/**
+ * Save the current agent state to the current project's session.
+ * Called after each successful agent response.
+ */
+export async function saveCurrentSession(state) {
+    const psm = getProjectSessionManager();
+    const currentProject = getCurrentProject();
+    const projectId = currentProject?.id ?? null;
+    const projectName = currentProject?.displayName ?? null;
+    // Get workflow state from project if available
+    let workflowState;
+    if (currentProject) {
+        const project = projectRepository.getById(currentProject.id);
+        if (project) {
+            workflowState = {
+                mode: project.workflowMode,
+                currentItemId: project.currentItemId ?? undefined,
+            };
+        }
+    }
+    await psm.saveProjectSession(projectId, projectName, state, workflowState);
+}
+/**
+ * Load the session for the current or specified project.
+ * Returns null if no session exists.
+ */
+export async function loadProjectSession(projectId) {
+    const psm = getProjectSessionManager();
+    return psm.loadProjectSession(projectId);
+}
+/**
+ * Check if the current project has a saved session.
+ */
+export function hasCurrentProjectSession() {
+    const psm = getProjectSessionManager();
+    const currentProject = getCurrentProject();
+    return psm.hasProjectSession(currentProject?.id ?? null);
+}
+/**
+ * Archive the current session before starting fresh.
+ */
+export async function archiveCurrentSession() {
+    const psm = getProjectSessionManager();
+    const currentProject = getCurrentProject();
+    return psm.archiveCurrentSession(currentProject?.id ?? null);
+}
+// =============================================================================
+// Team Persistence Helpers
+// =============================================================================
+/**
+ * Save the current team state to the current project.
+ * Called after each successful agent response (alongside session save).
+ * Also saves shared context and artifact store.
+ */
+export function saveCurrentTeam(team) {
+    const currentProject = getCurrentProject();
+    const projectId = currentProject?.id ?? null;
+    const checkpointer = getTeamCheckpointer();
+    // Save team metadata and agent states
+    checkpointer.saveTeam(projectId, team);
+    // Save shared context
+    checkpointer.saveSharedContext(projectId, team.sharedContext);
+    // Save artifacts
+    team.artifactStore.save();
+}
+/**
+ * Load the team for the current project.
+ * Returns null if no team exists.
+ * The checkpointer automatically loads shared context and artifact store.
+ */
+export function loadCurrentTeam(agentFactory, onEvent) {
+    const currentProject = getCurrentProject();
+    const projectId = currentProject?.id ?? null;
+    const checkpointer = getTeamCheckpointer();
+    return checkpointer.loadTeam(projectId, agentFactory, onEvent);
+}
+/**
+ * Check if the current project has a saved team.
+ */
+export function hasCurrentTeam() {
+    const currentProject = getCurrentProject();
+    const projectId = currentProject?.id ?? null;
+    const checkpointer = getTeamCheckpointer();
+    return checkpointer.hasTeam(projectId);
+}
+/**
+ * Delete the team for the current project.
+ */
+export function deleteCurrentTeam() {
+    const currentProject = getCurrentProject();
+    const projectId = currentProject?.id ?? null;
+    const checkpointer = getTeamCheckpointer();
+    return checkpointer.deleteTeam(projectId);
+}
+/**
+ * List all saved sessions for display in the resume overlay.
+ * Ordering priority:
+ *   1. This terminal's current session (if exists)
+ *   2. Other terminals' current sessions for the same project
+ *   3. History sessions for the same project
+ *   4. Other projects' sessions (sorted by most recent)
+ */
+async function listSessionsForResume() {
+    const psm = getProjectSessionManager();
+    const currentProject = getCurrentProject();
+    const allSessions = await psm.listAllSessions();
+    const currentProjectId = currentProject?.id ?? null;
+    const ownPrefix = getActiveTerminalSessionId()?.slice(0, 8) ?? null;
+    // Get current project's sessions
+    const currentProjectSessions = allSessions.get(currentProjectId) ?? [];
+    allSessions.delete(currentProjectId);
+    // Split current project sessions into tiers
+    const ownSession = [];
+    const otherTerminalSessions = [];
+    const historySessions = [];
+    for (const session of currentProjectSessions) {
+        if (session.terminalPrefix && ownPrefix && session.terminalPrefix === ownPrefix) {
+            ownSession.push(session);
+        }
+        else if (session.terminalPrefix) {
+            otherTerminalSessions.push(session);
+        }
+        else {
+            historySessions.push(session);
+        }
+    }
+    // Sort each tier by updatedAt descending
+    const byRecent = (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+    otherTerminalSessions.sort(byRecent);
+    historySessions.sort(byRecent);
+    // Build result with priority ordering
+    const result = [
+        ...ownSession,
+        ...otherTerminalSessions,
+        ...historySessions,
+    ];
+    // Add other projects' sessions (sorted by most recent)
+    const otherProjectSessions = [];
+    for (const sessions of allSessions.values()) {
+        otherProjectSessions.push(...sessions);
+    }
+    otherProjectSessions.sort(byRecent);
+    result.push(...otherProjectSessions);
+    return result;
+}
+/**
+ * Parse a session ID into its components.
+ * Handles both new format "current-{8hex}-{projectId}" and legacy "current-{projectId}".
+ */
+function parseCurrentSessionId(sessionId) {
+    if (!sessionId.startsWith('current-'))
+        return null;
+    const rest = sessionId.slice('current-'.length);
+    // New format: "{8hex}-{projectId}" or "{8hex}-global"
+    const hexMatch = /^([a-f0-9]{8})-(.+)$/.exec(rest);
+    if (hexMatch) {
+        const terminalPrefix = hexMatch[1];
+        const projectIdStr = hexMatch[2];
+        const projectId = projectIdStr === 'global' ? null : parseInt(projectIdStr, 10);
+        return { terminalPrefix, projectId };
+    }
+    // Legacy format: "{projectId}" or "global"
+    const projectId = rest === 'global' ? null : parseInt(rest, 10);
+    return { terminalPrefix: null, projectId };
+}
+/**
+ * Delete a session by ID.
+ * Handles both current and historical sessions.
+ */
+async function deleteSession(sessionId) {
+    const psm = getProjectSessionManager();
+    // Parse session ID to determine project and terminal prefix
+    const parsed = parseCurrentSessionId(sessionId);
+    if (parsed) {
+        if (parsed.terminalPrefix) {
+            return psm.deleteSessionByPrefix(parsed.projectId, parsed.terminalPrefix);
+        }
+        return psm.deleteCurrentSession(parsed.projectId);
+    }
+    // For historical sessions, we need to search all projects
+    // This is less common, so a simple search is acceptable
+    const allSessions = await psm.listAllSessions();
+    for (const [_projectId, sessions] of allSessions) {
+        const session = sessions.find((s) => s.sessionId === sessionId);
+        if (session) {
+            // TODO: Delete historical session from history folder
+            // For now, only current sessions are deletable
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check if there are any recent sessions (within last 24 hours).
+ */
+export async function hasRecentSession() {
+    const sessions = await listSessionsForResume();
+    if (sessions.length === 0)
+        return false;
+    const twentyFourHoursAgo = Date.now() - 24 * 60 * 60 * 1000;
+    const mostRecent = new Date(sessions[0].updatedAt).getTime();
+    return mostRecent > twentyFourHoursAgo;
+}
+/**
+ * Get the most recent session info.
+ */
+export async function getMostRecentSession() {
+    const sessions = await listSessionsForResume();
+    return sessions.length > 0 ? sessions[0] : null;
+}
+/**
+ * Checkpoint the current project's session before switching.
+ * Returns the old project ID if a checkpoint was made.
+ */
+export async function checkpointBeforeSwitch(agent) {
+    const currentProject = getCurrentProject();
+    const oldProjectId = currentProject?.id ?? null;
+    // Only checkpoint if we have an agent and messages to save
+    if (agent) {
+        try {
+            const state = agent.serialize();
+            if (state.messages.length > 0) {
+                await saveCurrentSession(state);
+            }
+        }
+        catch {
+            // Silently fail - checkpoint is best-effort
+        }
+    }
+    return oldProjectId;
+}
+/**
+ * Load and restore a session for a project.
+ * Returns the session if restored, null if no session or fresh start.
+ */
+export async function loadAndRestoreSession(projectId, agent, mode = 'auto') {
+    // Fresh mode = never load existing session
+    if (mode === 'fresh') {
+        return null;
+    }
+    const psm = getProjectSessionManager();
+    const session = await psm.loadProjectSession(projectId);
+    if (!session) {
+        return null;
+    }
+    // Auto mode = restore immediately
+    if (mode === 'auto' && agent) {
+        try {
+            // Strip thinking blocks - they contain provider-specific signatures
+            // that don't transfer between sessions (uses shared utility)
+            const messagesWithoutThinking = stripThinkingBlocks(session.messages);
+            await agent.setHistory(messagesWithoutThinking, { turnCount: session.turnCount });
+            return session;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Ask mode - return the session but don't restore (caller decides)
+    return session;
+}
+/**
+ * Handle project context switch after an overlay that may have changed projects.
+ * Checkpoints the old session, loads the new one, and refreshes context.
+ * Also handles team switching - saves old team and loads new project's team.
+ *
+ * @param oldProjectId - The project ID before the overlay was shown
+ * @param agent - The agent instance (for checkpoint/restore/anchors)
+ * @param teamOptions - Optional team switching options
+ * @returns Object with switch info, or null if no switch occurred
+ */
+export async function handleProjectSwitch(oldProjectId, agent, teamOptions) {
+    const newProject = getCurrentProject();
+    const newProjectId = newProject?.id ?? null;
+    // No switch occurred
+    if (oldProjectId === newProjectId) {
+        return null;
+    }
+    // Update session registry with new project + release old locks
+    const registry = getSessionRegistry();
+    if (registry) {
+        registry.updateProjectId(newProjectId);
+    }
+    const lockManager = getFileLockManager();
+    const sessionId = getActiveTerminalSessionId();
+    if (lockManager && sessionId) {
+        lockManager.releaseSessionLocks(sessionId);
+    }
+    // Switch occurred - checkpoint old session
+    if (agent && oldProjectId !== null) {
+        try {
+            const state = agent.serialize();
+            if (state.messages.length > 0) {
+                // Temporarily set back to old project for saving
+                const psm = getProjectSessionManager();
+                await psm.saveProjectSession(oldProjectId, null, // We don't have the old project name here
+                state);
+            }
+        }
+        catch {
+            // Best effort - continue even if checkpoint fails
+        }
+    }
+    // Load the new project's session
+    let sessionRestored = false;
+    let messageCount = 0;
+    let messages = [];
+    if (agent) {
+        try {
+            const psm = getProjectSessionManager();
+            const session = await psm.loadProjectSession(newProjectId);
+            if (session && session.messages.length > 0) {
+                // Strip thinking blocks from messages (uses shared utility)
+                messages = stripThinkingBlocks(session.messages);
+                messageCount = messages.length;
+                sessionRestored = true;
+            }
+        }
+        catch {
+            // If restore fails, start fresh
+        }
+    }
+    // Refresh project context (COMPILR.md, guided context, anchors)
+    let contextRefreshed = false;
+    let contextMessage;
+    try {
+        const contextResult = await refreshProjectContext(newProjectId, newProject?.path ?? null);
+        if (contextResult.memoryLoaded || contextResult.guidedContextGenerated) {
+            contextRefreshed = true;
+            contextMessage = contextResult.contextMessage;
+            // Append context refresh as a system message to the conversation
+            if (contextMessage && messages.length > 0) {
+                messages = [
+                    ...messages,
+                    {
+                        role: 'user',
+                        content: contextMessage,
+                    },
+                ];
+                messageCount = messages.length;
+            }
+        }
+        // Update agent's anchors for the new project
+        if (agent?.clearAnchors && agent.addAnchor) {
+            // Clear existing persistent anchors
+            agent.clearAnchors({ scope: 'persistent' });
+            // Add new project's anchors
+            const newAnchors = await getProjectAnchors(newProjectId);
+            for (const anchor of newAnchors) {
+                agent.addAnchor({
+                    id: anchor.id,
+                    content: anchor.content,
+                    priority: anchor.priority,
+                    scope: anchor.scope,
+                    tags: anchor.tags,
+                });
+            }
+        }
+    }
+    catch {
+        // Context refresh is best-effort
+    }
+    // Set the updated history (with context message if any)
+    if (agent) {
+        if (messages.length > 0) {
+            await agent.setHistory(messages, { turnCount: messageCount });
+        }
+        else {
+            agent.clearHistory();
+        }
+    }
+    // Handle team switching if team options provided
+    let newTeam;
+    if (teamOptions) {
+        const checkpointer = getTeamCheckpointer();
+        // Save the old team to the old project
+        if (teamOptions.team && oldProjectId !== null) {
+            try {
+                checkpointer.saveTeam(oldProjectId, teamOptions.team);
+                checkpointer.saveSharedContext(oldProjectId, teamOptions.team.sharedContext);
+                teamOptions.team.artifactStore.save();
+            }
+            catch {
+                // Best effort - continue even if save fails
+            }
+        }
+        // Load or create the new project's team
+        const loadedTeam = checkpointer.loadTeam(newProjectId, teamOptions.agentFactory, teamOptions.onEvent);
+        if (loadedTeam) {
+            newTeam = loadedTeam;
+        }
+        else {
+            // Create fresh team for the new project
+            const { AgentTeam } = await import('../../multi-agent/index.js');
+            newTeam = new AgentTeam({
+                name: newProject?.displayName ?? 'Team',
+                agentFactory: teamOptions.agentFactory,
+                onEvent: teamOptions.onEvent,
+            });
+        }
+    }
+    return {
+        switched: true,
+        oldProjectId,
+        newProjectId,
+        sessionRestored,
+        messageCount,
+        restoredMessages: sessionRestored ? messages : undefined,
+        contextRefreshed,
+        contextMessage,
+        newTeam,
+    };
+}
+/**
+ * Get the current project ID for tracking before overlay.
+ * Use with handleProjectSwitch after overlay closes.
+ */
+export function getCurrentProjectIdForTracking() {
+    const currentProject = getCurrentProject();
+    return currentProject?.id ?? null;
+}
+/**
+ * Refresh project context after switching projects.
+ * Loads COMPILR.md, generates guided context, and prepares anchor updates.
+ *
+ * @param projectId - The new project's ID (null for global)
+ * @param projectPath - The new project's path (for loading COMPILR.md)
+ * @returns Context refresh result with message to inject
+ */
+export async function refreshProjectContext(projectId, projectPath) {
+    // Lazy imports to avoid circular dependencies
+    const { loadProjectMemory } = await import('../../utils/project-memory.js');
+    const { getFullGuidedPrompt, shouldInjectGuidedContext } = await import('../../workflow/index.js');
+    const { workItemRepository } = await import('../../db/repositories/index.js');
+    const { getGlobalAnchorManager, getAnchorManager } = await import('../../anchors/index.js');
+    const result = {
+        memoryLoaded: false,
+        guidedContextGenerated: false,
+        anchorsLoaded: 0,
+        contextMessage: '',
+    };
+    const contextParts = [];
+    const project = projectId ? projectRepository.getById(projectId) : null;
+    // 1. Load COMPILR.md from the new project's directory
+    if (projectPath) {
+        const memory = loadProjectMemory({ cwd: projectPath });
+        if (memory.found && memory.content) {
+            result.memoryLoaded = true;
+            result.memoryContent = memory.content;
+            result.memoryPath = memory.filePath ?? undefined;
+            // Add to context message
+            const filename = memory.filePath?.split('/').pop() ?? 'COMPILR.md';
+            contextParts.push(`## Project Instructions (${filename})\n\n${memory.content}`);
+        }
+    }
+    // 2. Generate guided mode context if applicable
+    if (project && shouldInjectGuidedContext(project)) {
+        const statusCounts = workItemRepository.getStatusCounts(project.id);
+        let currentItem = null;
+        if (project.currentItemId) {
+            currentItem = workItemRepository.getByItemId(project.id, project.currentItemId);
+        }
+        else {
+            const inProgressItems = workItemRepository.query({
+                project_id: project.id,
+                status: 'in_progress',
+                limit: 1,
+            });
+            if (inProgressItems.items.length > 0) {
+                currentItem = inProgressItems.items[0];
+            }
+        }
+        const contextOptions = {
+            project,
+            currentItem,
+            backlogCount: statusCounts.backlog,
+            inProgressCount: statusCounts.in_progress,
+            completedCount: statusCounts.completed,
+        };
+        result.guidedContext = getFullGuidedPrompt(contextOptions);
+        result.guidedContextGenerated = true;
+        // Add to context message
+        contextParts.push(`## Current Workflow\n\n${result.guidedContext}`);
+    }
+    // 3. Collect anchors for the new project
+    const globalAnchors = getGlobalAnchorManager().getAll({ scope: 'persistent' });
+    const projectAnchors = projectId
+        ? getAnchorManager(String(projectId)).getAll({ scope: 'persistent' })
+        : [];
+    result.anchorsLoaded = globalAnchors.length + projectAnchors.length;
+    if (projectAnchors.length > 0) {
+        const anchorSummary = projectAnchors
+            .slice(0, 3)
+            .map(a => `- ${truncate(a.content, 50)}`)
+            .join('\n');
+        contextParts.push(`## Project Anchors (${String(projectAnchors.length)} items)\n\n${anchorSummary}`);
+    }
+    // Build final context message
+    if (contextParts.length > 0) {
+        result.contextMessage = `[Project context updated - now working on: ${project?.displayName ?? 'Global'}]\n\n${contextParts.join('\n\n---\n\n')}`;
+    }
+    else {
+        result.contextMessage = `[Project context updated - now working on: ${project?.displayName ?? 'Global'}]`;
+    }
+    return result;
+}
+/**
+ * Get anchor data for the new project (to update agent's anchor manager).
+ */
+export async function getProjectAnchors(projectId) {
+    const { getGlobalAnchorManager, getAnchorManager } = await import('../../anchors/index.js');
+    const globalAnchors = getGlobalAnchorManager().getAll({ scope: 'persistent' });
+    const projectAnchors = projectId
+        ? getAnchorManager(String(projectId)).getAll({ scope: 'persistent' })
+        : [];
+    return [
+        ...globalAnchors.map((a) => ({
+            id: a.id,
+            content: a.content,
+            priority: a.priority,
+            scope: a.scope,
+            tags: a.tags ?? [],
+        })),
+        ...projectAnchors.map((a) => ({
+            id: a.id,
+            content: a.content,
+            priority: a.priority,
+            scope: a.scope,
+            tags: a.tags ?? [],
+            projectId: String(projectId),
+        })),
+    ];
+}
+// =============================================================================
+// Resume Command
+// =============================================================================
+export const resumeCommand = {
+    name: 'resume',
+    aliases: ['sessions'],
+    description: 'Resume a previous session',
+    details: 'View and resume saved sessions. Sessions are now bound to projects - each project maintains its own conversation context. Use this to continue a previous conversation or switch between ongoing tasks.',
+    examples: [{ code: '/resume' }],
+    interactions: [
+        '↑/↓ to navigate sessions',
+        'Enter to resume selected session',
+        'd to delete a session',
+        '/ to search sessions',
+        'Esc to close',
+    ],
+    async execute(_args, ctx) {
+        // Load sessions
+        const sessions = await listSessionsForResume();
+        if (sessions.length === 0) {
+            ctx.ui.print({ type: 'info', message: 'No saved sessions found.' });
+            ctx.ui.print({ type: 'info', message: 'Sessions are automatically saved after each agent response.' });
+            return true;
+        }
+        // Show the resume overlay with current project context
+        const currentProject = getCurrentProject();
+        const overlay = new ResumeOverlayV2({
+            sessions,
+            currentProjectId: currentProject?.id ?? null,
+            onDelete: deleteSession,
+        });
+        const result = await ctx.ui.showOverlay(overlay);
+        // Handle result
+        if (result?.deleted) {
+            ctx.ui.print({ type: 'success', message: `Session deleted.` });
+            return true;
+        }
+        if (result?.sessionId) {
+            // Determine which project/terminal's session to load
+            let projectId = null;
+            let terminalPrefix = null;
+            const parsed = parseCurrentSessionId(result.sessionId);
+            if (parsed) {
+                projectId = parsed.projectId;
+                terminalPrefix = parsed.terminalPrefix;
+            }
+            else {
+                // For historical sessions, we'd need to parse from metadata
+                // For now, assume it's the current project
+                const currentProject = getCurrentProject();
+                projectId = currentProject?.id ?? null;
+            }
+            // Restore team roster (bound to the session's terminal prefix)
+            let teamRestored = false;
+            let teamAgentCount = 0;
+            if (terminalPrefix && ctx.team && ctx.agentFactory && ctx.setTeam) {
+                const checkpointer = getTeamCheckpointer();
+                const persistedTeam = checkpointer.loadTeamByPrefix(projectId, terminalPrefix, ctx.agentFactory);
+                if (persistedTeam && persistedTeam.size > 1) {
+                    // Wire up the current agent as default
+                    if (ctx.agent) {
+                        persistedTeam.setDefaultAgent(ctx.agent);
+                    }
+                    // Replace the team via ctx.setTeam (updates UI callbacks)
+                    ctx.setTeam(persistedTeam);
+                    setActiveSharedContext(persistedTeam.sharedContext);
+                    // Populate project info in shared context
+                    const activeProject = getCurrentProject();
+                    if (activeProject) {
+                        persistedTeam.sharedContext.setProject({
+                            id: activeProject.id,
+                            name: activeProject.displayName,
+                            path: activeProject.path,
+                        });
+                    }
+                    // Set team roster anchor
+                    if (persistedTeam.sharedContext.hasTeamRoster() && ctx.agent?.hasAnchors()) {
+                        ctx.agent.addAnchor({
+                            id: 'team-roster',
+                            content: persistedTeam.sharedContext.formatTeamRoster(),
+                            priority: 'info',
+                            scope: 'session',
+                        });
+                    }
+                    // Sync roster to session registry
+                    const registry = getSessionRegistry();
+                    if (registry) {
+                        const agents = persistedTeam.getAll();
+                        registry.updateAgents(agents.map(a => ({
+                            id: a.id,
+                            displayName: a.displayName,
+                            mascot: a.mascot,
+                        })));
+                    }
+                    teamRestored = true;
+                    teamAgentCount = persistedTeam.size;
+                }
+            }
+            // Load the session state (specific terminal or default)
+            const psm = getProjectSessionManager();
+            const session = terminalPrefix
+                ? await psm.loadProjectSessionByPrefix(projectId, terminalPrefix)
+                : await loadProjectSession(projectId);
+            // Claim: rename files from old prefix to this terminal's prefix
+            const ownPrefix = getActiveTerminalSessionId()?.slice(0, 8) ?? null;
+            if (terminalPrefix && ownPrefix && terminalPrefix !== ownPrefix) {
+                psm.claimSession(projectId, terminalPrefix, ownPrefix);
+                getTeamCheckpointer().claimTeamFiles(projectId, terminalPrefix, ownPrefix);
+            }
+            // Handle 0-message sessions (team-only restore)
+            if (!session || session.messages.length === 0) {
+                if (teamRestored) {
+                    ctx.ui.print({ type: 'success', message: `Team restored (${String(teamAgentCount)} agents).` });
+                }
+                else if (!session) {
+                    ctx.ui.print({ type: 'error', message: 'Failed to load session. It may have been corrupted or deleted.' });
+                }
+                else {
+                    ctx.ui.print({ type: 'info', message: 'Session has no conversation history.' });
+                }
+                return true;
+            }
+            // Restore the agent's conversation history
+            if (ctx.agent) {
+                try {
+                    // Strip thinking blocks (uses shared utility)
+                    const filteredMessages = stripThinkingBlocks(session.messages);
+                    // Use setHistory to restore the conversation
+                    // Pass turnCount to ensure compaction works correctly after resume
+                    await ctx.agent.setHistory(filteredMessages, {
+                        turnCount: session.turnCount,
+                    });
+                    // Show project info if session belongs to a different project
+                    const currentProject = getCurrentProject();
+                    if (session.projectId !== null && session.projectId !== currentProject?.id) {
+                        ctx.ui.print({ type: 'info', message: `Session from project: ${session.projectName ?? `ID ${String(session.projectId)}`}` });
+                    }
+                    // Build success message with team info
+                    const parts = [`${String(session.messages.length)} messages`];
+                    if (teamRestored) {
+                        parts.push(`${String(teamAgentCount)} agents`);
+                    }
+                    ctx.ui.print({ type: 'success', message: `Session restored (${parts.join(', ')}).` });
+                    // Populate restored history for Ctrl+R view
+                    const historyItems = convertMessagesToItems(filteredMessages);
+                    ctx.ui.setRestoredHistory(historyItems);
+                    // Show a summary of what was restored
+                    const lastUserMsg = session.messages.filter(m => m.role === 'user').pop();
+                    if (lastUserMsg) {
+                        let content = '';
+                        if (typeof lastUserMsg.content === 'string') {
+                            content = lastUserMsg.content;
+                        }
+                        else if (Array.isArray(lastUserMsg.content)) {
+                            const textBlock = lastUserMsg.content.find((b) => b.type === 'text');
+                            if (textBlock?.type === 'text') {
+                                content = textBlock.text;
+                            }
+                        }
+                        const preview = truncate(content, 60);
+                        if (preview) {
+                            ctx.ui.print({ type: 'info', message: `Last message: "${preview}"` });
+                        }
+                    }
+                    ctx.ui.print({ type: 'info', message: 'Tip: Use Ctrl+R to view conversation history.' });
+                }
+                catch (error) {
+                    ctx.ui.print({ type: 'error', message: `Failed to restore session: ${String(error)}` });
+                }
+            }
+            else {
+                ctx.ui.print({ type: 'warning', message: 'Cannot restore session - no agent connected.' });
+            }
+            return true;
+        }
+        // User cancelled
+        return true;
+    },
+};
+// =============================================================================
+// Export All Session Commands
+// =============================================================================
+export const sessionCommands = [
+    resumeCommand,
+];