pilotswarm 0.0.1 → 0.4.1

package/tui/src/plugin-config.js

@@ -0,0 +1,273 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, "..");
+const defaultTuiSplashPath = path.join(pkgRoot, "tui-splash.txt");
+const defaultTuiSplashMobilePath = path.join(pkgRoot, "tui-splash-mobile.txt");
+
+function fileExists(filePath) {
+    try {
+        return fs.existsSync(filePath);
+    } catch {
+        return false;
+    }
+}
+
+function readOptionalTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8").trimEnd();
+    } catch {
+        return null;
+    }
+}
+
+function getObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+
+function resolveRelativePath(baseDir, relativePath) {
+    if (!baseDir || typeof relativePath !== "string" || !relativePath.trim()) return null;
+    const basePath = path.resolve(baseDir);
+    const filePath = path.resolve(basePath, relativePath);
+    if (filePath !== basePath && !filePath.startsWith(`${basePath}${path.sep}`)) {
+        return null;
+    }
+    return filePath;
+}
+
+function readRelativeTextFile(baseDir, relativePath) {
+    const filePath = resolveRelativePath(baseDir, relativePath);
+    if (!filePath) return null;
+    return readOptionalTextFile(filePath);
+}
+
+function resolveRelativeAssetFile(baseDir, relativePath) {
+    const filePath = resolveRelativePath(baseDir, relativePath);
+    if (!filePath || !fileExists(filePath)) return null;
+    return filePath;
+}
+
+function firstAssetUrl(...values) {
+    for (const value of values) {
+        if (typeof value !== "string" || !value.trim()) continue;
+        const trimmed = value.trim();
+        if (/^(https?:\/\/|\/|data:|blob:)/iu.test(trimmed)) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+
+function resolvePortalAsset(baseDir, { file, url }) {
+    const directUrl = firstAssetUrl(url);
+    if (directUrl) {
+        return { filePath: null, publicUrl: directUrl };
+    }
+    const filePath = resolveRelativeAssetFile(baseDir, file);
+    if (!filePath) {
+        return { filePath: null, publicUrl: null };
+    }
+    return { filePath, publicUrl: null };
+}
+
+function readSplashValue(baseDir, config, fallback) {
+    if (typeof config?.splash === "string" && config.splash.trim()) {
+        return config.splash;
+    }
+    if (typeof config?.splashFile === "string" && config.splashFile.trim()) {
+        const fileText = readRelativeTextFile(baseDir, config.splashFile);
+        if (fileText != null) return fileText;
+    }
+    return fallback;
+}
+
+// Narrow-viewport splash variant (splashMobile / splashMobileFile). No
+// default art: null means "wrap the main splash when it does not fit".
+function readSplashMobileValue(baseDir, config, fallback = null) {
+    if (typeof config?.splashMobile === "string" && config.splashMobile.trim()) {
+        return config.splashMobile;
+    }
+    if (typeof config?.splashMobileFile === "string" && config.splashMobileFile.trim()) {
+        const fileText = readRelativeTextFile(baseDir, config.splashMobileFile);
+        if (fileText != null) return fileText;
+    }
+    return fallback;
+}
+
+function getDefaultSplash() {
+    return readOptionalTextFile(defaultTuiSplashPath) || "{bold}{cyan-fg}PilotSwarm{/cyan-fg}{/bold}";
+}
+
+function getDefaultSplashMobile() {
+    return readOptionalTextFile(defaultTuiSplashMobilePath) || null;
+}
+
+export function readPluginMetadata(pluginDir) {
+    if (!pluginDir) return null;
+    const pluginJsonPath = path.join(pluginDir, "plugin.json");
+    if (!fileExists(pluginJsonPath)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(pluginJsonPath, "utf-8"));
+    } catch (error) {
+        throw new Error(`Failed to parse plugin metadata: ${pluginJsonPath}: ${error.message}`);
+    }
+}
+
+export function getPluginDirsFromEnv() {
+    const envDirs = String(process.env.PLUGIN_DIRS || "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => path.resolve(value));
+    if (envDirs.length > 0) return envDirs;
+
+    const cwdPlugin = path.resolve(process.cwd(), "plugins");
+    if (fileExists(cwdPlugin)) return [cwdPlugin];
+
+    const bundledPlugin = path.join(pkgRoot, "plugins");
+    if (fileExists(bundledPlugin)) return [bundledPlugin];
+
+    return [];
+}
+
+export function resolveTuiBranding(pluginDir) {
+    const pluginMeta = readPluginMetadata(pluginDir);
+    const tui = pluginMeta?.tui;
+    const defaultSplash = getDefaultSplash();
+    if (!tui || typeof tui !== "object") {
+        const defaultMobile = getDefaultSplashMobile();
+        return { title: "PilotSwarm", splash: defaultSplash, ...(defaultMobile ? { splashMobile: defaultMobile } : {}) };
+    }
+
+    const title = firstNonEmptyString(tui.title, "PilotSwarm") || "PilotSwarm";
+    const splash = readSplashValue(pluginDir, tui, defaultSplash);
+    // The default mobile art only pairs with the default splash — an app that
+    // ships its own splash without a mobile variant wraps instead of showing
+    // PilotSwarm-branded art.
+    const splashMobile = readSplashMobileValue(pluginDir, tui, splash === defaultSplash ? getDefaultSplashMobile() : null);
+    return { title, splash, ...(splashMobile ? { splashMobile } : {}) };
+}
+
+export function resolvePortalConfigBundleFromPluginDirs(pluginDirs = []) {
+    const defaultSplash = getDefaultSplash();
+    const defaults = {
+        branding: {
+            title: "PilotSwarm",
+            pageTitle: "PilotSwarm",
+            splash: defaultSplash,
+            splashMobile: getDefaultSplashMobile(),
+            logoUrl: null,
+            faviconUrl: null,
+        },
+        ui: {
+            loadingMessage: "Preparing your workspace",
+            loadingCopy: "Connecting the shared workspace and live session feeds...",
+        },
+        auth: {
+            provider: null,
+            providers: {},
+            signInTitle: "Sign in to PilotSwarm",
+            signInMessage: null,
+            signInLabel: "Sign In",
+        },
+    };
+
+    for (const pluginDir of pluginDirs) {
+        const absDir = path.resolve(pluginDir);
+        const pluginMeta = readPluginMetadata(absDir);
+        if (!pluginMeta) continue;
+
+        const portal = getObject(pluginMeta?.portal);
+        const portalBranding = getObject(portal.branding);
+        const portalUi = getObject(portal.ui);
+        const portalAuth = getObject(portal.auth);
+        const tui = getObject(pluginMeta?.tui);
+
+        const title = firstNonEmptyString(portalBranding.title, portal.title, tui.title, defaults.branding.title) || defaults.branding.title;
+        const pageTitle = firstNonEmptyString(portalBranding.pageTitle, portal.pageTitle, title, defaults.branding.pageTitle) || defaults.branding.pageTitle;
+        const splash = readSplashValue(
+            absDir,
+            portalBranding,
+            readSplashValue(absDir, portal, readSplashValue(absDir, tui, defaults.branding.splash)),
+        );
+        const splashMobile = readSplashMobileValue(
+            absDir,
+            portalBranding,
+            readSplashMobileValue(
+                absDir,
+                portal,
+                readSplashMobileValue(absDir, tui, splash === defaultSplash ? getDefaultSplashMobile() : null),
+            ),
+        );
+        const logoAsset = resolvePortalAsset(absDir, {
+            file: firstNonEmptyString(portalBranding.logoFile, portal.logoFile),
+            url: firstNonEmptyString(portalBranding.logoUrl, portal.logoUrl),
+        });
+        const faviconAsset = resolvePortalAsset(absDir, {
+            file: firstNonEmptyString(portalBranding.faviconFile, portal.faviconFile, portalBranding.logoFile, portal.logoFile),
+            url: firstNonEmptyString(portalBranding.faviconUrl, portal.faviconUrl, portalBranding.logoUrl, portal.logoUrl),
+        });
+
+        const assetFiles = {};
+        const branding = {
+            title,
+            pageTitle,
+            splash,
+            splashMobile: splashMobile || null,
+            logoUrl: logoAsset.publicUrl || null,
+            faviconUrl: faviconAsset.publicUrl || null,
+        };
+
+        if (logoAsset.filePath) {
+            assetFiles.logo = logoAsset.filePath;
+            branding.logoUrl = "/api/portal-assets/logo";
+        }
+        if (faviconAsset.filePath) {
+            assetFiles.favicon = faviconAsset.filePath;
+            branding.faviconUrl = "/api/portal-assets/favicon";
+        }
+        if (!branding.faviconUrl && branding.logoUrl) {
+            branding.faviconUrl = branding.logoUrl;
+        }
+
+        return {
+            portalConfig: {
+                branding,
+                ui: {
+                    loadingMessage: firstNonEmptyString(portalUi.loadingMessage, portal.loadingMessage, defaults.ui.loadingMessage) || defaults.ui.loadingMessage,
+                    loadingCopy: firstNonEmptyString(portalUi.loadingCopy, portal.loadingCopy, defaults.ui.loadingCopy) || defaults.ui.loadingCopy,
+                },
+                auth: {
+                    provider: firstNonEmptyString(portalAuth.provider, portal.provider),
+                    providers: getObject(portalAuth.providers),
+                    signInTitle: firstNonEmptyString(portalAuth.signInTitle, portal.signInTitle, `Sign in to ${title}`) || `Sign in to ${title}`,
+                    signInMessage: firstNonEmptyString(portalAuth.signInMessage, portal.signInMessage, defaults.auth.signInMessage),
+                    signInLabel: firstNonEmptyString(portalAuth.signInLabel, defaults.auth.signInLabel) || defaults.auth.signInLabel,
+                },
+            },
+            assetFiles,
+        };
+    }
+
+    return {
+        portalConfig: defaults,
+        assetFiles: {},
+    };
+}
+
+export function resolvePortalConfigFromPluginDirs(pluginDirs = []) {
+    return resolvePortalConfigBundleFromPluginDirs(pluginDirs).portalConfig;
+}

package/tui/src/portal.js

@@ -0,0 +1,7 @@
+export { NodeSdkTransport } from "./node-sdk-transport.js";
+export {
+    getPluginDirsFromEnv,
+    readPluginMetadata,
+    resolvePortalConfigBundleFromPluginDirs,
+    resolvePortalConfigFromPluginDirs,
+} from "./plugin-config.js";

package/tui/src/version.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const cliPackageJson = require("../../package.json");
+
+export const PILOTSWARM_CLI_VERSION = String(cliPackageJson?.version || "0.0.0");
+export const PILOTSWARM_CLI_VERSION_LABEL = `v${PILOTSWARM_CLI_VERSION}`;

package/tui/tui-splash-mobile.txt

@@ -0,0 +1,7 @@
+{bold}{cyan-fg}█▀█ █ █   █▀█ ▀█▀{/cyan-fg} {magenta-fg}█▀ █ █ █ ▄▀█ █▀█ █▀▄▀█{/magenta-fg}{/bold}
+{bold}{cyan-fg}█▀▀ █ █▄▄ █▄█  █ {/cyan-fg} {magenta-fg}▄█ ▀▄▀▄▀ █▀█ █▀▄ █ ▀ █{/magenta-fg}{/bold}
+{yellow-fg}░▒▓██████████████████████████████████▓▒░{/yellow-fg}
+ {bold}{white-fg}Durable AI Agent Orchestration{/white-fg}{/bold}
+ {cyan-fg}Crash recovery{/cyan-fg} · {magenta-fg}Durable timers{/magenta-fg}
+ {yellow-fg}Sub-agents{/yellow-fg} · {green-fg}Multi-node scaling{/green-fg}
+ {gray-fg}Powered by duroxide + Copilot SDK{/gray-fg}

package/tui/tui-splash.txt

@@ -0,0 +1,11 @@
+{bold}{cyan-fg}
+    ____  _ __      __  _____                              
+   / __ \(_) /___  / /_/ ___/      ______ __________ ___  
+{/cyan-fg}{magenta-fg}  / /_/ / / / __ \/ __/\__ \ | /| / / __ `/ ___/ __ `__ \
+ / ____/ / / /_/ / /_ ___/ / |/ |/ / /_/ / /  / / / / / /{/magenta-fg}
+{yellow-fg}/_/   /_/_/\____/\__//____/|__/|__/\__,_/_/  /_/ /_/ /_/ {/yellow-fg}
+{/bold}
+
+  {bold}{white-fg}Durable AI Agent Orchestration{/white-fg}{/bold}
+  {cyan-fg}Crash recovery{/cyan-fg} · {magenta-fg}Durable timers{/magenta-fg} · {yellow-fg}Sub-agents{/yellow-fg} · {green-fg}Multi-node scaling{/green-fg}
+  {gray-fg}Powered by duroxide + GitHub Copilot SDK{/gray-fg}

package/ui/core/README.md

@@ -0,0 +1,6 @@
+# pilotswarm/ui-core (internal)
+
+Framework-free shared UI state, selectors, commands, and controller logic for
+PilotSwarm hosts.
+
+This package is used by both the TUI and web portal host layers.

package/ui/core/src/commands.js

@@ -0,0 +1,93 @@
+export const FOCUS_REGIONS = {
+    SESSIONS: "sessions",
+    CHAT: "chat",
+    INSPECTOR: "inspector",
+    ACTIVITY: "activity",
+    PROMPT: "prompt",
+    ADMIN: "admin",
+};
+
+export const INSPECTOR_TABS = ["sequence", "logs", "nodes", "history", "files", "stats"];
+
+export const UI_COMMANDS = {
+    REFRESH: "refresh",
+    NEW_SESSION: "newSession",
+    OPEN_MODEL_PICKER: "openModelPicker",
+    OPEN_THEME_PICKER: "openThemePicker",
+    OPEN_RENAME_SESSION: "openRenameSession",
+    OPEN_SESSION_FILTER: "openSessionFilter",
+    OPEN_TERMINATE_PICKER: "openTerminatePicker",
+    OPEN_MOVE_TO_GROUP: "openMoveToGroup",
+    CREATE_SESSION_GROUP: "createSessionGroup",
+    OPEN_ARTIFACT_UPLOAD: "openArtifactUpload",
+    TOGGLE_CHAT_VIEW: "toggleChatView",
+    CLOSE_MODAL: "closeModal",
+    MODAL_PREV: "modalPrev",
+    MODAL_NEXT: "modalNext",
+    MODAL_PANE_PREV: "modalPanePrev",
+    MODAL_PANE_NEXT: "modalPaneNext",
+    MODAL_CONFIRM: "modalConfirm",
+    SEND_PROMPT: "sendPrompt",
+    FOCUS_NEXT: "focusNext",
+    FOCUS_PREV: "focusPrev",
+    FOCUS_LEFT: "focusLeft",
+    FOCUS_RIGHT: "focusRight",
+    FOCUS_PROMPT: "focusPrompt",
+    FOCUS_SESSIONS: "focusSessions",
+    MOVE_SESSION_UP: "moveSessionUp",
+    MOVE_SESSION_DOWN: "moveSessionDown",
+    EXPAND_SESSION: "expandSession",
+    COLLAPSE_SESSION: "collapseSession",
+    NEXT_INSPECTOR_TAB: "nextInspectorTab",
+    PREV_INSPECTOR_TAB: "prevInspectorTab",
+    CYCLE_INSPECTOR_TAB: "cycleInspectorTab",
+    GROW_LEFT_PANE: "growLeftPane",
+    GROW_RIGHT_PANE: "growRightPane",
+    GROW_SESSION_PANE: "growSessionPane",
+    SHRINK_SESSION_PANE: "shrinkSessionPane",
+    OPEN_ARTIFACT_PICKER: "openArtifactPicker",
+    TOGGLE_LOG_TAIL: "toggleLogTail",
+    TOGGLE_STATS_VIEW: "toggleStatsView",
+    OPEN_LOG_FILTER: "openLogFilter",
+    OPEN_FILES_FILTER: "openFilesFilter",
+    MOVE_FILE_UP: "moveFileUp",
+    MOVE_FILE_DOWN: "moveFileDown",
+    DOWNLOAD_SELECTED_FILE: "downloadSelectedFile",
+    DELETE_SELECTED_FILE: "deleteSelectedFile",
+    OPEN_SELECTED_FILE: "openSelectedFile",
+    TOGGLE_FILE_PREVIEW_FULLSCREEN: "toggleFilePreviewFullscreen",
+    TOGGLE_PANE_FULLSCREEN: "togglePaneFullscreen",
+    SCROLL_UP: "scrollUp",
+    SCROLL_DOWN: "scrollDown",
+    PAGE_UP: "pageUp",
+    PAGE_DOWN: "pageDown",
+    EXPAND_HISTORY: "expandHistory",
+    SCROLL_TOP: "scrollTop",
+    SCROLL_BOTTOM: "scrollBottom",
+    DONE_SESSION: "doneSession",
+    CANCEL_SESSION: "cancelSession",
+    STOP_TURN: "stopTurn",
+    DELETE_SESSION: "deleteSession",
+    PIN_SESSION: "pinSession",
+    TOGGLE_SELECT_MODE: "toggleSelectMode",
+    TOGGLE_SESSION_SELECTION: "toggleSessionSelection",
+    CLEAR_SESSION_SELECTION: "clearSessionSelection",
+    OPEN_HISTORY_FORMAT: "openHistoryFormat",
+    REFRESH_EXECUTION_HISTORY: "refreshExecutionHistory",
+    EXPORT_EXECUTION_HISTORY: "exportExecutionHistory",
+    // Admin Console — swaps out sessions+chat for the per-user admin view.
+    OPEN_ADMIN_CONSOLE: "openAdminConsole",
+    CLOSE_ADMIN_CONSOLE: "closeAdminConsole",
+    ADMIN_REFRESH_PROFILE: "adminRefreshProfile",
+    ADMIN_BEGIN_EDIT_GHCP_KEY: "adminBeginEditGhcpKey",
+    ADMIN_CANCEL_EDIT_GHCP_KEY: "adminCancelEditGhcpKey",
+    ADMIN_SAVE_GHCP_KEY: "adminSaveGhcpKey",
+    ADMIN_CLEAR_GHCP_KEY: "adminClearGhcpKey",
+};
+
+export function cycleValue(values, current, delta) {
+    const index = values.indexOf(current);
+    const safeIndex = index === -1 ? 0 : index;
+    const nextIndex = (safeIndex + delta + values.length) % values.length;
+    return values[nextIndex];
+}

package/ui/core/src/context-usage.js

@@ -0,0 +1,212 @@
+export function computeContextPercent(contextUsage) {
+    const utilization = typeof contextUsage?.utilization === "number"
+        ? contextUsage.utilization
+        : (typeof contextUsage?.tokenLimit === "number"
+            && contextUsage.tokenLimit > 0
+            && typeof contextUsage?.currentTokens === "number"
+            ? contextUsage.currentTokens / contextUsage.tokenLimit
+            : null);
+
+    if (typeof utilization !== "number" || !Number.isFinite(utilization)) return null;
+    return Math.max(0, Math.min(100, Math.round(utilization * 100)));
+}
+
+export function formatTokenCount(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return "?";
+    if (value >= 1_000_000) {
+        const compact = value >= 10_000_000
+            ? Math.round(value / 1_000_000)
+            : Math.round(value / 100_000) / 10;
+        return `${compact}`.replace(/\.0$/, "") + "m";
+    }
+    if (value >= 1_000) {
+        const compact = value >= 100_000
+            ? Math.round(value / 1_000)
+            : Math.round(value / 100) / 10;
+        return `${compact}`.replace(/\.0$/, "") + "k";
+    }
+    return String(Math.round(value));
+}
+
+export function getContextMeterColor(contextUsage) {
+    const percent = computeContextPercent(contextUsage);
+    if (percent == null) return "gray";
+    if (percent >= 85) return "red";
+    if (percent >= 70) return "yellow";
+    return "gray";
+}
+
+export function getContextHeaderBadge(contextUsage) {
+    if (!contextUsage) return null;
+    if (!(typeof contextUsage.tokenLimit === "number"
+        && contextUsage.tokenLimit > 0
+        && typeof contextUsage.currentTokens === "number"
+        && contextUsage.currentTokens >= 0)) {
+        return null;
+    }
+
+    const percent = computeContextPercent(contextUsage);
+    if (percent == null) return null;
+
+    return {
+        text: `ctx ${formatTokenCount(contextUsage.currentTokens)}/${formatTokenCount(contextUsage.tokenLimit)} ${percent}%`,
+        color: getContextMeterColor(contextUsage),
+    };
+}
+
+export function getContextListBadge(contextUsage) {
+    if (!contextUsage) return null;
+
+    const compaction = contextUsage.compaction;
+    if (compaction?.state === "running") {
+        return { text: "[compact]", color: "magenta" };
+    }
+    if (compaction?.state === "failed") {
+        return { text: "[compact !]", color: "red" };
+    }
+
+    const percent = computeContextPercent(contextUsage);
+    if (percent == null || percent < 70) return null;
+
+    return {
+        text: `[ctx ${percent}%]`,
+        color: percent >= 85 ? "red" : "yellow",
+    };
+}
+
+export function getContextCompactionBadge(contextUsage) {
+    const compaction = contextUsage?.compaction;
+    if (!compaction || typeof compaction !== "object") return null;
+
+    if (compaction.state === "running") {
+        return { text: "[compacting]", color: "magenta" };
+    }
+    if (compaction.state === "failed") {
+        return { text: "[compact failed]", color: "red" };
+    }
+    return null;
+}
+
+export function cloneContextUsageSnapshot(contextUsage) {
+    if (!contextUsage || typeof contextUsage !== "object") return null;
+    return {
+        ...contextUsage,
+        ...(contextUsage.compaction && typeof contextUsage.compaction === "object"
+            ? { compaction: { ...contextUsage.compaction } }
+            : {}),
+    };
+}
+
+function normalizeUsageTimestamp(value) {
+    if (value instanceof Date) return value.getTime();
+    const numeric = new Date(value).getTime();
+    return Number.isFinite(numeric) ? numeric : Date.now();
+}
+
+export function applySessionUsageEvent(contextUsage, eventType, data = {}, options = {}) {
+    if (!eventType) return null;
+    const current = cloneContextUsageSnapshot(contextUsage) || {};
+    const timestamp = normalizeUsageTimestamp(options.timestamp);
+
+    if (eventType === "session.usage_info") {
+        if (typeof data.tokenLimit !== "number"
+            || typeof data.currentTokens !== "number"
+            || typeof data.messagesLength !== "number") {
+            return null;
+        }
+        current.tokenLimit = data.tokenLimit;
+        current.currentTokens = data.currentTokens;
+        current.messagesLength = data.messagesLength;
+        current.utilization = data.tokenLimit > 0 ? data.currentTokens / data.tokenLimit : 0;
+        if (typeof data.systemTokens === "number") current.systemTokens = data.systemTokens;
+        if (typeof data.conversationTokens === "number") current.conversationTokens = data.conversationTokens;
+        if (typeof data.toolDefinitionsTokens === "number") current.toolDefinitionsTokens = data.toolDefinitionsTokens;
+        if (typeof data.isInitial === "boolean") current.isInitial = data.isInitial;
+        return current;
+    }
+
+    if (eventType === "assistant.usage") {
+        if (typeof data.inputTokens === "number") current.lastInputTokens = data.inputTokens;
+        if (typeof data.outputTokens === "number") current.lastOutputTokens = data.outputTokens;
+        if (typeof data.cacheReadTokens === "number") current.lastCacheReadTokens = data.cacheReadTokens;
+        if (typeof data.cacheWriteTokens === "number") current.lastCacheWriteTokens = data.cacheWriteTokens;
+        return current;
+    }
+
+    if (eventType === "session.compaction_start") {
+        current.compaction = {
+            ...(current.compaction || {}),
+            state: "running",
+            startedAt: timestamp,
+            completedAt: undefined,
+            error: undefined,
+        };
+        return current;
+    }
+
+    if (eventType === "session.compaction_complete") {
+        current.compaction = {
+            ...(current.compaction || {}),
+            state: data.success === false ? "failed" : "succeeded",
+            completedAt: timestamp,
+            error: typeof data.error === "string" ? data.error : undefined,
+            preCompactionTokens: typeof data.preCompactionTokens === "number" ? data.preCompactionTokens : undefined,
+            postCompactionTokens: typeof data.postCompactionTokens === "number" ? data.postCompactionTokens : undefined,
+            preCompactionMessagesLength: typeof data.preCompactionMessagesLength === "number" ? data.preCompactionMessagesLength : undefined,
+            messagesRemoved: typeof data.messagesRemoved === "number" ? data.messagesRemoved : undefined,
+            tokensRemoved: typeof data.tokensRemoved === "number" ? data.tokensRemoved : undefined,
+            systemTokens: typeof data.systemTokens === "number" ? data.systemTokens : undefined,
+            conversationTokens: typeof data.conversationTokens === "number" ? data.conversationTokens : undefined,
+            toolDefinitionsTokens: typeof data.toolDefinitionsTokens === "number" ? data.toolDefinitionsTokens : undefined,
+            inputTokens: typeof data.compactionTokensUsed?.input === "number" ? data.compactionTokensUsed.input : undefined,
+            outputTokens: typeof data.compactionTokensUsed?.output === "number" ? data.compactionTokensUsed.output : undefined,
+            cachedInputTokens: typeof data.compactionTokensUsed?.cachedInput === "number" ? data.compactionTokensUsed.cachedInput : undefined,
+        };
+
+        if (typeof data.postCompactionTokens === "number" && typeof current.tokenLimit === "number" && current.tokenLimit > 0) {
+            current.currentTokens = data.postCompactionTokens;
+            current.utilization = data.postCompactionTokens / current.tokenLimit;
+        }
+        if (typeof data.preCompactionMessagesLength === "number" && typeof data.messagesRemoved === "number") {
+            current.messagesLength = Math.max(0, data.preCompactionMessagesLength - data.messagesRemoved);
+        }
+        if (typeof data.systemTokens === "number") current.systemTokens = data.systemTokens;
+        if (typeof data.conversationTokens === "number") current.conversationTokens = data.conversationTokens;
+        if (typeof data.toolDefinitionsTokens === "number") current.toolDefinitionsTokens = data.toolDefinitionsTokens;
+        return current;
+    }
+
+    return null;
+}
+
+export function formatCompactionActivityRuns(timestamp, eventType, data = {}) {
+    const prefix = timestamp ? [{ text: `[${timestamp}] `, color: "white" }] : [];
+
+    if (eventType === "session.compaction_start") {
+        return [
+            ...prefix,
+            { text: "[compaction]", color: "magenta" },
+            { text: " started", color: "white" },
+        ];
+    }
+
+    if (data.success === false) {
+        return [
+            ...prefix,
+            { text: "[compaction]", color: "red" },
+            { text: " failed", color: "white" },
+            ...(typeof data.error === "string" && data.error
+                ? [{ text: `: ${data.error}`, color: "red" }]
+                : []),
+        ];
+    }
+
+    return [
+        ...prefix,
+        { text: "[compaction]", color: "magenta" },
+        { text: " complete", color: "white" },
+        ...(typeof data.tokensRemoved === "number"
+            ? [{ text: ` freed ${formatTokenCount(data.tokensRemoved)}`, color: "gray" }]
+            : []),
+    ];
+}