pikiloop 0.4.0

package/dist/bot/render-shared.js

@@ -0,0 +1,309 @@
+/**
+ * Shared rendering utilities used by channel-specific renderers.
+ *
+ * Contains types, pure-data helpers, and functions that are identical across platforms.
+ * Platform-specific formatting (HTML vs Markdown) stays in the respective render files.
+ */
+import { materializeImage } from '../agent/index.js';
+import { fmtUptime, formatThinkingForDisplay, thinkLabel } from './bot.js';
+import { formatActivityCommandSummary, parseActivitySummary, renderPlanForPreview, summarizeActivityForPreview } from './streaming.js';
+import { supportsChannelCapability } from '../channels/base.js';
+import { agentLog, agentWarn } from '../agent/index.js';
+// ---------------------------------------------------------------------------
+// GFM table parsing
+// ---------------------------------------------------------------------------
+/** Parse GFM table lines into structured headers + rows. */
+export function parseGfmTable(tableLines) {
+    if (tableLines.length < 3)
+        return null;
+    const parseRow = (line) => line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map(c => c.trim());
+    const isSep = (line) => {
+        const cells = parseRow(line);
+        return cells.length > 0 && cells.every(c => /^:?-{2,}:?$/.test(c));
+    };
+    let headerIdx = -1;
+    for (let i = 0; i < tableLines.length - 1; i++) {
+        if (isSep(tableLines[i + 1])) {
+            headerIdx = i;
+            break;
+        }
+    }
+    if (headerIdx < 0)
+        return null;
+    const headers = parseRow(tableLines[headerIdx]);
+    const rows = [];
+    for (let i = headerIdx + 2; i < tableLines.length; i++) {
+        if (isSep(tableLines[i]))
+            continue;
+        rows.push(parseRow(tableLines[i]));
+    }
+    return rows.length ? { headers, rows } : null;
+}
+// ---------------------------------------------------------------------------
+// Footer helpers
+// ---------------------------------------------------------------------------
+export function fmtCompactUptime(ms) {
+    return fmtUptime(ms).replace(/\s+/g, '');
+}
+export function footerStatusSymbol(status) {
+    switch (status) {
+        case 'running': return '●';
+        case 'done': return '✓';
+        case 'failed': return '✗';
+    }
+}
+/**
+ * Drop a leading `provider/` segment from long model ids so the footer stays
+ * readable on narrow IM clients. `anthropic/claude-sonnet-4` → `claude-sonnet-4`,
+ * `deepseek/deepseek-v4-flash` → `deepseek-v4-flash`. Already-short ids are
+ * returned unchanged.
+ */
+function compactModelLabel(model) {
+    const trimmed = model.trim();
+    if (trimmed.length <= 24)
+        return trimmed;
+    const slashIdx = trimmed.indexOf('/');
+    return slashIdx > 0 ? trimmed.slice(slashIdx + 1) : trimmed;
+}
+/**
+ * Split footer fields into a primary identity line (agent + model) and a
+ * secondary runtime line (effort, context%, elapsed). Channel renderers
+ * compose the two lines with their own visual styling so narrow IM clients
+ * never have to soft-wrap a single dense line.
+ */
+export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decorations) {
+    const identityParts = [agent];
+    if (decorations?.model)
+        identityParts.push(compactModelLabel(decorations.model));
+    const runtimeParts = [];
+    if (decorations?.effort)
+        runtimeParts.push(decorations.effort);
+    const ctx = contextPercent ?? meta?.contextPercent ?? null;
+    if (ctx != null)
+        runtimeParts.push(`${ctx}%`);
+    runtimeParts.push(fmtCompactUptime(Math.max(0, Math.round(elapsedMs))));
+    // BYOK attribution — tells the user the turn is being routed through a
+    // third-party provider rather than the agent CLI's native auth path.
+    // Tucked at the end of the runtime line so it doesn't crowd the (often
+    // long) identity line on narrow IM clients.
+    const providerName = meta?.providerName ?? decorations?.provider ?? null;
+    if (providerName)
+        runtimeParts.push(`via ${providerName}`);
+    return {
+        identity: identityParts.join(' · '),
+        runtime: runtimeParts.join(' · '),
+    };
+}
+// ---------------------------------------------------------------------------
+// Activity trimming
+// ---------------------------------------------------------------------------
+/**
+ * Trim the activity narrative for a streaming preview. Keeps the **most
+ * recent** lines that fit the budget — the user is watching the turn live,
+ * what just happened matters far more than what happened 30 tool-calls ago.
+ * A leading `...` marker signals "earlier activity dropped" when truncation
+ * happens; the tail order is preserved.
+ */
+export function trimActivityForPreview(text, maxChars = 900) {
+    if (text.length <= maxChars)
+        return text;
+    const lines = text.split('\n').filter(line => line.trim());
+    if (lines.length <= 1) {
+        // Single very-long line — keep the trailing characters with a leading
+        // ellipsis so the freshest content is visible.
+        return '...' + text.slice(text.length - Math.max(0, maxChars - 3));
+    }
+    const ellipsis = '...';
+    const budget = Math.max(0, maxChars - ellipsis.length - 1);
+    const tail = [];
+    let used = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        const extra = line.length + (tail.length ? 1 : 0);
+        if (used + extra > budget)
+            break;
+        tail.unshift(line);
+        used += extra;
+    }
+    if (!tail.length) {
+        return ellipsis + '\n' + lines[lines.length - 1].slice(-Math.max(0, maxChars - ellipsis.length - 1));
+    }
+    if (tail.length === lines.length)
+        return tail.join('\n');
+    return [ellipsis, ...tail].join('\n');
+}
+// ---------------------------------------------------------------------------
+// Provider usage (plain-text builder — caller wraps as needed)
+// ---------------------------------------------------------------------------
+function rawUsageLine(parts) {
+    return parts.filter(part => !!part && String(part).trim()).join(' ');
+}
+export function buildProviderUsageLines(usage) {
+    const lines = [
+        { text: '', bold: false },
+        { text: 'Provider Usage', bold: true },
+    ];
+    if (!usage.ok) {
+        lines.push({ text: `  Unavailable: ${usage.error || 'No recent usage data found.'}` });
+        return lines;
+    }
+    if (usage.capturedAt) {
+        const capturedAtMs = Date.parse(usage.capturedAt);
+        if (Number.isFinite(capturedAtMs)) {
+            lines.push({ text: `  Updated: ${fmtUptime(Math.max(0, Date.now() - capturedAtMs))} ago` });
+        }
+    }
+    if (!usage.windows.length) {
+        lines.push({ text: `  ${usage.status ? `status=${usage.status}` : 'No window data'}` });
+        return lines;
+    }
+    for (const window of usage.windows) {
+        const details = rawUsageLine([
+            window.usedPercent != null ? `${window.usedPercent}% used` : null,
+            window.status ? `status=${window.status}` : null,
+            window.resetAfterSeconds != null ? `resetAfterSeconds=${window.resetAfterSeconds}` : null,
+        ]);
+        lines.push({ text: `  ${window.label}: ${details || 'No details'}` });
+    }
+    return lines;
+}
+/**
+ * Iterate an assistant turn's image MessageBlocks and dispatch each through
+ * the channel's `sendImage` capability. No-op when the channel doesn't claim
+ * `sendImage`. Errors per image are logged but don't block the rest of the
+ * dispatch — the text reply path is responsible for the user-visible summary.
+ *
+ * Returns the list of `{messageId, caption}` entries so the caller can register
+ * them with the session for "reply to continue" linkage.
+ */
+export async function dispatchImageBlocks(channel, blocks, opts) {
+    if (!blocks?.length)
+        return [];
+    if (!supportsChannelCapability(channel, 'sendImage'))
+        return [];
+    const out = [];
+    let index = 0;
+    for (const block of blocks) {
+        if (block.type !== 'image')
+            continue;
+        index++;
+        const materialized = materializeImage(block);
+        if (!materialized) {
+            (opts.log || agentLog)(`[image-dispatch] skipped block #${index}: could not materialize bytes`);
+            continue;
+        }
+        try {
+            const messageId = await channel.sendImage(opts.chatId, materialized.bytes, {
+                mime: materialized.mime,
+                caption: materialized.caption,
+                replyTo: opts.replyTo,
+                messageThreadId: opts.messageThreadId,
+            });
+            out.push({ messageId, caption: materialized.caption });
+        }
+        catch (err) {
+            (opts.log || agentWarn)(`[image-dispatch] send failed #${index}: ${err?.message || err}`);
+        }
+    }
+    return out;
+}
+export function extractFinalReplyData(agent, result) {
+    const footerStatus = result.incomplete || !result.ok ? 'failed' : 'done';
+    const elapsedMs = result.elapsedS * 1000;
+    let activityNarrative = null;
+    let activityCommandSummary = null;
+    if (result.activity) {
+        const summary = parseActivitySummary(result.activity);
+        const narrative = summary.narrative.join('\n');
+        if (narrative) {
+            activityNarrative = narrative.length > 1600 ? '...\n' + narrative.slice(-1600) : narrative;
+        }
+        const cmdSummary = formatActivityCommandSummary(summary.completedCommands, summary.activeCommands, summary.failedCommands);
+        if (cmdSummary)
+            activityCommandSummary = cmdSummary;
+    }
+    let thinkingDisplay = null;
+    if (result.thinking) {
+        thinkingDisplay = formatThinkingForDisplay(result.thinking, 1600);
+    }
+    let statusLines = null;
+    if (result.incomplete) {
+        statusLines = [];
+        if (result.stopReason === 'max_tokens')
+            statusLines.push('Output limit reached. Response may be truncated.');
+        if (result.stopReason === 'timeout') {
+            statusLines.push(`Timed out after ${fmtUptime(Math.max(0, Math.round(elapsedMs)))} before the agent reported completion.`);
+        }
+        if (!result.ok) {
+            const detail = result.error?.trim();
+            if (detail && detail !== result.message.trim() && !statusLines.includes(detail))
+                statusLines.push(detail);
+            else if (result.stopReason !== 'timeout')
+                statusLines.push('Agent exited before reporting completion.');
+        }
+    }
+    return {
+        footerStatus,
+        activityNarrative,
+        activityCommandSummary,
+        thinkingDisplay,
+        thinkLabel: thinkLabel(agent),
+        statusLines,
+        bodyMessage: result.message,
+        elapsedMs,
+    };
+}
+/**
+ * Build the sub-agent block for the streaming preview. Sub-agents are
+ * deliberately isolated from parent activity (their tool list lives on each
+ * StreamSubAgent record), so we render a separate compact section showing each
+ * sub-agent's purpose + latest tool. Completed sub-agents are hidden — the
+ * parent's activity already reflects the Task `done` line.
+ */
+function renderSubAgentsForPreview(meta) {
+    const subs = meta?.subAgents;
+    if (!subs?.length)
+        return '';
+    const lines = [];
+    for (const sub of subs) {
+        if (sub.status !== 'running')
+            continue;
+        const label = (sub.description || sub.kind || 'sub-agent').trim().slice(0, 80);
+        const lastTool = sub.tools.length ? sub.tools[sub.tools.length - 1].summary : 'starting…';
+        const modelTag = sub.model ? ` · ${sub.model}` : '';
+        lines.push(`↳ ${label}${modelTag}`);
+        lines.push(`  · ${lastTool}`);
+    }
+    return lines.join('\n');
+}
+export function extractStreamPreviewData(input) {
+    const maxBody = 2400;
+    const display = input.bodyText.trim();
+    const rawThinking = input.thinking.trim();
+    const thinkDisplay = formatThinkingForDisplay(input.thinking, maxBody);
+    const planDisplay = renderPlanForPreview(input.plan ?? null);
+    const activityDisplay = summarizeActivityForPreview(input.activity);
+    const subAgentsDisplay = renderSubAgentsForPreview(input.meta);
+    const maxActivity = !display && !thinkDisplay && !planDisplay ? 2400 : 1400;
+    const label = thinkLabel(input.agent);
+    const thinkSnippet = rawThinking ? formatThinkingForDisplay(input.thinking, 600) : '';
+    const preview = display.length > maxBody ? '(...truncated)\n' + display.slice(-maxBody) : display;
+    // Elapsed time is the only monotonic progress signal available during the
+    // thinking phase (see thinkingProgressText). Hidden in the first second so a
+    // freshly-opened card doesn't flash "0s".
+    const elapsedMs = Math.max(0, input.elapsedMs);
+    const thinkingProgressText = elapsedMs >= 1000 ? fmtCompactUptime(elapsedMs) : null;
+    return {
+        display,
+        rawThinking,
+        thinkDisplay,
+        planDisplay,
+        activityDisplay,
+        subAgentsDisplay,
+        maxActivity,
+        label,
+        thinkSnippet,
+        preview,
+        thinkingProgressText,
+    };
+}

package/dist/bot/session-hub.js

@@ -0,0 +1,361 @@
+/**
+ * session-hub.ts — Unified session management service.
+ *
+ * THE canonical interface for all session operations across pikiloop.
+ * Upper-layer code (bot, dashboard, CLI) should import session functions
+ * from here, not from code-agent.ts directly.
+ *
+ * Responsibilities:
+ *   - Cross-agent / workspace-scoped session queries
+ *   - Session metadata management (status, notes, links, classification)
+ *   - Migration, export/import orchestration
+ *   - Workspace registry (delegates to user-config)
+ */
+import path from 'node:path';
+import { getSessions as _getSessions, getSessionTail as _getSessionTail, getSessionMessages as _getSessionMessages, classifySession as _classifySession, deriveUserStatus as _deriveStatusFromOutcome, exportSession as _exportSession, importSession as _importSession, findPikiloopSession, updateSessionMeta, deleteAgentSession as _deleteAgentSession, collapseSkillPrompt, } from '../agent/index.js';
+import { allDriverIds, hasDriver } from '../agent/driver.js';
+import { loadWorkspaces, addWorkspace, removeWorkspace, renameWorkspace, reorderWorkspaces, updateWorkspace, findWorkspace, } from '../core/config/user-config.js';
+// ---------------------------------------------------------------------------
+// Resolve user status
+// ---------------------------------------------------------------------------
+/**
+ * Compute the effective user status for a session.
+ * Priority: explicit userStatus > derived from classification > inbox.
+ */
+export function resolveUserStatus(session) {
+    if (session.userStatus)
+        return session.userStatus;
+    if (session.classification)
+        return _deriveStatusFromOutcome(session.classification.outcome);
+    return 'inbox';
+}
+// ---------------------------------------------------------------------------
+// Unified session query
+// ---------------------------------------------------------------------------
+function normalizeAgents(agent) {
+    if (!agent)
+        return allDriverIds().filter(a => hasDriver(a));
+    const list = Array.isArray(agent) ? agent : [agent];
+    return list.filter(a => hasDriver(a));
+}
+/**
+ * Query sessions — the single entry point for all session listing.
+ *
+ * Handles single-agent, multi-agent, and all-agent queries with optional
+ * status filtering and limits. Returns workspace-enriched results.
+ */
+export async function querySessions(opts) {
+    const resolvedWorkdir = path.resolve(opts.workdir);
+    const ws = findWorkspace(resolvedWorkdir);
+    const workspaceName = ws?.name || path.basename(resolvedWorkdir);
+    const agents = normalizeAgents(opts.agent);
+    const results = await Promise.all(agents.map(agent => _getSessions({ agent, workdir: resolvedWorkdir }).catch(() => ({
+        ok: false, sessions: [], error: `Failed to fetch ${agent} sessions`,
+    }))));
+    let allSessions = [];
+    const errors = [];
+    let anyOk = false;
+    for (const result of results) {
+        if (result.ok)
+            anyOk = true;
+        if (result.error)
+            errors.push(result.error);
+        for (const session of result.sessions) {
+            allSessions.push({ ...session, workspaceName });
+        }
+    }
+    // Sort by most recent activity
+    allSessions.sort((a, b) => {
+        const aTime = a.runUpdatedAt || a.createdAt || '';
+        const bTime = b.runUpdatedAt || b.createdAt || '';
+        return Date.parse(bTime) - Date.parse(aTime);
+    });
+    // Filter by userStatus
+    if (opts.userStatus?.length) {
+        const allowed = new Set(opts.userStatus);
+        allSessions = allSessions.filter(s => allowed.has(resolveUserStatus(s)));
+    }
+    // Apply limit
+    if (opts.limit && opts.limit > 0) {
+        allSessions = allSessions.slice(0, opts.limit);
+    }
+    // Count statuses
+    const statusCounts = { inbox: 0, active: 0, review: 0, done: 0, parked: 0, unknown: 0 };
+    for (const s of allSessions) {
+        const status = resolveUserStatus(s);
+        statusCounts[status] = (statusCounts[status] || 0) + 1;
+    }
+    return {
+        ok: anyOk || agents.length === 0,
+        workdir: resolvedWorkdir,
+        workspaceName,
+        sessions: allSessions,
+        statusCounts: statusCounts,
+        total: allSessions.length,
+        errors,
+    };
+}
+// ---------------------------------------------------------------------------
+// Session detail queries
+// ---------------------------------------------------------------------------
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
+const MIME_BY_EXT = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp', '.svg': 'image/svg+xml',
+};
+/** Build image MessageBlocks from a session record's `lastUserAttachments`
+ *  (relative paths under `workspacePath`). Used by fallback paths so the
+ *  dashboard can still render the user's image bubble while the agent CLI
+ *  has not yet flushed the turn to its own session file. Non-image
+ *  attachments are skipped — the fallback is text-first and doesn't try to
+ *  reconstruct generic file references. */
+function imageBlocksFromManagedRecord(record) {
+    const attachments = record.lastUserAttachments;
+    if (!attachments?.length)
+        return [];
+    const blocks = [];
+    for (const rel of attachments) {
+        const ext = path.extname(rel).toLowerCase();
+        if (!IMAGE_EXTENSIONS.has(ext))
+            continue;
+        const abs = path.isAbsolute(rel) ? rel : path.join(record.workspacePath, rel);
+        blocks.push({
+            type: 'image',
+            // `file://` sentinel — `rewriteImageBlocksForTransport` (dashboard
+            // response layer) converts it to a proper /attachment URL.
+            content: `file://${abs}`,
+            imagePath: abs,
+            imageMime: MIME_BY_EXT[ext] || 'application/octet-stream',
+        });
+    }
+    return blocks;
+}
+function tailFallbackFromManagedRecord(opts) {
+    const fb = managedFallbackContent(opts);
+    if (!fb)
+        return null;
+    const limit = Math.max(1, opts.limit ?? fb.messages.length);
+    return { ok: true, messages: fb.messages.slice(-limit), error: null };
+}
+function managedFallbackContent(opts) {
+    const record = findPikiloopSession(opts.workdir, opts.agent, opts.sessionId);
+    if (!record)
+        return null;
+    const messages = [];
+    const richMessages = [];
+    if (record.lastQuestion) {
+        const text = record.lastQuestion;
+        messages.push({ role: 'user', text });
+        const blocks = text ? [{ type: 'text', content: text }] : [];
+        blocks.push(...imageBlocksFromManagedRecord(record));
+        if (blocks.length)
+            richMessages.push({ role: 'user', text, blocks, usage: null });
+    }
+    const failureText = record.lastAnswer
+        || (record.runState === 'incomplete' ? record.runDetail : null);
+    if (failureText) {
+        messages.push({ role: 'assistant', text: failureText });
+        richMessages.push({
+            role: 'assistant',
+            text: failureText,
+            blocks: [{ type: 'text', content: failureText }],
+            usage: null,
+        });
+    }
+    if (!messages.length)
+        return null;
+    return { messages, richMessages };
+}
+/** Get recent messages from a session (tail). */
+export async function querySessionTail(opts) {
+    const result = await _getSessionTail(opts);
+    if (!result.ok || !result.messages.length) {
+        const fallback = tailFallbackFromManagedRecord(opts);
+        if (fallback)
+            return fallback;
+    }
+    return result;
+}
+/**
+ * Replace canonical skill-execution expansions in a user message with the
+ * `/skillname` shorthand the user originally typed. The expanded text is what
+ * the agent CLI consumed and persisted; we collapse on read so the dashboard
+ * chat shows the slash command instead of the long instruction we synthesized
+ * for dispatch. Non-user messages and non-skill prompts pass through unchanged.
+ */
+function collapseSkillPromptsInResult(result) {
+    if (!result.ok)
+        return result;
+    const messages = result.messages.map(m => {
+        if (m.role !== 'user')
+            return m;
+        const collapsed = collapseSkillPrompt(m.text);
+        return collapsed ? { ...m, text: collapsed } : m;
+    });
+    const richMessages = result.richMessages?.map(m => {
+        if (m.role !== 'user')
+            return m;
+        const collapsed = collapseSkillPrompt(m.text);
+        if (!collapsed)
+            return m;
+        // The user's text content lives in one or more `text` blocks; collapse any
+        // whose individual content also matches the expansion. Non-text blocks
+        // (images, attachments) pass through untouched.
+        const blocks = m.blocks.map(b => {
+            if (b.type !== 'text')
+                return b;
+            const blockCollapsed = collapseSkillPrompt(b.content);
+            return blockCollapsed ? { ...b, content: blockCollapsed } : b;
+        });
+        return { ...m, text: collapsed, blocks };
+    });
+    return { ...result, messages, richMessages };
+}
+/** Get full session messages (with optional turn filtering). */
+export async function querySessionMessages(opts) {
+    const result = await _getSessionMessages(opts);
+    if (!result.ok || !result.messages.length) {
+        const fb = managedFallbackContent({
+            agent: opts.agent,
+            sessionId: opts.sessionId,
+            workdir: opts.workdir,
+        });
+        if (fb) {
+            const totalTurns = fb.messages.filter(m => m.role === 'user').length;
+            return collapseSkillPromptsInResult({
+                ok: true,
+                messages: fb.messages.map(m => ({ role: m.role, text: m.text })),
+                // Always emit richMessages so the dashboard can render image blocks
+                // for the first user turn while the agent CLI is still spinning up.
+                richMessages: fb.richMessages,
+                totalTurns,
+                error: null,
+            });
+        }
+    }
+    return collapseSkillPromptsInResult(result);
+}
+// ---------------------------------------------------------------------------
+// Workspace overviews
+// ---------------------------------------------------------------------------
+/** Overview of all registered workspaces — designed for dashboard sidebar. */
+export async function getWorkspaceOverviews() {
+    const workspaces = loadWorkspaces();
+    const agents = allDriverIds().filter(a => hasDriver(a));
+    return Promise.all(workspaces.map(async (ws) => {
+        // Fan the agents out in parallel — each _getSessions is independent I/O, and
+        // running them serially made one slow agent stall the whole workspace card.
+        const summaries = await Promise.all(agents.map(async (agent) => {
+            try {
+                const result = await _getSessions({ agent, workdir: ws.path });
+                let active = 0;
+                let review = 0;
+                let lastTs = null;
+                for (const session of result.sessions) {
+                    const status = resolveUserStatus(session);
+                    if (status === 'active' || session.running)
+                        active++;
+                    else if (status === 'review')
+                        review++;
+                    const ts = session.runUpdatedAt || session.createdAt || '';
+                    if (ts && (!lastTs || ts > lastTs))
+                        lastTs = ts;
+                }
+                return { agent, active, review, total: result.sessions.length, lastTs };
+            }
+            catch {
+                return { agent, active: 0, review: 0, total: 0, lastTs: null };
+            }
+        }));
+        const agentSummary = [];
+        let attentionCount = 0;
+        let lastActivityAt = null;
+        for (const s of summaries) {
+            agentSummary.push({ agent: s.agent, active: s.active, review: s.review, total: s.total });
+            attentionCount += s.active + s.review;
+            if (s.lastTs && (!lastActivityAt || s.lastTs > lastActivityAt))
+                lastActivityAt = s.lastTs;
+        }
+        return { workspace: ws, attentionCount, agentSummary, lastActivityAt };
+    }));
+}
+// ---------------------------------------------------------------------------
+// Session metadata
+// ---------------------------------------------------------------------------
+/** Update session metadata (status, note, classification, migration links). */
+export function updateSession(workdir, agent, sessionId, patch) {
+    return updateSessionMeta(workdir, agent, sessionId, patch);
+}
+/**
+ * Delete a session. Re-exports the agent-layer primitive so dashboard routes
+ * stay in the bot/ layer for layering consistency. See
+ * {@link DeleteAgentSessionOpts}.
+ */
+export function deleteSession(opts) {
+    return _deleteAgentSession(opts);
+}
+/** Link two sessions together (bidirectional). */
+export function linkSessions(workdir, a, b) {
+    const updatedA = updateSessionMeta(workdir, a.agent, a.sessionId, {
+        addLink: { agent: b.agent, sessionId: b.sessionId },
+    });
+    const updatedB = updateSessionMeta(workdir, b.agent, b.sessionId, {
+        addLink: { agent: a.agent, sessionId: a.sessionId },
+    });
+    return updatedA || updatedB;
+}
+// ---------------------------------------------------------------------------
+// Classification
+// ---------------------------------------------------------------------------
+/** Auto-classify a session based on stream result. */
+export function classifySession(result) {
+    return _classifySession(result);
+}
+// ---------------------------------------------------------------------------
+// Export / Import / Migration
+// ---------------------------------------------------------------------------
+export function exportSession(opts) {
+    return _exportSession(opts);
+}
+export function importSession(opts) {
+    return _importSession(opts);
+}
+/** Build migration context from source session for injection into target agent. */
+export async function buildMigrationContext(opts) {
+    try {
+        const messagesResult = await _getSessionMessages({
+            agent: opts.source.agent,
+            sessionId: opts.source.sessionId,
+            workdir: opts.source.workdir,
+            lastNTurns: opts.lastNTurns,
+        });
+        if (!messagesResult.ok) {
+            return { ok: false, contextInjected: '', messageCount: 0, error: messagesResult.error };
+        }
+        const messages = messagesResult.messages;
+        if (!messages.length) {
+            return { ok: false, contextInjected: '', messageCount: 0, error: 'No messages to migrate' };
+        }
+        const contextLines = [
+            `[Migrated from ${opts.source.agent} session, ${messages.length} messages]`,
+            '',
+        ];
+        for (const msg of messages) {
+            contextLines.push(`[${msg.role === 'user' ? 'User' : 'Assistant'}]:`);
+            contextLines.push(msg.text);
+            contextLines.push('');
+        }
+        const contextInjected = contextLines.join('\n');
+        updateSessionMeta(opts.source.workdir, opts.source.agent, opts.source.sessionId, {
+            migratedTo: { agent: opts.target.agent, sessionId: '' },
+        });
+        return { ok: true, contextInjected, messageCount: messages.length, error: null };
+    }
+    catch (e) {
+        return { ok: false, contextInjected: '', messageCount: 0, error: e.message };
+    }
+}
+// ---------------------------------------------------------------------------
+// Workspace registry (delegates to user-config)
+// ---------------------------------------------------------------------------
+export { loadWorkspaces, addWorkspace, removeWorkspace, renameWorkspace, reorderWorkspaces, updateWorkspace, findWorkspace };