zoe-agent 0.3.1

package/dist/adapters/cli/agent.js

@@ -0,0 +1,232 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getAllToolDefinitions } from '../../core/tool-executor.js';
+import { buildSystemPrompt } from './system-prompts.js';
+import { initializeSkillRegistry } from '../../skills/index.js';
+import { runAgentLoop } from '../../core/agent-loop.js';
+import { generateId, now } from '../../core/message-convert.js';
+import { createHookExecutor } from '../../core/hooks.js';
+import { buildSkillCatalog } from '../../core/skill-catalog.js';
+import { DEFAULT_MODELS } from '../../models-catalog.js';
+import { persistSession } from '../../core/session-store.js';
+export class Agent {
+    provider;
+    messages;
+    model;
+    config;
+    autoConfirm;
+    skillRegistry = null;
+    skillCatalog = '';
+    abortController = null;
+    _middleware = [];
+    systemPrompt;
+    providerType;
+    persistence;
+    sessionId;
+    constructor(provider, model = DEFAULT_MODELS['openai-compatible'], config = {}, systemPrompt, persistence = null, providerType) {
+        this.provider = provider;
+        this.model = model;
+        this.config = config;
+        this.autoConfirm = !!config?.autoConfirm;
+        // Default to the headless/Docker prompt; the caller (repl.ts) selects the
+        // interactive prompt when launching in a TTY. Kept mode-agnostic here so
+        // Core's runAgentLoop never needs to know about launch mode.
+        this.systemPrompt = systemPrompt ?? buildSystemPrompt();
+        this.providerType = providerType;
+        this.persistence = persistence;
+        this.sessionId = generateId();
+        this.messages = [{
+                id: generateId(),
+                role: "system",
+                content: this.systemPrompt,
+                timestamp: now(),
+            }];
+    }
+    async initializeSkills() {
+        try {
+            this.skillRegistry = await initializeSkillRegistry(process.cwd());
+            const metadata = this.skillRegistry.getMetadata();
+            if (metadata.length > 0) {
+                // Build and store skill catalog — will be injected by runAgentLoop
+                this.skillCatalog = buildSkillCatalog(metadata);
+                console.log(chalk.green(`Loaded ${metadata.length} skill(s):`));
+                for (const s of metadata) {
+                    console.log(chalk.dim(`  - ${s.name}`));
+                }
+            }
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`Warning: Skills initialization failed: ${error.message}`));
+        }
+    }
+    getSkillRegistry() {
+        return this.skillRegistry;
+    }
+    /** Set middleware pipeline (e.g., gateway semantic injection). */
+    setMiddleware(middleware) {
+        this._middleware = middleware;
+    }
+    async chat(userInput, signal, approveTool, permissionLevel, onStep) {
+        // @path references are resolved by the caller (repl.ts / use-agent.ts),
+        // not here — one resolution site per caller (T022).
+        this.messages.push({ id: generateId(), role: "user", content: userInput, timestamp: now() });
+        // When a custom onStep is supplied (TUI mode), the caller owns rendering:
+        // skip the ora spinner and chalk finish messages, and return the loop
+        // result so the caller renders terminal states. The readline path passes
+        // no onStep and stays byte-identical.
+        const customSteps = !!onStep;
+        const spinner = customSteps ? null : ora('Thinking...').start();
+        let wrappedApproveTool = approveTool;
+        if (!customSteps && approveTool && spinner) {
+            wrappedApproveTool = async (call) => {
+                spinner.stop();
+                try {
+                    return await approveTool(call);
+                }
+                finally {
+                    spinner.start();
+                }
+            };
+        }
+        const defaultOnStep = (step) => {
+            if (!spinner)
+                return;
+            if (step.type === "text" && step.content) {
+                spinner.stop();
+                console.log(chalk.blue("Zoe: ") + step.content);
+                spinner.start();
+            }
+            else if (step.type === "tool_call" && step.toolCall) {
+                spinner.stop();
+                console.log(chalk.gray(`Executing tool: ${step.toolCall.name}...`));
+                spinner.start();
+            }
+        };
+        try {
+            const result = await runAgentLoop({
+                provider: this.provider,
+                model: this.model,
+                messages: this.messages,
+                toolDefs: getAllToolDefinitions(),
+                skillCatalog: this.skillCatalog || undefined,
+                maxSteps: 30,
+                hooks: createHookExecutor(),
+                config: { ...this.config, agentName: 'cli' },
+                signal,
+                approveTool: wrappedApproveTool,
+                permissionLevel,
+                autoConfirm: this.autoConfirm,
+                middleware: this._middleware.length > 0 ? this._middleware : undefined,
+                onStep: onStep ?? defaultOnStep,
+                // Stream only when the caller supplies its own onStep (TUI mode) — the
+                // readline default handler prints complete 'text' steps, not deltas.
+                stream: customSteps,
+            });
+            spinner?.stop();
+            if (!customSteps) {
+                if (result.finishReason === "aborted") {
+                    console.log(chalk.yellow("\n(Interrupted)"));
+                }
+                else if (result.finishReason === "max_steps") {
+                    console.log(chalk.yellow("\n(Max steps reached — the agent needed more iterations to complete. Try increasing maxSteps or asking a more specific question.)"));
+                }
+                else if (result.error) {
+                    console.error(chalk.red(`Error: ${result.error.message}`));
+                }
+            }
+            return { finishReason: result.finishReason, error: result.error?.message, usage: result.usage };
+        }
+        catch (error) {
+            spinner?.stop();
+            if (error.name === 'AbortError' || signal?.aborted) {
+                if (!customSteps)
+                    console.log(chalk.yellow("\n(Interrupted)"));
+                return { finishReason: 'aborted' };
+            }
+            if (!customSteps)
+                console.error(chalk.red(error.message));
+            return { finishReason: 'error', error: error.message };
+        }
+        finally {
+            // Persist after every turn (success, abort, or error) so partial output
+            // survives a restart. Save is best-effort: a persistence failure must
+            // never crash the chat path. (Mirrors SDK agent.ts error handling.)
+            if (this.persistence) {
+                try {
+                    await persistSession(this.persistence, this.sessionId, this.messages, {
+                        provider: this.providerType,
+                        model: this.model,
+                    });
+                }
+                catch { /* persistence is best-effort */ }
+            }
+        }
+    }
+    /**
+     * Load a previously persisted session by id, replacing the in-memory history.
+     * Re-seeds the system message if the loaded set has none. No-op when no
+     * backend is configured.
+     */
+    async loadSession(sessionId) {
+        if (!this.persistence)
+            return false;
+        const data = await this.persistence.load(sessionId);
+        if (!data)
+            return false;
+        this.sessionId = sessionId;
+        const hasSystem = data.messages.some(m => m.role === 'system');
+        this.messages = hasSystem
+            ? data.messages
+            : [{ id: generateId(), role: 'system', content: this.systemPrompt, timestamp: now() }, ...data.messages];
+        return true;
+    }
+    /** Active session id (rotated by `clearConversation` when persistence is on). */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /** Configured persistence backend, or null when persistence is disabled. */
+    getPersistence() {
+        return this.persistence;
+    }
+    clearConversation() {
+        const systemPrompt = this.messages.find(m => m.role === 'system');
+        this.messages = systemPrompt
+            ? [systemPrompt]
+            : [{ id: generateId(), role: 'system', content: this.systemPrompt, timestamp: now() }];
+        // Rotate the session id so the next save writes a new file instead of
+        // overwriting the prior (now-superseded) session — it survives for resume.
+        if (this.persistence) {
+            this.sessionId = generateId();
+        }
+    }
+    /** Public accessor for the current message history. */
+    getMessages() {
+        return this.messages;
+    }
+    /** Replace the message history (e.g., after compaction). */
+    setMessages(messages) {
+        this.messages = messages;
+    }
+    /** Public accessor for the active LLM provider. */
+    getProvider() {
+        return this.provider;
+    }
+    /** Public accessor for the active model name. */
+    getModel() {
+        return this.model;
+    }
+    switchProvider(provider, model) {
+        this.provider = provider;
+        this.model = model;
+    }
+    abort() {
+        this.abortController?.abort();
+    }
+    createAbortSignal() {
+        this.abortController = new AbortController();
+        return this.abortController.signal;
+    }
+    clearAbortController() {
+        this.abortController = null;
+    }
+}

package/dist/adapters/cli/bootstrap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Zoe CLI — Shared session bootstrap
+ *
+ * The setup phase that both dispatch paths need: config load + merge,
+ * provider resolution (+ interactive setup wizard), permission level,
+ * Agent construction, skills init, gateway init, and the documents dir.
+ *
+ * Extracted verbatim from `runChat()` so the readline fallback and the
+ * Ink TUI share one setup path — no duplicated ~175 lines, and
+ * `zoe -n` stays byte-identical (the setup prints only the same
+ * interactive-gated status messages as before). UI chrome (welcome
+ * banner, "agent initialized", the readline loop) stays in the caller.
+ */
+import { Agent } from './agent.js';
+import type { PermissionLevel, PersistenceBackend } from '../../core/types.js';
+export interface CliSessionContext {
+    agent: Agent;
+    fullConfig: any;
+    activeProviderType: string;
+    providerConfig: any;
+    permissionLevel: PermissionLevel | undefined;
+    gatewayInstance: any;
+    persistence: PersistenceBackend;
+}
+export declare function bootstrapCliSession(options: any): Promise<CliSessionContext>;

package/dist/adapters/cli/bootstrap.js

@@ -0,0 +1,204 @@
+/**
+ * Zoe CLI — Shared session bootstrap
+ *
+ * The setup phase that both dispatch paths need: config load + merge,
+ * provider resolution (+ interactive setup wizard), permission level,
+ * Agent construction, skills init, gateway init, and the documents dir.
+ *
+ * Extracted verbatim from `runChat()` so the readline fallback and the
+ * Ink TUI share one setup path — no duplicated ~175 lines, and
+ * `zoe -n` stays byte-identical (the setup prints only the same
+ * interactive-gated status messages as before). UI chrome (welcome
+ * banner, "agent initialized", the readline loop) stays in the caller.
+ */
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Agent } from './agent.js';
+import { resolveLaunchMode, selectSystemPrompt } from './system-prompts.js';
+import { configureProviders, loadProviderConfig, getProvider, } from '../../core/provider-resolver.js';
+import { loadJsonConfig, applyEnvOverrides, migrateLegacyFormat, getConfigPaths, } from './config-loader.js';
+import { runSetup } from './setup.js';
+import { isNonInteractive } from './docker-utils.js';
+import { createPersistenceBackend } from '../../core/session-store.js';
+import { resolvePermissionLevel } from '../../core/permission.js';
+import { SettingsManager } from '../../core/settings-manager.js';
+import { loadMergedConfig } from './config-loader.js';
+export async function bootstrapCliSession(options) {
+    const { global: GLOBAL_CONFIG_FILE, local: LOCAL_CONFIG_FILE } = getConfigPaths();
+    // 1. Load and merge configs (local > global)
+    const globalConfig = loadJsonConfig(GLOBAL_CONFIG_FILE);
+    const localConfig = loadJsonConfig(LOCAL_CONFIG_FILE);
+    if (Object.keys(localConfig).length > 0 && options.interactive) {
+        console.log(chalk.dim(`Loaded project config from ${LOCAL_CONFIG_FILE}`));
+    }
+    let fullConfig = { ...globalConfig, ...localConfig };
+    // 2. Inject runtime flags
+    fullConfig.autoConfirm = options.yes || options.headless || options.docker || false;
+    // 2b. Resolve permission level from CLI flags, env var, and config
+    let permissionLevel;
+    const headless = options.headless || options.yes || options.docker;
+    if (!headless) {
+        const flagLevel = options.yolo ? "permissive"
+            : options.strict ? "strict"
+                : options.moderate ? "moderate"
+                    : undefined;
+        permissionLevel = resolvePermissionLevel(flagLevel, process.env.ZOE_PERMISSION, fullConfig.permissionLevel);
+    }
+    // Warn about conflicting flags
+    if (headless && (options.strict || options.moderate || options.yolo)) {
+        const flag = options.strict ? '--strict' : options.moderate ? '--moderate' : '--yolo';
+        console.warn(`Warning: --headless overrides ${flag}. All tools will be auto-approved.`);
+    }
+    // 3. Auto-migrate legacy config format (top-level apiKey/baseUrl/model)
+    //    Must run BEFORE applyEnvOverrides, which initializes models={} and would
+    //    block the !config.models guard in migrateLegacyFormat.
+    fullConfig = migrateLegacyFormat(fullConfig, { model: options.model });
+    // 4. Apply env var overrides for tool settings
+    fullConfig = applyEnvOverrides(fullConfig);
+    // 5. Load provider config via unified resolution
+    const cliProvider = options.provider;
+    let multiConfig = loadProviderConfig(fullConfig, cliProvider);
+    if (!multiConfig) {
+        console.log(chalk.yellow("No provider configuration found."));
+        if (isNonInteractive()) {
+            console.error(chalk.red("No provider configured. Set API key env vars (OPENAI_API_KEY / ANTHROPIC_API_KEY / GLM_API_KEY) or provide a config file."));
+            process.exit(1);
+        }
+        else {
+            const inquirer = await import('inquirer');
+            const { doSetup } = await inquirer.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'doSetup',
+                    message: 'Would you like to run the setup wizard now?',
+                    default: true
+                }
+            ]);
+            if (doSetup) {
+                await runSetup();
+                const newConfig = loadJsonConfig(GLOBAL_CONFIG_FILE);
+                Object.assign(fullConfig, newConfig);
+                multiConfig = loadProviderConfig(fullConfig, cliProvider);
+            }
+            else {
+                console.error(chalk.red("Provider configuration is required to proceed."));
+                process.exit(1);
+            }
+        }
+    }
+    if (!multiConfig) {
+        console.error(chalk.red("Provider configuration is still missing. Exiting."));
+        process.exit(1);
+    }
+    configureProviders(multiConfig);
+    // Active provider: CLI --provider flag → multiConfig.default
+    const activeProviderType = cliProvider ?? multiConfig.default;
+    // getProvider handles model override so it's baked into the provider instance
+    const { provider, model } = await getProvider(activeProviderType, options.model);
+    const providerConfig = { type: activeProviderType, model };
+    // Select system prompt by launch mode: interactive (TUI/readline in a TTY)
+    // gets the interactive coding-agent prompt; headless/docker/piped keep
+    // the Docker-native prompt unchanged.
+    const launchMode = resolveLaunchMode(options);
+    const systemPrompt = selectSystemPrompt(launchMode);
+    // Session persistence — single file backend shared by the REPL, TUI, and the
+    // session selector overlay. Default path is ~/.zoe/sessions (see Core's
+    // defaultSessionPath()). Disabled backends can be added via registerBackend().
+    const persistence = createPersistenceBackend({ type: 'file' });
+    const agent = new Agent(provider, model, fullConfig, systemPrompt, persistence, activeProviderType);
+    // Initialize skills system
+    await agent.initializeSkills();
+    // Initialize gateway (if enabled)
+    let gatewayInstance = null;
+    try {
+        const settingsManager = new SettingsManager({
+            config: applyEnvOverrides(loadMergedConfig()),
+            projectConfigPath: LOCAL_CONFIG_FILE,
+            globalConfigPath: GLOBAL_CONFIG_FILE,
+        });
+        const gwEnabled = settingsManager.get('gateway.enabled').value;
+        if (gwEnabled) {
+            const gatewayConfig = {
+                enabled: true,
+                semanticTopK: settingsManager.get('gateway.semanticTopK').value,
+                defaultRateLimitPerMin: settingsManager.get('gateway.defaultRateLimitPerMin').value,
+                maxAuditLogsInMemory: settingsManager.get('gateway.maxAuditLogs').value,
+            };
+            const { GatewaySettingsAdapter } = await import('../../gateway/settings-adapter.js');
+            const gwStorageDir = process.env.ZOE_GATEWAY_DIR ?? path.join(os.homedir(), '.zoe');
+            const gwSettingsAdapter = new GatewaySettingsAdapter(gwStorageDir);
+            await gwSettingsAdapter.initialize();
+            const { createGateway } = await import('../../gateway/index.js');
+            gatewayInstance = await createGateway(gatewayConfig, gwSettingsAdapter);
+            if (gatewayInstance) {
+                const { semanticToolInjectionMiddleware } = await import('../../core/middleware/semantic-tools.js');
+                agent.setMiddleware([semanticToolInjectionMiddleware(gatewayInstance, gatewayConfig.semanticTopK)]);
+                if (options.interactive) {
+                    console.log(chalk.green('Gateway initialized'));
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.warn(chalk.yellow(`Gateway initialization skipped: ${e instanceof Error ? e.message : String(e)}`));
+    }
+    // Ensure ~/zoe_documents exists
+    const docsDir = path.join(os.homedir(), 'zoe_documents');
+    if (!fs.existsSync(docsDir)) {
+        fs.mkdirSync(docsDir, { recursive: true });
+        for (const sub of ['notes', 'templates', 'output', 'knowledge']) {
+            fs.mkdirSync(path.join(docsDir, sub), { recursive: true });
+        }
+    }
+    // Session TTL cleanup — sweep expired sessions on startup (once, no timer).
+    // Runs before --resume so an expired target is gone before we try to load it.
+    try {
+        const settingsManager = new SettingsManager({
+            config: applyEnvOverrides(loadMergedConfig()),
+            projectConfigPath: LOCAL_CONFIG_FILE,
+            globalConfigPath: GLOBAL_CONFIG_FILE,
+        });
+        const maxAgeDays = settingsManager.get('sessions.maxAgeDays').value;
+        if (maxAgeDays && maxAgeDays > 0) {
+            const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+            const cutoff = Date.now() - maxAgeMs;
+            const ids = await persistence.list();
+            await Promise.all(ids.map(async (id) => {
+                const data = await persistence.load(id);
+                if (data && data.updatedAt < cutoff)
+                    await persistence.delete(id);
+            }));
+        }
+    }
+    catch { /* best-effort — never block startup on cleanup */ }
+    // --resume <id|last> — load a session before the REPL/TUI starts.
+    if (options.resume) {
+        let resumeId = options.resume;
+        if (resumeId === 'last') {
+            const ids = await persistence.list();
+            if (ids.length === 0) {
+                console.error(chalk.red('No saved sessions to resume.'));
+                process.exit(1);
+            }
+            const loaded = await Promise.all(ids.map((id) => persistence.load(id)));
+            const mostRecent = loaded
+                .filter((s) => s != null)
+                .sort((a, b) => b.updatedAt - a.updatedAt)[0];
+            if (!mostRecent) {
+                console.error(chalk.red('No saved sessions to resume.'));
+                process.exit(1);
+            }
+            resumeId = mostRecent.id;
+        }
+        const ok = await agent.loadSession(resumeId);
+        if (!ok) {
+            console.error(chalk.red(`Session "${resumeId}" not found. Use /sessions in the TUI to list available sessions.`));
+            process.exit(1);
+        }
+        if (options.interactive !== false)
+            console.log(chalk.dim(`Resumed session ${resumeId.slice(0, 8)}.`));
+    }
+    return { agent, fullConfig, activeProviderType, providerConfig, permissionLevel, gatewayInstance, persistence };
+}

package/dist/adapters/cli/commands/build-registry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build the shared slash-command registry.
+ *
+ * Single owner of which commands exist and how they're wired — used by both
+ * the readline REPL (`repl.ts`) and the Ink TUI (`tui/`). Handlers follow one
+ * contract: they return `{ output, exit }` and never write to stdout directly.
+ *
+ * `interactive: true` marks handlers that own stdin/stdout (inquirer wizards,
+ * ora spinners, the setup wizard). They run in the readline REPL but the TUI
+ * defers them (Ink owns stdin there).
+ */
+import type { Agent } from '../agent.js';
+import { CommandRegistry } from './registry.js';
+export declare function buildCommandRegistry(agent: Agent, config: any, activeProviderType: string, gatewayInstance?: any): CommandRegistry;

package/dist/adapters/cli/commands/build-registry.js

@@ -0,0 +1,88 @@
+/**
+ * Build the shared slash-command registry.
+ *
+ * Single owner of which commands exist and how they're wired — used by both
+ * the readline REPL (`repl.ts`) and the Ink TUI (`tui/`). Handlers follow one
+ * contract: they return `{ output, exit }` and never write to stdout directly.
+ *
+ * `interactive: true` marks handlers that own stdin/stdout (inquirer wizards,
+ * ora spinners, the setup wizard). They run in the readline REPL but the TUI
+ * defers them (Ink owns stdin there).
+ */
+import { CommandRegistry } from './registry.js';
+import { createHelpHandler } from './help.js';
+import { clearHandler } from './clear.js';
+import { exitHandler } from './exit.js';
+import { compactHandler } from './compact.js';
+import { skillsHandler } from './skills.js';
+import { modelsHandler } from './models.js';
+import { settingsHandler } from './settings.js';
+import { runSetup } from '../setup.js';
+export function buildCommandRegistry(agent, config, activeProviderType, gatewayInstance) {
+    const registry = new CommandRegistry();
+    const skillRegistry = agent.getSkillRegistry();
+    // Tier 1 — Session Control
+    registry.register('help', createHelpHandler(registry, skillRegistry), {
+        description: 'Show available commands',
+        aliases: ['?'],
+    });
+    registry.register('clear', clearHandler, {
+        description: 'Clear conversation history',
+        aliases: ['reset', 'new'],
+    });
+    registry.register('exit', exitHandler, {
+        description: 'End the session',
+        aliases: ['quit'],
+    });
+    registry.register('compact', compactHandler, {
+        description: 'Compress conversation to a summary',
+        aliases: ['compress'],
+        interactive: true, // ora spinner
+    });
+    // Tier 2 — Configuration & Discovery
+    registry.register('skills', skillsHandler, {
+        description: 'List loaded skills',
+    });
+    registry.register('models', modelsHandler(agent, config, activeProviderType), {
+        description: 'Switch providers and models',
+        aliases: ['model'],
+        interactive: true, // inquirer wizard
+    });
+    registry.register('sessions', async () => ({
+        output: 'Session selector is available in the TUI: run /sessions or Ctrl+P → sessions.',
+    }), {
+        description: 'Resume, switch, or delete a session',
+        aliases: ['session'],
+        interactive: true, // TUI overlay (intercepted by handleUserInput before dispatch)
+    });
+    registry.register('steer', async () => ({
+        output: '/steer <message> interrupts the current run and sends a new message. Available in the TUI.',
+    }), {
+        description: 'Interrupt the run and send a new message',
+        interactive: true, // TUI-intercepted (works during a run — its purpose)
+    });
+    registry.register('settings', settingsHandler(), {
+        description: 'View and edit configuration',
+        aliases: ['config', 'setting'],
+        // Not flagged interactive: read subcommands (list/get/reset/export/help)
+        // return output and work in the TUI. The wizard (no args) + `set` use
+        // inquirer and are intercepted by the TUI's handleUserInput.
+    });
+    registry.register('setup', async () => {
+        await runSetup();
+        return {};
+    }, {
+        description: 'Run the setup wizard',
+        interactive: true,
+    });
+    // Gateway management — handler returns a string; adapt to CommandResult.
+    registry.register('gateway', async (ctx) => {
+        const { createGatewayCommandHandler } = await import('./gateway.js');
+        const handler = createGatewayCommandHandler(gatewayInstance);
+        return { output: await handler(ctx.args) };
+    }, {
+        description: 'Gateway management (targets, routes, credentials)',
+        aliases: ['gw'],
+    });
+    return registry;
+}

package/dist/adapters/cli/commands/clear.d.ts

@@ -0,0 +1,7 @@
+/**
+ * /clear command handler for Zoe CLI.
+ *
+ * Aliases: /reset, /new
+ */
+import type { CommandHandler } from './registry.js';
+export declare const clearHandler: CommandHandler;

package/dist/adapters/cli/commands/clear.js

@@ -0,0 +1,10 @@
+/**
+ * /clear command handler for Zoe CLI.
+ *
+ * Aliases: /reset, /new
+ */
+import chalk from 'chalk';
+export const clearHandler = async (ctx) => {
+    ctx.agent.clearConversation();
+    return { output: chalk.cyan('Conversation cleared. Starting fresh.') };
+};

package/dist/adapters/cli/commands/compact.d.ts

@@ -0,0 +1,13 @@
+/**
+ * /compact command handler for Zoe CLI.
+ *
+ * Summarizes the conversation to reduce token usage while preserving
+ * key context needed to continue the session.
+ *
+ * Aliases: /compress
+ *
+ * Uses an `ora` spinner (stdout), so it is marked `interactive` and the TUI
+ * defers it — run it in the readline REPL.
+ */
+import type { CommandHandler } from './registry.js';
+export declare const compactHandler: CommandHandler;