pi-kot 0.1.20 → 0.1.21

package/dist/server/session-registry.js

@@ -1,754 +0,0 @@
-import { createAgentSession, DefaultResourceLoader, SessionManager, } from "@earendil-works/pi-coding-agent";
-import { compactionContinuationExtension } from "./compaction-continuation.js";
-import { mkdir, rename, readdir, stat } from "node:fs/promises";
-import { createAskUserQuestionTool } from "./ask-user-question/tool.js";
-import { createPlanModeQuestionTool } from "./ask-user-question/plan-mode-question-tool.js";
-import { join, basename } from "node:path";
-import { config } from "./config.js";
-import { isOrchestrationEnabled } from "./orchestration/config.js";
-/**
- * Build a DefaultResourceLoader with pi-kot's always-on extensions.
- * Currently registers the compaction continuation extension that nudges
- * the model to keep working after an overflow-driven auto-compaction.
- * Pass the result as `resourceLoader` to createAgentSession().
- *
- * Must call reload() before passing to the SDK so the loader is
- * in an operational state (the SDK skips resourceLoader.reload()
- * when a pre-built resourceLoader is provided).
- */
-export async function buildResourceLoader(cwd) {
-    const loader = new DefaultResourceLoader({
-        cwd,
-        agentDir: config.piConfigDir,
-        extensionFactories: [compactionContinuationExtension],
-    });
-    await loader.reload();
-    return loader;
-}
-import { isSupervisor } from "./orchestration/store.js";
-import { createOrchestrationTools } from "./orchestration/tools.js";
-import { bridgeWorkerAgentEvent } from "./orchestration/event-bridge.js";
-import { discoverExtensionResources } from "./extensions-discovery.js";
-import { notifySupervisorDisposed, notifySupervisorIdle } from "./orchestration/inbox.js";
-import { customToolsForProject as mcpCustomToolsForProject, ensureGlobalLoaded as mcpEnsureGlobalLoaded, ensureProjectLoaded as mcpEnsureProjectLoaded, isGloballyEnabled as mcpIsGloballyEnabled, } from "./mcp/manager.js";
-import { filterEnabledTools, readToolOverrides, isToolEffective } from "./tool-overrides.js";
-/**
- * Build the ExtensionBindings for a session with real command context
- * actions (navigateTree, fork, etc.) so extension commands like
- * pi-rewind's `/rewind` can navigate the conversation tree.
- *
- * Without this, `ctx.navigateTree()` is a no-op that returns
- * `{ cancelled: false }` without actually navigating.
- */
-export function buildBindings(session) {
-    return {
-        commandContextActions: {
-            waitForIdle: async () => { },
-            newSession: async () => ({ cancelled: false }),
-            fork: async () => ({ cancelled: false }),
-            switchSession: async () => ({ cancelled: false }),
-            reload: async () => { },
-            navigateTree: async (targetId, options) => {
-                return session.navigateTree(targetId, options);
-            },
-        },
-    };
-}
-const registry = new Map();
-function sessionDirFor(projectId) {
-    return join(config.sessionDir, projectId);
-}
-async function ensureSessionDir(projectId) {
-    const dir = sessionDirFor(projectId);
-    await mkdir(dir, { recursive: true });
-    return dir;
-}
-export async function discoverSessionsOnDisk(projectId, workspacePath) {
-    const dir = sessionDirFor(projectId);
-    try {
-        const infos = await SessionManager.list(workspacePath, dir);
-        return infos.map((info) => ({
-            sessionId: info.id,
-            path: info.path,
-            createdAt: info.created,
-            modifiedAt: info.modified,
-            messageCount: info.messageCount,
-            name: info.name,
-        }));
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return [];
-        throw err;
-    }
-}
-export async function listSessionsForProject(projectId, workspacePath) {
-    const live = listSessions(projectId);
-    const liveById = new Map(live.map((l) => [
-        l.sessionId,
-        {
-            sessionId: l.sessionId,
-            projectId: l.projectId,
-            isLive: true,
-            name: l.name ?? l.session.sessionName,
-            createdAt: l.createdAt,
-            lastActivityAt: l.lastActivityAt,
-            messageCount: l.session.messages.length,
-        },
-    ]));
-    const disk = await discoverSessionsOnDisk(projectId, workspacePath);
-    for (const d of disk) {
-        const merged = liveById.get(d.sessionId);
-        if (merged !== undefined) {
-            merged.messageCount = d.messageCount;
-            continue;
-        }
-        liveById.set(d.sessionId, {
-            sessionId: d.sessionId,
-            projectId,
-            isLive: false,
-            name: d.name,
-            createdAt: d.createdAt,
-            lastActivityAt: d.modifiedAt,
-            messageCount: d.messageCount,
-        });
-    }
-    return Array.from(liveById.values()).sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime());
-}
-/**
- * Create a new session. Uses disk-backed SessionManager for persistence.
- */
-export async function createSession(projectId, workspacePath) {
-    const dir = await ensureSessionDir(projectId);
-    const sessionManager = SessionManager.create(workspacePath, dir);
-    const sessionId = sessionManager.getSessionId();
-    const mcpTools = await resolveMcpCustomTools(projectId, workspacePath);
-    const orchestrationTools = await resolveOrchestrationTools(sessionId);
-    const customTools = [
-        ...mcpTools,
-        createAskUserQuestionTool(sessionId),
-        createPlanModeQuestionTool(sessionId),
-        ...orchestrationTools,
-    ];
-    const resourceLoader = await buildResourceLoader(workspacePath);
-    const { session } = await createAgentSession({
-        cwd: workspacePath,
-        sessionManager,
-        agentDir: config.piConfigDir,
-        customTools,
-        resourceLoader,
-    });
-    // Trigger session_start event and wire real command context actions
-    // (navigateTree, etc.) so extension commands like /rewind can
-    // navigate the conversation tree.
-    await session.bindExtensions(buildBindings(session)).catch(() => {
-        // best-effort
-    });
-    const now = new Date();
-    const live = {
-        session,
-        sessionId: session.sessionId,
-        projectId,
-        workspacePath,
-        sessionManager,
-        clients: new Set(),
-        createdAt: now,
-        lastActivityAt: now,
-        lastAgentStartIndex: undefined,
-        unsubscribe: () => undefined,
-        name: sessionManager.getSessionName(),
-        currentExecAbort: undefined,
-    };
-    // Wire the registry's event subscription
-    live.unsubscribe = session.subscribe((event) => {
-        live.lastActivityAt = new Date();
-        if (event.type === "agent_start") {
-            live.lastAgentStartIndex = live.session.messages.length;
-        }
-        // Bridge orchestration lifecycle events (fire-and-forget)
-        if (event.type === "agent_start" || event.type === "agent_end") {
-            void bridgeWorkerAgentEvent({ sessionId: live.sessionId, session: live.session }, event);
-        }
-        // Notify supervisor idle — compatibility recovery for undelivered items
-        if (event.type === "agent_end") {
-            void notifySupervisorIdle(live.sessionId);
-        }
-        // Fan out to all connected SSE clients
-        for (const client of live.clients) {
-            try {
-                client.send(event);
-            }
-            catch {
-                live.clients.delete(client);
-            }
-        }
-    });
-    registry.set(live.sessionId, live);
-    return live;
-}
-/** Get a live session by id. Returns undefined if not in the registry. */
-export function getSession(sessionId) {
-    return registry.get(sessionId);
-}
-/** List live sessions, optionally filtered by projectId. */
-export function listSessions(projectId) {
-    const all = Array.from(registry.values());
-    return projectId === undefined ? all : all.filter((s) => s.projectId === projectId);
-}
-/** Number of active sessions. */
-export function sessionCount() {
-    return registry.size;
-}
-/** Register a session in the registry (used by session resume). */
-export function registerSession(live) {
-    registry.set(live.sessionId, live);
-}
-/* ── Archive / Unarchive ── */
-function archivedDirFor(projectId) {
-    return join(config.sessionDir, projectId, "_archived");
-}
-/**
- * Archive a session: move JSONL to _archived/ subfolder, remove from live registry.
- * Works for both live and disk-only sessions.
- * Returns true if archived, false if not found on disk or in registry.
- */
-export async function archiveSession(sessionId, projectId) {
-    // Always check registry first — live session takes precedence
-    const live = registry.get(sessionId);
-    const resolvedProjectId = live?.projectId ?? projectId;
-    if (resolvedProjectId === undefined)
-        return false;
-    const pid = resolvedProjectId;
-    const srcDir = join(config.sessionDir, pid);
-    let fileMoved = false;
-    // Find and move the JSONL file
-    try {
-        const files = await readdir(srcDir);
-        const match = files.find((f) => f.endsWith(".jsonl") && f.includes(sessionId));
-        if (match) {
-            const archiveDir = archivedDirFor(pid);
-            await mkdir(archiveDir, { recursive: true });
-            await rename(join(srcDir, match), join(archiveDir, match));
-            fileMoved = true;
-        }
-    }
-    catch {
-        // best-effort file move
-    }
-    // Remove from live registry if present
-    if (live !== undefined) {
-        try {
-            await live.session.abort();
-        }
-        catch { }
-        try {
-            live.unsubscribe();
-        }
-        catch { }
-        for (const client of live.clients) {
-            try {
-                client.close();
-            }
-            catch { }
-        }
-        live.clients.clear();
-        try {
-            live.session.dispose();
-        }
-        catch { }
-        registry.delete(sessionId);
-    }
-    return fileMoved || live !== undefined;
-}
-/**
- * Unarchive a session: move JSONL back from _archived/ to main dir.
- * Does NOT warm it back into the live registry — that happens on SSE connect.
- * Returns true if restored, false if no archive file found.
- */
-export async function unarchiveSession(sessionId, projectId) {
-    const archiveDir = archivedDirFor(projectId);
-    try {
-        const files = await readdir(archiveDir);
-        const match = files.find((f) => f.endsWith(".jsonl") && f.includes(sessionId));
-        if (!match)
-            return false;
-        const srcDir = join(config.sessionDir, projectId);
-        await rename(join(archiveDir, match), join(srcDir, match));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * List archived sessions for a project.
- */
-export async function listArchivedSessions(projectId, workspacePath) {
-    const archiveDir = archivedDirFor(projectId);
-    try {
-        await stat(archiveDir);
-    }
-    catch {
-        return []; // archive dir doesn't exist
-    }
-    try {
-        const files = await readdir(archiveDir);
-        const jsonls = files.filter((f) => f.endsWith(".jsonl"));
-        const results = [];
-        for (const file of jsonls) {
-            try {
-                const sessionPath = join(archiveDir, file);
-                const sm = SessionManager.open(sessionPath);
-                // Derive sessionId from the filename (UUID after timestamp prefix)
-                const base = basename(file, ".jsonl");
-                const underscoreIdx = base.indexOf("_");
-                const sessionId = underscoreIdx !== -1 ? base.slice(underscoreIdx + 1) : base;
-                const ctx = sm.buildSessionContext();
-                const info = SessionManager.list(workspacePath, archiveDir);
-                const match = (await info).find((i) => i.id === sessionId);
-                results.push({
-                    sessionId,
-                    projectId,
-                    isLive: false,
-                    name: match?.name ?? sm.getSessionName(),
-                    createdAt: match?.created ?? new Date(0),
-                    lastActivityAt: match?.modified ?? new Date(0),
-                    messageCount: ctx.messages.length,
-                });
-            }
-            catch {
-                // skip corrupt files
-            }
-        }
-        return results.sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime());
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Rename a live session. Persists via SessionManager.appendSessionInfo.
- * Returns true if renamed, false if session not live.
- */
-export function renameSession(sessionId, name) {
-    const live = registry.get(sessionId);
-    if (live === undefined)
-        return false;
-    const trimmed = name.trim();
-    if (trimmed.length === 0)
-        return false;
-    live.sessionManager.appendSessionInfo(trimmed);
-    live.name = trimmed;
-    return true;
-}
-/**
- * Auto-name a session from the first user prompt text.
- * Called when the first prompt is sent. Truncates to 60 chars.
- */
-export function autoNameSession(sessionId, promptText) {
-    const live = registry.get(sessionId);
-    if (live === undefined)
-        return;
-    // Only auto-name if no name is already set
-    if (live.name !== undefined)
-        return;
-    const name = promptText.trim().slice(0, 60).replace(/\n/g, " ");
-    if (name.length === 0)
-        return;
-    live.sessionManager.appendSessionInfo(name);
-    live.name = name;
-}
-/**
- * Resolve MCP custom tools for a session.
- * Resolve MCP custom tools — ensures global + project
- * MCP config is loaded, respects the master disabled toggle, and returns
- * the union of all connected, enabled server tools for this project.
- */
-async function resolveMcpCustomTools(projectId, workspacePath) {
-    await mcpEnsureGlobalLoaded().catch(() => undefined);
-    if (!mcpIsGloballyEnabled())
-        return [];
-    await mcpEnsureProjectLoaded(projectId, workspacePath).catch(() => undefined);
-    const tools = mcpCustomToolsForProject(projectId);
-    // Apply tool-level overrides (global disabled set + per-project tri-state)
-    const overrides = await readToolOverrides().catch(() => undefined);
-    if (overrides === undefined)
-        return tools;
-    return tools.filter((t) => isToolEffective(overrides, projectId, "mcp", t.name));
-}
-/**
- * Resolve orchestration tools for a session, if supervisor mode is active.
- * Returns empty array when orchestration is disabled or the session isn't
- * a registered supervisor.
- */
-async function resolveOrchestrationTools(sessionId) {
-    if (!isOrchestrationEnabled())
-        return [];
-    try {
-        if (!(await isSupervisor(sessionId)))
-            return [];
-        return createOrchestrationTools(sessionId);
-    }
-    catch {
-        return [];
-    }
-}
-/** Builtin tool names known to the SDK. */
-const BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
-/**
- * Build the tools allowlist for createAgentSession, respecting tool
- * overrides (global disabled set + per-project tri-state) across
- * builtin, MCP/custom, and extension-contributed tools.
- */
-async function buildToolsAllowlist(customTools, projectId, cwd) {
-    const overrides = await readToolOverrides();
-    const extResources = await discoverExtensionResources(cwd);
-    // Classify each custom tool: forge-native tools (askUserQuestion,
-    // orchestration) are treated as "builtin"; MCP tools remain "mcp".
-    const builtinCustomToolNames = new Set([
-        "ask_user_question",
-        ...BUILTIN_TOOL_NAMES,
-    ]);
-    const candidates = [
-        ...BUILTIN_TOOL_NAMES.map((n) => ({ family: "builtin", name: n })),
-        ...customTools.map((t) => ({
-            family: builtinCustomToolNames.has(t.name)
-                ? "builtin"
-                : "mcp",
-            name: t.name,
-        })),
-        ...extResources.tools.map((t) => ({
-            family: "extension",
-            name: t.name,
-        })),
-    ];
-    const enabled = filterEnabledTools(overrides, projectId, candidates);
-    return enabled.map((e) => e.name);
-}
-/**
- * Rebuild a live session's AgentSession with updated custom tools.
- * Preserves the SessionManager (messages intact), SSE clients stay
- * attached, and the old session is disposed cleanly.
- */
-export async function rebuildSessionTools(sessionId) {
-    const live = registry.get(sessionId);
-    if (live === undefined)
-        return;
-    const mcpTools = await resolveMcpCustomTools(live.projectId, live.workspacePath);
-    const orchestrationTools = await resolveOrchestrationTools(sessionId);
-    const customTools = [
-        ...mcpTools,
-        createAskUserQuestionTool(sessionId),
-        createPlanModeQuestionTool(sessionId),
-        ...orchestrationTools,
-    ];
-    // Unsubscribe old subscription, abort any in-flight turn
-    try {
-        live.unsubscribe();
-    }
-    catch { /* ignore */ }
-    try {
-        await live.session.abort();
-    }
-    catch { /* ignore */ }
-    // Create new AgentSession with same SessionManager but updated tools
-    const resourceLoader = await buildResourceLoader(live.workspacePath);
-    const toolsAllowlist = await buildToolsAllowlist(customTools, live.projectId, live.workspacePath);
-    const { session } = await createAgentSession({
-        cwd: live.workspacePath,
-        sessionManager: live.sessionManager,
-        agentDir: config.piConfigDir,
-        customTools,
-        resourceLoader,
-        tools: toolsAllowlist,
-    });
-    // Wire real command context actions (navigateTree, etc.) so
-    // extension commands like /rewind can navigate the conversation.
-    await session.bindExtensions(buildBindings(session)).catch(() => {
-        // best-effort
-    });
-    // Dispose old session
-    try {
-        live.session.dispose();
-    }
-    catch { /* ignore */ }
-    // Swap in new session
-    live.session = session;
-    // Re-subscribe
-    live.unsubscribe = session.subscribe((event) => {
-        live.lastActivityAt = new Date();
-        if (event.type === "agent_start") {
-            live.lastAgentStartIndex = live.session.messages.length;
-        }
-        if (event.type === "agent_start" || event.type === "agent_end") {
-            void bridgeWorkerAgentEvent({ sessionId: live.sessionId, session: live.session }, event);
-        }
-        if (event.type === "agent_end") {
-            void notifySupervisorIdle(live.sessionId);
-        }
-        for (const client of live.clients) {
-            try {
-                client.send(event);
-            }
-            catch {
-                live.clients.delete(client);
-            }
-        }
-    });
-    // Notify SSE clients about the rebuild
-    for (const client of live.clients) {
-        try {
-            client.send({
-                type: "custom_tools_changed",
-                sessionId: live.sessionId,
-                toolCount: customTools.length,
-            });
-        }
-        catch {
-            live.clients.delete(client);
-        }
-    }
-}
-/** Dispose a live session — abort, unsubscribe, close clients, remove from registry. */
-export async function disposeSession(sessionId) {
-    const live = registry.get(sessionId);
-    if (live === undefined)
-        return false;
-    try {
-        await live.session.abort();
-    }
-    catch {
-        // best-effort
-    }
-    try {
-        live.unsubscribe();
-    }
-    catch {
-        // ignore
-    }
-    for (const client of live.clients) {
-        try {
-            client.close();
-        }
-        catch {
-            // ignore
-        }
-    }
-    live.clients.clear();
-    try {
-        live.session.dispose();
-    }
-    catch {
-        // ignore
-    }
-    registry.delete(live.sessionId);
-    // Clean up orchestration dedupe state for this session
-    notifySupervisorDisposed(live.sessionId);
-    return true;
-}
-/** Dispose all sessions (called on server shutdown). */
-export async function disposeAllSessions() {
-    const ids = Array.from(registry.keys());
-    await Promise.all(ids.map((id) => disposeSession(id)));
-}
-/**
- * Find a session's location on disk. Returns projectId and workspacePath
- * by scanning all project session dirs.
- */
-export async function findSessionLocation(sessionId) {
-    // Check all project directories
-    const { readProjects } = await import("./project-manager.js");
-    try {
-        const projects = await readProjects();
-        for (const project of projects) {
-            const dir = join(config.sessionDir, project.id);
-            try {
-                const files = await readdir(dir);
-                if (files.some((f) => f.includes(sessionId))) {
-                    return { projectId: project.id, workspacePath: project.path };
-                }
-            }
-            catch {
-                // dir doesn't exist, skip
-            }
-        }
-    }
-    catch {
-        // can't read projects
-    }
-    return undefined;
-}
-/**
- * Resume a cold session from disk. Opens the JSONL, creates an AgentSession,
- * registers it in the registry, and returns the LiveSession.
- */
-export async function resumeSessionById(sessionId) {
-    const loc = await findSessionLocation(sessionId);
-    if (loc === undefined) {
-        throw new Error(`session_not_found: ${sessionId}`);
-    }
-    const dir = join(config.sessionDir, loc.projectId);
-    const files = await readdir(dir);
-    const match = files.find((f) => f.endsWith(".jsonl") && f.includes(sessionId));
-    if (match === undefined) {
-        throw new Error(`session_not_found: ${sessionId}`);
-    }
-    const sessionPath = join(dir, match);
-    const sessionManager = SessionManager.open(sessionPath);
-    const mcpTools = await resolveMcpCustomTools(loc.projectId, loc.workspacePath);
-    const orchestrationTools = await resolveOrchestrationTools(sessionId);
-    const customTools = [
-        ...mcpTools,
-        createAskUserQuestionTool(sessionId),
-        createPlanModeQuestionTool(sessionId),
-        ...orchestrationTools,
-    ];
-    const resourceLoader = await buildResourceLoader(loc.workspacePath);
-    const { session } = await createAgentSession({
-        cwd: loc.workspacePath,
-        sessionManager,
-        agentDir: config.piConfigDir,
-        customTools,
-        resourceLoader,
-    });
-    // Wire real command context actions (navigateTree, etc.) so
-    // extension commands like /rewind can navigate the conversation.
-    await session.bindExtensions(buildBindings(session)).catch(() => {
-        // best-effort
-    });
-    const now = new Date();
-    const live = {
-        session,
-        sessionId,
-        projectId: loc.projectId,
-        workspacePath: loc.workspacePath,
-        sessionManager,
-        clients: new Set(),
-        createdAt: now,
-        lastActivityAt: now,
-        lastAgentStartIndex: undefined,
-        unsubscribe: () => undefined,
-        name: sessionManager.getSessionName(),
-        currentExecAbort: undefined,
-    };
-    live.unsubscribe = session.subscribe((event) => {
-        live.lastActivityAt = new Date();
-        if (event.type === "agent_start") {
-            live.lastAgentStartIndex = live.session.messages.length;
-        }
-        // Bridge orchestration lifecycle events (fire-and-forget)
-        if (event.type === "agent_start" || event.type === "agent_end") {
-            void bridgeWorkerAgentEvent({ sessionId: live.sessionId, session: live.session }, event);
-        }
-        // Notify supervisor idle on agent_end
-        if (event.type === "agent_end") {
-            void notifySupervisorIdle(live.sessionId);
-        }
-        for (const client of live.clients) {
-            try {
-                client.send(event);
-            }
-            catch {
-                live.clients.delete(client);
-            }
-        }
-    });
-    registry.set(live.sessionId, live);
-    return live;
-}
-/**
- * Fork a session at a given entry. Creates a new JSONL file containing
- * the path-to-leaf from root to the given entry, registers the new
- * session, and returns it.
- *
- * NOTE: `createBranchedSession` mutates the source session's in-memory
- * file reference to point at the new fork (SDK behavior). We handle this
- * by capturing the source file before and re-opening the source after.
- */
-export async function forkSession(sessionId, entryId) {
-    const sourceLive = registry.get(sessionId);
-    if (sourceLive === undefined) {
-        // Try to resume cold first, then fork
-        const resumed = await resumeSessionById(sessionId);
-        return forkSession(resumed.sessionId, entryId);
-    }
-    // Capture the source file path BEFORE createBranchedSession mutates it
-    const sourceSessionFile = sourceLive.sessionManager.getSessionFile();
-    if (sourceSessionFile === undefined) {
-        throw new Error("fork_failed: source session has no file (in-memory only)");
-    }
-    const sourceDir = join(config.sessionDir, sourceLive.projectId);
-    // Create the branched session file
-    const newPath = sourceLive.sessionManager.createBranchedSession(entryId);
-    if (newPath === undefined) {
-        throw new Error("fork_failed: createBranchedSession returned undefined");
-    }
-    // Re-open the SOURCE session from the original file to undo SDK mutation
-    const restoredSourceSM = SessionManager.open(sourceSessionFile, sourceDir, sourceLive.workspacePath);
-    sourceLive.sessionManager = restoredSourceSM;
-    // Open the new fork as a SessionManager
-    const dir = join(config.sessionDir, sourceLive.projectId);
-    const forkedSM = SessionManager.open(newPath, dir, sourceLive.workspacePath);
-    const forkedId = forkedSM.getSessionId();
-    const mcpTools = await resolveMcpCustomTools(sourceLive.projectId, sourceLive.workspacePath);
-    const orchestrationTools = await resolveOrchestrationTools(forkedId);
-    const customTools = [
-        ...mcpTools,
-        createAskUserQuestionTool(forkedId),
-        createPlanModeQuestionTool(forkedId),
-        ...orchestrationTools,
-    ];
-    const resourceLoader = await buildResourceLoader(sourceLive.workspacePath);
-    const { session } = await createAgentSession({
-        cwd: sourceLive.workspacePath,
-        sessionManager: forkedSM,
-        agentDir: config.piConfigDir,
-        customTools,
-        resourceLoader,
-    });
-    // Wire real command context actions (navigateTree, etc.) so
-    // extension commands like /rewind can navigate the conversation.
-    await session.bindExtensions(buildBindings(session)).catch(() => {
-        // best-effort
-    });
-    const now = new Date();
-    const forkedLive = {
-        session,
-        sessionId: session.sessionId,
-        projectId: sourceLive.projectId,
-        workspacePath: sourceLive.workspacePath,
-        sessionManager: forkedSM,
-        clients: new Set(),
-        createdAt: now,
-        lastActivityAt: now,
-        lastAgentStartIndex: undefined,
-        unsubscribe: () => undefined,
-        name: forkedSM.getSessionName(),
-        currentExecAbort: undefined,
-    };
-    forkedLive.unsubscribe = session.subscribe((event) => {
-        forkedLive.lastActivityAt = new Date();
-        if (event.type === "agent_start") {
-            forkedLive.lastAgentStartIndex = forkedLive.session.messages.length;
-        }
-        // Bridge orchestration lifecycle events (fire-and-forget)
-        if (event.type === "agent_start" || event.type === "agent_end") {
-            void bridgeWorkerAgentEvent({ sessionId: forkedLive.sessionId, session: forkedLive.session }, event);
-        }
-        // Notify supervisor idle on agent_end
-        if (event.type === "agent_end") {
-            void notifySupervisorIdle(forkedLive.sessionId);
-        }
-        for (const client of forkedLive.clients) {
-            try {
-                client.send(event);
-            }
-            catch {
-                forkedLive.clients.delete(client);
-            }
-        }
-    });
-    registry.set(forkedLive.sessionId, forkedLive);
-    return forkedLive;
-}
-//# sourceMappingURL=session-registry.js.map