dexto 1.5.5 → 1.5.6

package/dist/cli/commands/sync-agents.js

@@ -0,0 +1,483 @@
+// packages/cli/src/cli/commands/sync-agents.ts
+import { promises as fs } from 'fs';
+import { createHash } from 'crypto';
+import path from 'path';
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { logger } from '@dexto/core';
+import { getDextoGlobalPath, resolveBundledScript, copyDirectory, loadBundledRegistryAgents, } from '@dexto/agent-management';
+/**
+ * Calculate SHA256 hash of a file
+ */
+async function hashFile(filePath) {
+    const content = await fs.readFile(filePath);
+    return createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Calculate combined hash for a directory
+ * Hashes all files recursively and combines them
+ */
+async function hashDirectory(dirPath) {
+    const hash = createHash('sha256');
+    const files = [];
+    async function collectFiles(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await collectFiles(fullPath);
+            }
+            else {
+                files.push(fullPath);
+            }
+        }
+    }
+    await collectFiles(dirPath);
+    // Sort for consistent ordering
+    files.sort();
+    for (const file of files) {
+        const relativePath = path.relative(dirPath, file);
+        const content = await fs.readFile(file);
+        hash.update(relativePath);
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}
+/**
+ * Get hash of bundled agent
+ */
+async function getBundledAgentHash(agentEntry) {
+    try {
+        const sourcePath = resolveBundledScript(`agents/${agentEntry.source}`);
+        const stat = await fs.stat(sourcePath);
+        if (stat.isDirectory()) {
+            return await hashDirectory(sourcePath);
+        }
+        else {
+            return await hashFile(sourcePath);
+        }
+    }
+    catch (error) {
+        logger.debug(`Failed to hash bundled agent: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Get hash of installed agent
+ */
+async function getInstalledAgentHash(agentId) {
+    try {
+        const installedPath = path.join(getDextoGlobalPath('agents'), agentId);
+        const stat = await fs.stat(installedPath);
+        if (stat.isDirectory()) {
+            return await hashDirectory(installedPath);
+        }
+        else {
+            return await hashFile(installedPath);
+        }
+    }
+    catch (error) {
+        logger.debug(`Failed to hash installed agent: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Check if an agent is installed
+ */
+async function isAgentInstalled(agentId) {
+    try {
+        const installedPath = path.join(getDextoGlobalPath('agents'), agentId);
+        await fs.access(installedPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get list of all installed agent directories
+ */
+async function getInstalledAgentIds() {
+    try {
+        const agentsDir = getDextoGlobalPath('agents');
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch (error) {
+        logger.debug(`Failed to list installed agents: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+/**
+ * Get agent status by comparing bundled vs installed
+ */
+async function getAgentStatus(agentId, agentEntry) {
+    const installed = await isAgentInstalled(agentId);
+    if (!installed) {
+        return {
+            id: agentId,
+            name: agentEntry.name,
+            description: agentEntry.description,
+            status: 'not_installed',
+        };
+    }
+    try {
+        const bundledHash = await getBundledAgentHash(agentEntry);
+        const installedHash = await getInstalledAgentHash(agentId);
+        if (!bundledHash || !installedHash) {
+            return {
+                id: agentId,
+                name: agentEntry.name,
+                description: agentEntry.description,
+                status: 'error',
+                error: 'Could not compute hash',
+            };
+        }
+        if (bundledHash === installedHash) {
+            return {
+                id: agentId,
+                name: agentEntry.name,
+                description: agentEntry.description,
+                status: 'up_to_date',
+            };
+        }
+        else {
+            return {
+                id: agentId,
+                name: agentEntry.name,
+                description: agentEntry.description,
+                status: 'changes_available',
+            };
+        }
+    }
+    catch (error) {
+        return {
+            id: agentId,
+            name: agentEntry.name,
+            description: agentEntry.description,
+            status: 'error',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+// Store sync dismissed state in cache directory
+const SYNC_DISMISSED_PATH = getDextoGlobalPath('cache', 'sync-dismissed.json');
+/**
+ * Check if sync was dismissed for current version
+ */
+async function wasSyncDismissed(currentVersion) {
+    try {
+        const content = await fs.readFile(SYNC_DISMISSED_PATH, 'utf-8');
+        const data = JSON.parse(content);
+        return data.version === currentVersion;
+    }
+    catch (error) {
+        logger.debug(`Could not read sync dismissed state: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Mark sync as dismissed for current version
+ */
+export async function markSyncDismissed(currentVersion) {
+    try {
+        await fs.mkdir(path.dirname(SYNC_DISMISSED_PATH), { recursive: true });
+        await fs.writeFile(SYNC_DISMISSED_PATH, JSON.stringify({ version: currentVersion }));
+    }
+    catch (error) {
+        logger.debug(`Could not save sync dismissed state: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Clear sync dismissed state (called after successful sync)
+ */
+export async function clearSyncDismissed() {
+    try {
+        await fs.unlink(SYNC_DISMISSED_PATH);
+    }
+    catch (error) {
+        // File might not exist - only log if it's a different error
+        if (error.code !== 'ENOENT') {
+            logger.debug(`Could not clear sync dismissed state: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+/**
+ * Quick check if any installed agents have updates available
+ *
+ * Used at CLI startup to prompt for sync without full command output.
+ * Returns true if at least one installed agent differs from bundled
+ * AND the user hasn't dismissed the prompt for this version.
+ *
+ * @param currentVersion Current CLI version to check dismissal state
+ * @returns true if should prompt for sync
+ */
+export async function shouldPromptForSync(currentVersion) {
+    try {
+        // Check if user already dismissed for this version
+        if (await wasSyncDismissed(currentVersion)) {
+            return false;
+        }
+        const bundledAgents = loadBundledRegistryAgents();
+        const installedAgentIds = await getInstalledAgentIds();
+        for (const agentId of installedAgentIds) {
+            const agentEntry = bundledAgents[agentId];
+            // Skip custom agents (not in bundled registry)
+            if (!agentEntry)
+                continue;
+            const bundledHash = await getBundledAgentHash(agentEntry);
+            const installedHash = await getInstalledAgentHash(agentId);
+            if (bundledHash && installedHash && bundledHash !== installedHash) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        logger.debug(`shouldPromptForSync check failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Update an agent from bundled to installed
+ */
+async function updateAgent(agentId, agentEntry) {
+    const agentsDir = getDextoGlobalPath('agents');
+    const targetDir = path.join(agentsDir, agentId);
+    const sourcePath = resolveBundledScript(`agents/${agentEntry.source}`);
+    // Ensure agents directory exists
+    await fs.mkdir(agentsDir, { recursive: true });
+    // Remove old installation
+    try {
+        await fs.rm(targetDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore if doesn't exist
+    }
+    // Copy from bundled source
+    const stat = await fs.stat(sourcePath);
+    if (stat.isDirectory()) {
+        await copyDirectory(sourcePath, targetDir);
+    }
+    else {
+        await fs.mkdir(targetDir, { recursive: true });
+        const targetFile = path.join(targetDir, path.basename(sourcePath));
+        await fs.copyFile(sourcePath, targetFile);
+    }
+}
+/**
+ * Display agent status with appropriate colors
+ */
+function formatStatus(status) {
+    switch (status) {
+        case 'up_to_date':
+            return chalk.green('Up to date');
+        case 'changes_available':
+            return chalk.yellow('Changes available');
+        case 'not_installed':
+            return chalk.gray('Not installed');
+        case 'custom':
+            return chalk.blue('Custom (user-installed)');
+        case 'error':
+            return chalk.red('Error');
+        default:
+            return chalk.gray('Unknown');
+    }
+}
+/**
+ * Main handler for the sync-agents command
+ *
+ * @param options Command options
+ *
+ * @example
+ * ```bash
+ * dexto sync-agents          # Interactive - prompt for each
+ * dexto sync-agents --list   # Show what would be updated
+ * dexto sync-agents --force  # Update all without prompting
+ * ```
+ */
+export async function handleSyncAgentsCommand(options) {
+    const { list = false, force = false, quiet = false } = options;
+    if (!quiet) {
+        p.intro(chalk.cyan('Agent Sync'));
+    }
+    const spinner = p.spinner();
+    spinner.start('Checking agent configs...');
+    try {
+        // Load bundled registry (uses existing function from agent-management)
+        const bundledAgents = loadBundledRegistryAgents();
+        const bundledAgentIds = Object.keys(bundledAgents);
+        // Get installed agents
+        const installedAgentIds = await getInstalledAgentIds();
+        // Find custom agents (installed but not in bundled registry)
+        const customAgentIds = installedAgentIds.filter((id) => !bundledAgents[id]);
+        // Check status of all bundled agents
+        const agentInfos = [];
+        for (const agentId of bundledAgentIds) {
+            const entry = bundledAgents[agentId];
+            if (entry) {
+                const info = await getAgentStatus(agentId, entry);
+                agentInfos.push(info);
+            }
+        }
+        // Add custom agents
+        for (const agentId of customAgentIds) {
+            agentInfos.push({
+                id: agentId,
+                name: agentId,
+                status: 'custom',
+            });
+        }
+        const updatableAgents = agentInfos.filter((a) => a.status === 'changes_available');
+        const upToDateAgents = agentInfos.filter((a) => a.status === 'up_to_date');
+        const notInstalledAgents = agentInfos.filter((a) => a.status === 'not_installed');
+        const customAgents = agentInfos.filter((a) => a.status === 'custom');
+        const errorAgents = agentInfos.filter((a) => a.status === 'error');
+        spinner.stop('Agent check complete');
+        // Quiet mode with force - minimal output for startup prompt
+        if (quiet && force) {
+            if (updatableAgents.length === 0) {
+                p.log.success('All agents up to date');
+                return;
+            }
+            const updatedNames = [];
+            const failedNames = [];
+            for (const agent of updatableAgents) {
+                const entry = bundledAgents[agent.id];
+                if (entry) {
+                    try {
+                        await updateAgent(agent.id, entry);
+                        updatedNames.push(agent.id);
+                    }
+                    catch (error) {
+                        failedNames.push(agent.id);
+                        logger.debug(`Failed to update ${agent.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            if (updatedNames.length > 0) {
+                p.log.success(`Updated: ${updatedNames.join(', ')}`);
+            }
+            if (failedNames.length > 0) {
+                p.log.warn(`Failed to update: ${failedNames.join(', ')}`);
+            }
+            return;
+        }
+        // Display full status (non-quiet mode)
+        console.log('');
+        console.log(chalk.bold('Agent Status:'));
+        console.log('');
+        // Show updatable first
+        for (const agent of updatableAgents) {
+            console.log(`  ${chalk.cyan(agent.id)}:`);
+            console.log(`    Status: ${formatStatus(agent.status)}`);
+            if (agent.description) {
+                console.log(`    ${chalk.gray(agent.description)}`);
+            }
+            console.log('');
+        }
+        // Show up-to-date
+        for (const agent of upToDateAgents) {
+            console.log(`  ${chalk.green(agent.id)}: ${formatStatus(agent.status)}`);
+        }
+        // Show not installed (summarized)
+        if (notInstalledAgents.length > 0) {
+            console.log('');
+            console.log(chalk.gray(`  ${notInstalledAgents.length} agents not installed: ${notInstalledAgents.map((a) => a.id).join(', ')}`));
+        }
+        // Show custom
+        if (customAgents.length > 0) {
+            console.log('');
+            for (const agent of customAgents) {
+                console.log(`  ${chalk.blue(agent.id)}: ${formatStatus(agent.status)}`);
+            }
+        }
+        // Show errors
+        for (const agent of errorAgents) {
+            console.log(`  ${chalk.red(agent.id)}: ${formatStatus(agent.status)}`);
+            if (agent.error) {
+                console.log(`    ${chalk.red(agent.error)}`);
+            }
+        }
+        console.log('');
+        // Summary
+        console.log(chalk.bold('Summary:'));
+        console.log(`  Up to date: ${chalk.green(upToDateAgents.length.toString())}`);
+        console.log(`  Changes available: ${chalk.yellow(updatableAgents.length.toString())}`);
+        console.log(`  Not installed: ${chalk.gray(notInstalledAgents.length.toString())}`);
+        if (customAgents.length > 0) {
+            console.log(`  Custom: ${chalk.blue(customAgents.length.toString())}`);
+        }
+        console.log('');
+        // If list mode, stop here
+        if (list) {
+            p.outro('Use `dexto sync-agents` to update agents');
+            return;
+        }
+        // No updates needed
+        if (updatableAgents.length === 0) {
+            p.outro(chalk.green('All installed agents are up to date!'));
+            return;
+        }
+        // Force mode - update all without prompting
+        if (force) {
+            const updateSpinner = p.spinner();
+            updateSpinner.start(`Updating ${updatableAgents.length} agents...`);
+            let successCount = 0;
+            let failCount = 0;
+            for (const agent of updatableAgents) {
+                const entry = bundledAgents[agent.id];
+                if (entry) {
+                    try {
+                        await updateAgent(agent.id, entry);
+                        successCount++;
+                    }
+                    catch (error) {
+                        failCount++;
+                        logger.error(`Failed to update ${agent.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            updateSpinner.stop(`Updated ${successCount} agents`);
+            if (failCount > 0) {
+                p.log.warn(`${failCount} agents failed to update`);
+            }
+            p.outro(chalk.green('Sync complete!'));
+            return;
+        }
+        // Interactive mode - prompt for each
+        for (const agent of updatableAgents) {
+            const shouldUpdate = await p.confirm({
+                message: `Update ${chalk.cyan(agent.name)} (${agent.id})?`,
+                initialValue: true,
+            });
+            if (p.isCancel(shouldUpdate)) {
+                p.cancel('Sync cancelled');
+                return;
+            }
+            if (shouldUpdate) {
+                const entry = bundledAgents[agent.id];
+                if (entry) {
+                    try {
+                        const updateSpinner = p.spinner();
+                        updateSpinner.start(`Updating ${agent.id}...`);
+                        await updateAgent(agent.id, entry);
+                        updateSpinner.stop(`Updated ${agent.id}`);
+                    }
+                    catch (error) {
+                        p.log.error(`Failed to update ${agent.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            else {
+                p.log.info(`Skipped ${agent.id}`);
+            }
+        }
+        p.outro(chalk.green('Sync complete!'));
+    }
+    catch (error) {
+        spinner.stop('Error');
+        p.log.error(`Failed to check agents: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/dist/cli/ink-cli/InkCLIRefactored.d.ts

@@ -25,9 +25,22 @@ interface InkCLIProps {
  * - MouseProvider (only in alternate buffer mode)
  */
 export declare function InkCLIRefactored({ agent, initialSessionId, startupInfo, soundService, }: InkCLIProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Options for starting the Ink CLI
+ */
+export interface InkCLIOptions {
+    /** Update info if a newer version is available */
+    updateInfo?: {
+        current: string;
+        latest: string;
+        updateCommand: string;
+    } | undefined;
+    /** True if installed agents differ from bundled and user should sync */
+    needsAgentSync?: boolean | undefined;
+}
 /**
  * Start the modern Ink-based CLI
  */
-export declare function startInkCliRefactored(agent: DextoAgent, initialSessionId: string | null): Promise<void>;
+export declare function startInkCliRefactored(agent: DextoAgent, initialSessionId: string | null, options?: InkCLIOptions): Promise<void>;
 export {};
 //# sourceMappingURL=InkCLIRefactored.d.ts.map

package/dist/cli/ink-cli/InkCLIRefactored.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InkCLIRefactored.d.ts","sourceRoot":"","sources":["../../../src/cli/ink-cli/InkCLIRefactored.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAWpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAiB7E,UAAU,WAAW;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACjD;AA6CD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAC7B,KAAK,EACL,gBAAgB,EAChB,WAAW,EACX,YAAY,GACf,EAAE,WAAW,2CAgBb;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACvC,KAAK,EAAE,UAAU,EACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAChC,OAAO,CAAC,IAAI,CAAC,CAgEf"}
+{"version":3,"file":"InkCLIRefactored.d.ts","sourceRoot":"","sources":["../../../src/cli/ink-cli/InkCLIRefactored.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAWpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAiB7E,UAAU,WAAW;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACjD;AA6CD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAC7B,KAAK,EACL,gBAAgB,EAChB,WAAW,EACX,YAAY,GACf,EAAE,WAAW,2CAgBb;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,kDAAkD;IAClD,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IACpF,wEAAwE;IACxE,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACxC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACvC,KAAK,EAAE,UAAU,EACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,EAC/B,OAAO,GAAE,aAAkB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAqEf"}

package/dist/cli/ink-cli/InkCLIRefactored.js

@@ -56,12 +56,17 @@ export function InkCLIRefactored({ agent, initialSessionId, startupInfo, soundSe
 /**
  * Start the modern Ink-based CLI
  */
-export async function startInkCliRefactored(agent, initialSessionId) {
+export async function startInkCliRefactored(agent, initialSessionId, options = {}) {
     registerGracefulShutdown(() => agent, { inkMode: true });
     // Enable bracketed paste mode so we can detect pasted text
     // This wraps pastes with escape sequences that our KeypressContext handles
     enableBracketedPaste();
-    const startupInfo = await getStartupInfo(agent);
+    const baseStartupInfo = await getStartupInfo(agent);
+    const startupInfo = {
+        ...baseStartupInfo,
+        updateInfo: options.updateInfo,
+        needsAgentSync: options.needsAgentSync,
+    };
     // Initialize sound service from preferences
     const { SoundNotificationService } = await import('./utils/soundNotification.js');
     const { globalPreferencesExist, loadGlobalPreferences } = await import('@dexto/agent-management');

package/dist/cli/ink-cli/components/StatusBar.d.ts

@@ -17,6 +17,10 @@ interface StatusBarProps {
     copyModeEnabled?: boolean;
     /** Whether an approval prompt is currently shown */
     isAwaitingApproval?: boolean;
+    /** Whether the todo list is expanded */
+    todoExpanded?: boolean;
+    /** Whether there are todos to display */
+    hasTodos?: boolean;
 }
 /**
  * Status bar that shows processing state above input area
@@ -26,6 +30,6 @@ interface StatusBarProps {
  * - Hide spinner during approval wait (user is reviewing, not waiting)
  * - Only show elapsed time after 30s (avoid visual noise for fast operations)
  */
-export declare function StatusBar({ agent, isProcessing, isThinking, isCompacting, approvalQueueCount, copyModeEnabled, isAwaitingApproval, }: StatusBarProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function StatusBar({ agent, isProcessing, isThinking, isCompacting, approvalQueueCount, copyModeEnabled, isAwaitingApproval, todoExpanded, hasTodos, }: StatusBarProps): import("react/jsx-runtime").JSX.Element | null;
 export {};
 //# sourceMappingURL=StatusBar.d.ts.map

package/dist/cli/ink-cli/components/StatusBar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StatusBar.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/StatusBar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,UAAU,cAAc;IACpB,KAAK,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oDAAoD;IACpD,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,EACtB,KAAK,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,eAAuB,EACvB,kBAA0B,GAC7B,EAAE,cAAc,kDA6GhB"}
+{"version":3,"file":"StatusBar.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/StatusBar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,UAAU,cAAc;IACpB,KAAK,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oDAAoD;IACpD,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wCAAwC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,EACtB,KAAK,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,eAAuB,EACvB,kBAA0B,EAC1B,YAAmB,EACnB,QAAgB,GACnB,EAAE,cAAc,kDAuHhB"}

package/dist/cli/ink-cli/components/StatusBar.js

@@ -21,7 +21,7 @@ import { useTokenCounter } from '../hooks/useTokenCounter.js';
  * - Hide spinner during approval wait (user is reviewing, not waiting)
  * - Only show elapsed time after 30s (avoid visual noise for fast operations)
  */
-export function StatusBar({ agent, isProcessing, isThinking, isCompacting, approvalQueueCount, copyModeEnabled = false, isAwaitingApproval = false, }) {
+export function StatusBar({ agent, isProcessing, isThinking, isCompacting, approvalQueueCount, copyModeEnabled = false, isAwaitingApproval = false, todoExpanded = true, hasTodos = false, }) {
     // Cycle through witty phrases while processing (not during compacting)
     const { phrase } = usePhraseCycler({ isActive: isProcessing && !isCompacting });
     // Track elapsed time during processing
@@ -42,14 +42,22 @@ export function StatusBar({ agent, isProcessing, isThinking, isCompacting, appro
     if (isAwaitingApproval) {
         return null;
     }
+    // Build the task toggle hint based on state
+    const todoHint = hasTodos
+        ? todoExpanded
+            ? 'ctrl+t to hide tasks'
+            : 'ctrl+t to show tasks'
+        : null;
     // Show compacting state - yellow/orange color to indicate context management
     if (isCompacting) {
         const metaParts = [];
         if (showTime)
             metaParts.push(`(${elapsedTime})`);
         metaParts.push('Esc to cancel');
+        if (todoHint)
+            metaParts.push(todoHint);
         const metaContent = metaParts.join(' • ');
-        return (_jsxs(Box, { paddingX: 1, marginTop: 1, marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { color: "yellow", children: " \uD83D\uDCE6 Compacting context..." })] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
+        return (_jsxs(Box, { paddingX: 1, marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { color: "yellow", children: " \uD83D\uDCE6 Compacting context..." })] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
     }
     // Show initial processing state (before streaming starts) - green/teal color
     // TODO: Rename this event/state to "reasoning" and associate it with actual reasoning tokens
@@ -61,8 +69,10 @@ export function StatusBar({ agent, isProcessing, isThinking, isCompacting, appro
         if (tokenCount)
             metaParts.push(tokenCount);
         metaParts.push('Esc to cancel');
+        if (todoHint)
+            metaParts.push(todoHint);
         const metaContent = metaParts.join(' • ');
-        return (_jsxs(Box, { paddingX: 1, marginTop: 1, marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "green", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: "green", children: [" ", phrase] })] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
+        return (_jsxs(Box, { paddingX: 1, marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "green", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: "green", children: [" ", phrase] })] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
     }
     // Show active streaming state - green/teal color
     // Always use 2-line layout: phrase on first line, meta on second
@@ -73,6 +83,8 @@ export function StatusBar({ agent, isProcessing, isThinking, isCompacting, appro
     if (tokenCount)
         metaParts.push(tokenCount);
     metaParts.push('Esc to cancel');
+    if (todoHint)
+        metaParts.push(todoHint);
     const metaContent = metaParts.join(' • ');
-    return (_jsxs(Box, { paddingX: 1, marginTop: 1, marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "green", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: "green", children: [" ", phrase] }), approvalQueueCount > 0 && (_jsxs(Text, { color: "yellowBright", children: [" \u2022 ", approvalQueueCount, " queued"] }))] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
+    return (_jsxs(Box, { paddingX: 1, marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", children: [_jsx(Text, { color: "green", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: "green", children: [" ", phrase] }), approvalQueueCount > 0 && (_jsxs(Text, { color: "yellowBright", children: [" \u2022 ", approvalQueueCount, " queued"] }))] }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: metaContent }) })] }));
 }

package/dist/cli/ink-cli/components/TodoPanel.d.ts

@@ -3,21 +3,24 @@
  *
  * Displays the current todo list for workflow tracking.
  * Shows todos with their status indicators (pending, in progress, completed).
+ *
+ * Display modes:
+ * - Processing + Collapsed: Shows "Next:" with the next pending/in-progress task
+ * - Processing + Expanded: Shows simple checklist with ☐/☑ indicators below status bar
+ * - Idle + Expanded: Shows boxed format with header
+ * - Idle + Collapsed: Hidden
  */
 import type { TodoItem } from '../state/types.js';
 interface TodoPanelProps {
     todos: TodoItem[];
+    /** Whether to show the full list or just the next task */
+    isExpanded: boolean;
+    /** Whether the agent is currently processing (affects display style) */
+    isProcessing?: boolean;
 }
 /**
  * TodoPanel - Shows current todos for workflow tracking
- *
- * Design decisions:
- * - Only shown when there are todos to display
- * - Compact display that doesn't take too much vertical space
- * - Status indicators: ○ pending, ● in progress, ✓ completed
- * - In-progress items show activeForm (what's being worked on)
- * - Completed items are dimmed with strikethrough
  */
-export declare function TodoPanel({ todos }: TodoPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function TodoPanel({ todos, isExpanded, isProcessing }: TodoPanelProps): import("react/jsx-runtime").JSX.Element | null;
 export {};
 //# sourceMappingURL=TodoPanel.d.ts.map

package/dist/cli/ink-cli/components/TodoPanel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TodoPanel.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/TodoPanel.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,mBAAmB,CAAC;AAE9D,UAAU,cAAc;IACpB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACrB;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,EAAE,KAAK,EAAE,EAAE,cAAc,kDAsClD"}
+{"version":3,"file":"TodoPanel.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/components/TodoPanel.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,mBAAmB,CAAC;AAE9D,UAAU,cAAc;IACpB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,0DAA0D;IAC1D,UAAU,EAAE,OAAO,CAAC;IACpB,wEAAwE;IACxE,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B;AAiBD;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,YAAoB,EAAE,EAAE,cAAc,kDAkHpF"}