@lovelybunch/api 1.0.47 → 1.0.48

package/dist/lib/gait-path.d.ts

@@ -1,13 +1,15 @@
 /**
- * Find the .gait directory by traversing up from the current working directory
+ * Find the .nut directory by traversing up from the current working directory
  * If GAIT_DATA_PATH is set (from CLI), use that instead
  */
-export declare function findGaitDirectory(startDir?: string): Promise<string | null>;
+export declare function findNutDirectory(startDir?: string): Promise<string | null>;
+export declare const findGaitDirectory: typeof findNutDirectory;
 /**
- * Get the path to a context file, automatically finding the .gait directory
+ * Get the path to a context file, automatically finding the .nut directory
  */
 export declare function getContextFilePath(fileName: string): Promise<string | null>;
 /**
- * Get the .gait config to read storage path settings
+ * Get the .nut config to read storage path settings
  */
-export declare function getGaitConfig(): Promise<any | null>;
+export declare function getNutConfig(): Promise<any | null>;
+export declare const getGaitConfig: typeof getNutConfig;

package/dist/lib/gait-path.js

@@ -1,16 +1,18 @@
 import { promises as fs } from 'fs';
 import path from 'path';
+// Directory constant
+const NUT_DIR_NAME = '.nut';
 /**
- * Find the .gait directory by traversing up from the current working directory
+ * Find the .nut directory by traversing up from the current working directory
  * If GAIT_DATA_PATH is set (from CLI), use that instead
  */
-export async function findGaitDirectory(startDir) {
+export async function findNutDirectory(startDir) {
     // If running from CLI (gait serve), use the directory where command was run
     if (process.env.GAIT_DATA_PATH) {
-        const gaitPath = path.join(process.env.GAIT_DATA_PATH, '.gait');
+        const nutPath = path.join(process.env.GAIT_DATA_PATH, NUT_DIR_NAME);
         try {
-            await fs.access(gaitPath);
-            return gaitPath;
+            await fs.access(nutPath);
+            return nutPath;
         }
         catch {
             // Fall through to directory traversal
@@ -19,10 +21,10 @@ export async function findGaitDirectory(startDir) {
     // Otherwise traverse up from start directory
     let currentDir = startDir || process.cwd();
     while (currentDir !== path.parse(currentDir).root) {
-        const gaitPath = path.join(currentDir, '.gait');
+        const nutPath = path.join(currentDir, NUT_DIR_NAME);
         try {
-            await fs.access(gaitPath);
-            return gaitPath;
+            await fs.access(nutPath);
+            return nutPath;
         }
         catch {
             currentDir = path.dirname(currentDir);
@@ -30,23 +32,25 @@ export async function findGaitDirectory(startDir) {
     }
     return null;
 }
+// Legacy function name for backward compatibility
+export const findGaitDirectory = findNutDirectory;
 /**
- * Get the path to a context file, automatically finding the .gait directory
+ * Get the path to a context file, automatically finding the .nut directory
  */
 export async function getContextFilePath(fileName) {
-    const gaitDir = await findGaitDirectory();
-    if (!gaitDir)
+    const nutDir = await findNutDirectory();
+    if (!nutDir)
         return null;
-    return path.join(gaitDir, 'context', fileName);
+    return path.join(nutDir, 'context', fileName);
 }
 /**
- * Get the .gait config to read storage path settings
+ * Get the .nut config to read storage path settings
  */
-export async function getGaitConfig() {
-    const gaitDir = await findGaitDirectory();
-    if (!gaitDir)
+export async function getNutConfig() {
+    const nutDir = await findNutDirectory();
+    if (!nutDir)
         return null;
-    const configPath = path.join(gaitDir, 'config.json');
+    const configPath = path.join(nutDir, 'config.json');
     try {
         const config = await fs.readFile(configPath, 'utf-8');
         return JSON.parse(config);
@@ -55,3 +59,5 @@ export async function getGaitConfig() {
         return null;
     }
 }
+// Legacy function name for backward compatibility
+export const getGaitConfig = getNutConfig;

package/dist/lib/project-paths.d.ts

@@ -1,5 +1,5 @@
 /**
- * Gets the consistent project root path for GAIT operations.
+ * Gets the consistent project root path for Coconut operations.
  * This ensures that both symlink operations use the same base path.
  */
 export declare function getProjectRoot(): Promise<string>;
@@ -8,6 +8,6 @@ export declare function getProjectRoot(): Promise<string>;
  */
 export declare function getSymlinkPath(): Promise<string>;
 /**
- * Gets the path to the actual CLAUDE.md file in .gait/rules
+ * Gets the path to the actual CLAUDE.md file in .nut/rules
  */
 export declare function getTargetPath(): Promise<string>;

package/dist/lib/project-paths.js

@@ -1,7 +1,9 @@
 import path from 'path';
 import { promises as fs } from 'fs';
+// Directory constant
+const NUT_DIR_NAME = '.nut';
 /**
- * Gets the consistent project root path for GAIT operations.
+ * Gets the consistent project root path for Coconut operations.
  * This ensures that both symlink operations use the same base path.
  */
 export async function getProjectRoot() {
@@ -19,10 +21,11 @@ export async function getProjectRoot() {
             // Check if we're at the project root by looking for distinctive files
             const possibleRoot = currentPath;
             const hasPackageJson = await fs.access(path.join(possibleRoot, 'package.json')).then(() => true).catch(() => false);
-            const hasGaitDir = await fs.access(path.join(possibleRoot, '.gait')).then(() => true).catch(() => false);
+            // Check for .nut directory
+            const hasNutDir = await fs.access(path.join(possibleRoot, NUT_DIR_NAME)).then(() => true).catch(() => false);
             const hasPnpmWorkspace = await fs.access(path.join(possibleRoot, 'pnpm-workspace.yaml')).then(() => true).catch(() => false);
             // If this looks like the project root, use it
-            if (hasPackageJson && hasGaitDir && hasPnpmWorkspace) {
+            if (hasPackageJson && hasNutDir && hasPnpmWorkspace) {
                 return possibleRoot;
             }
             // Otherwise, check parent directory
@@ -49,9 +52,9 @@ export async function getSymlinkPath() {
     return path.join(projectRoot, 'CLAUDE.md');
 }
 /**
- * Gets the path to the actual CLAUDE.md file in .gait/rules
+ * Gets the path to the actual CLAUDE.md file in .nut/rules
  */
 export async function getTargetPath() {
     const projectRoot = await getProjectRoot();
-    return path.join(projectRoot, '.gait', 'rules', 'CLAUDE.md');
+    return path.join(projectRoot, '.nut', 'rules', 'CLAUDE.md');
 }

package/dist/lib/storage/file-storage.js

@@ -9,16 +9,16 @@ export class FileStorageAdapter {
             this.basePath = basePath;
         }
         else if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-            // Dev mode: use project root .gait directory
+            // Dev mode: use project root .nut directory
             this.basePath = process.env.GAIT_DEV_ROOT;
         }
         else if (process.env.GAIT_DATA_PATH) {
             // Production mode: use GAIT_DATA_PATH (set by CLI)
-            this.basePath = path.join(process.env.GAIT_DATA_PATH, '.gait');
+            this.basePath = path.join(process.env.GAIT_DATA_PATH, '.nut');
         }
         else {
-            // Fallback: use current directory .gait
-            this.basePath = '.gait';
+            // Fallback: use current directory .nut
+            this.basePath = '.nut';
         }
     }
     async ensureDirectories() {

package/dist/lib/symlinks/symlink-manager.js

@@ -10,7 +10,7 @@ export class SymlinkManager {
     state;
     constructor(projectRoot) {
         this.projectRoot = projectRoot;
-        this.configPath = path.join(projectRoot, '.gait', 'symlinks.json');
+        this.configPath = path.join(projectRoot, '.nut', 'symlinks.json');
         this.state = {
             version: '1.0.0',
             symlinks: []
@@ -23,9 +23,9 @@ export class SymlinkManager {
         try {
             console.log(`[SymlinkManager] Initializing with project root: ${this.projectRoot}`);
             console.log(`[SymlinkManager] Config path: ${this.configPath}`);
-            // Ensure .gait directory exists
-            const gaitDir = path.join(this.projectRoot, '.gait');
-            await fs.mkdir(gaitDir, { recursive: true });
+            // Ensure .nut directory exists
+            const nutDir = path.join(this.projectRoot, '.nut');
+            await fs.mkdir(nutDir, { recursive: true });
             // Try to load existing configuration
             try {
                 const configData = await fs.readFile(this.configPath, 'utf-8');
@@ -70,7 +70,7 @@ export class SymlinkManager {
             name: 'Claude Rules',
             description: 'Project-specific rules and guidelines for Claude AI assistant',
             linkPath: 'CLAUDE.md',
-            targetPath: '.gait/rules/CLAUDE.md',
+            targetPath: '.nut/rules/CLAUDE.md',
             isActive,
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString()
@@ -121,7 +121,6 @@ export class SymlinkManager {
             await fs.writeFile(tempPath, JSON.stringify(this.state, null, 2), 'utf-8');
             // Atomic rename
             await fs.rename(tempPath, this.configPath);
-            console.log(`[SymlinkManager] Saved state with ${this.state.symlinks.length} symlinks to ${this.configPath}`);
         }
         catch (error) {
             console.error('[SymlinkManager] Failed to save state:', error);
@@ -407,25 +406,42 @@ export async function getSymlinkManager() {
             // Determine project root more reliably
             let projectRoot = process.env.GAIT_PROJECT_ROOT;
             if (!projectRoot) {
-                // Try to find the project root by looking for distinctive files
-                const cwd = process.cwd();
-                // Check if we're in packages/web
-                if (cwd.includes('packages/web')) {
-                    projectRoot = path.resolve(cwd, '../..');
-                }
-                else if (cwd.includes('packages')) {
-                    projectRoot = path.resolve(cwd, '..');
-                }
-                else {
-                    projectRoot = cwd;
-                }
-                // Verify this is the right directory by checking for .gait
-                try {
-                    await fs.access(path.join(projectRoot, '.gait'));
+                // In development, we need to find the actual project root
+                // Starting from the current working directory
+                let currentPath = process.cwd();
+                // If we're in a Next.js app, we might be in packages/web
+                // We need to traverse up to find the actual project root
+                while (currentPath !== path.dirname(currentPath)) {
+                    try {
+                        // Check if we're at the project root by looking for distinctive files
+                        const possibleRoot = currentPath;
+                        const hasPackageJson = await fs.access(path.join(possibleRoot, 'package.json')).then(() => true).catch(() => false);
+                        // Check for .nut directory
+                        const hasNutDir = await fs.access(path.join(possibleRoot, '.nut')).then(() => true).catch(() => false);
+                        const hasPnpmWorkspace = await fs.access(path.join(possibleRoot, 'pnpm-workspace.yaml')).then(() => true).catch(() => false);
+                        // If this looks like the project root, use it
+                        if (hasPackageJson && hasNutDir && hasPnpmWorkspace) {
+                            projectRoot = possibleRoot;
+                            break;
+                        }
+                        // Otherwise, check parent directory
+                        currentPath = path.dirname(currentPath);
+                    }
+                    catch {
+                        currentPath = path.dirname(currentPath);
+                    }
                 }
-                catch {
-                    console.warn(`Could not find .gait directory at ${projectRoot}, using cwd`);
-                    projectRoot = cwd;
+                // Fallback: if we can't find the project root, use the current working directory
+                // But also try a known relative path from the web package
+                if (!projectRoot) {
+                    const webPackagePath = process.cwd();
+                    if (webPackagePath.includes('packages/web')) {
+                        // We're in the web package, go up to the root
+                        projectRoot = path.resolve(webPackagePath, '../..');
+                    }
+                    else {
+                        projectRoot = process.cwd();
+                    }
                 }
             }
             console.log(`[SymlinkManager] Using project root: ${projectRoot}`);

package/dist/lib/terminal/context-helper.js

@@ -3,24 +3,24 @@
 export function generateWelcomeMessage(context) {
     return `
 \x1b[32m╭─────────────────────────────────────────────────────────────╮\x1b[0m
-\x1b[32m│                    GAIT Terminal Session                    │\x1b[0m
+\x1b[32m│                 Coconut Terminal Session                    │\x1b[0m
 \x1b[32m╰─────────────────────────────────────────────────────────────╯\x1b[0m
 
 \x1b[36mProposal:\x1b[0m ${context.proposalId}
 \x1b[36mProject Root:\x1b[0m ${context.projectRoot}
 
 \x1b[33mAvailable Environment Variables:\x1b[0m
-  GAIT_PROPOSAL_ID="${context.proposalId}"
-  GAIT_CONTEXT_PATH="${context.contextPath}"
-  GAIT_PROPOSAL_PATH="${context.proposalPath}"
+  COCONUT_PROPOSAL_ID="${context.proposalId}"
+  COCONUT_CONTEXT_PATH="${context.contextPath}"
+  COCONUT_PROPOSAL_PATH="${context.proposalPath}"
 
 \x1b[33mQuick Commands:\x1b[0m
-  \x1b[32mgait-help\x1b[0m        - Show this help message
-  \x1b[32mgait-proposal\x1b[0m    - View current proposal
-  \x1b[32mgait-files\x1b[0m       - List context files
-  \x1b[32mgait-claude\x1b[0m      - Setup Claude Code CLI
+  \x1b[32mcoconut-help\x1b[0m        - Show this help message
+  \x1b[32mcoconut-proposal\x1b[0m    - View current proposal
+  \x1b[32mcoconut-files\x1b[0m       - List context files
+  \x1b[32mcoconut-claude\x1b[0m      - Setup Claude Code CLI
 
-\x1b[90mTip: Use 'gait-claude' to configure Claude Code for this proposal\x1b[0m
+\x1b[90mTip: Use 'coconut-claude' to configure Claude Code for this proposal\x1b[0m
 
 `;
 }
@@ -36,7 +36,7 @@ export function generateClaudeSetupCommands(context) {
         '# 2. Create a Claude Code project configuration',
         'cat > .claude-project.json << EOF',
         '{',
-        `  "name": "GAIT Proposal ${context.proposalId}",`,
+        `  "name": "Coconut Proposal ${context.proposalId}",`,
         `  "description": "Working on proposal ${context.proposalId}",`,
         '  "context": [',
         `    "${context.proposalPath}",`,
@@ -85,38 +85,38 @@ export function generateBashAliases(_context) {
 }
 export function createInitScript(context) {
     return `#!/bin/bash
-# GAIT Terminal Initialization Script
+# Coconut Terminal Initialization Script
 # This script is automatically sourced when a terminal session starts
 
 # Function to show context help
-gait-context-help() {
-  cat << 'GAIT_HELP_EOF'
+coconut-context-help() {
+  cat << 'COCONUT_HELP_EOF'
 ${generateWelcomeMessage(context)}
-GAIT_HELP_EOF
+COCONUT_HELP_EOF
 }
 
 # Function to show proposal content
-gait-proposal() {
-  if [ -f "$GAIT_PROPOSAL_PATH" ]; then
-    echo "\\x1b[36m=== Proposal: $GAIT_PROPOSAL_ID ===\\x1b[0m"
-    cat "$GAIT_PROPOSAL_PATH"
+coconut-proposal() {
+  if [ -f "$COCONUT_PROPOSAL_PATH" ]; then
+    echo "\\x1b[36m=== Proposal: $COCONUT_PROPOSAL_ID ===\\x1b[0m"
+    cat "$COCONUT_PROPOSAL_PATH"
   else
-    echo "\\x1b[31mProposal file not found: $GAIT_PROPOSAL_PATH\\x1b[0m"
+    echo "\\x1b[31mProposal file not found: $COCONUT_PROPOSAL_PATH\\x1b[0m"
   fi
 }
 
 # Function to list context files
-gait-files() {
+coconut-files() {
   echo "\\x1b[36m=== Context Files ===\\x1b[0m"
-  if [ -d "$GAIT_CONTEXT_PATH" ]; then
-    find "$GAIT_CONTEXT_PATH" -name "*.md" -type f | sort
+  if [ -d "$COCONUT_CONTEXT_PATH" ]; then
+    find "$COCONUT_CONTEXT_PATH" -name "*.md" -type f | sort
   else
-    echo "\\x1b[31mContext directory not found: $GAIT_CONTEXT_PATH\\x1b[0m"
+    echo "\\x1b[31mContext directory not found: $COCONUT_CONTEXT_PATH\\x1b[0m"
   fi
 }
 
 # Function to setup Claude Code
-gait-claude() {
+coconut-claude() {
   echo "\\x1b[36m=== Claude Code Setup ===\\x1b[0m"
   
   # Check if Claude Code is available
@@ -129,7 +129,7 @@ gait-claude() {
   # Create project configuration
   cat > .claude-project.json << 'EOF'
 {
-  "name": "GAIT Proposal ${context.proposalId}",
+  "name": "Coconut Proposal ${context.proposalId}",
   "description": "Working on proposal ${context.proposalId}",
   "context": [
     "${context.proposalPath}",
@@ -149,13 +149,13 @@ EOF
 }
 
 # Create helpful alias for help command
-alias gait-help='gait-context-help'
+alias coconut-help='coconut-context-help'
 
 # Clear screen first to avoid any leftover content
 clear
 
 # Show welcome message
-gait-context-help
+coconut-context-help
 
 # Set a custom prompt to show the proposal ID
 # This will be replaced with shell-specific syntax in prepareShellInit

package/dist/lib/terminal/shell-utils.js

@@ -139,15 +139,15 @@ export function prepareShellInit(shellPath, initScript) {
             // Also fix the prompt to use zsh syntax
             const zshScript = initScript
                 // Replace bash-style prompt with zsh-style prompt
-                .replace(/export PS1=.*$/m, 'export PROMPT="%F{cyan}[${GAIT_PROPOSAL_ID}]%f %~ %# "');
+                .replace(/export PS1=.*$/m, 'export PROMPT="%F{cyan}[${COCONUT_PROPOSAL_ID}]%f %~ %# "');
             return {
                 script: `#!/bin/zsh
-# GAIT Zsh Initialization
+# Coconut Zsh Initialization
 
 # Source system zshrc if it exists (suppress any output)
 [ -f ~/.zshrc ] && source ~/.zshrc > /dev/null 2>&1 || true
 
-# Custom GAIT initialization
+# Custom Coconut initialization
 ${zshScript}`,
                 needsEnvVar: { name: 'ZDOTDIR', value: '' } // Will be set to temp dir
             };
@@ -157,19 +157,19 @@ ${zshScript}`,
                 .replace(/export\\s+(\\w+)=(.*)/g, 'set -gx $1 $2')
                 .replace(/alias\\s+(\\w+)=(.*)/g, 'alias $1 $2')
                 // Fish prompt syntax
-                .replace(/export PS1=.*$/m, 'function fish_prompt\n    echo -n (set_color cyan)"[$GAIT_PROPOSAL_ID]"(set_color normal)" "(prompt_pwd)" > "\nend');
+                .replace(/export PS1=.*$/m, 'function fish_prompt\n    echo -n (set_color cyan)"[$COCONUT_PROPOSAL_ID]"(set_color normal)" "(prompt_pwd)" > "\nend');
             return {
                 script: fishScript
             };
         case 'bash':
         default:
             // Bash uses the script with proper PS1 escaping
-            const bashScript = initScript.replace(/export PS1="\[(.*)\] \\w \$ "/, 'export PS1="\\[\\033[36m\\][$GAIT_PROPOSAL_ID]\\[\\033[0m\\] \\w \\$ "');
+            const bashScript = initScript.replace(/export PS1="\[(.*)\] \\w \$ "/, 'export PS1="\\[\\033[36m\\][$COCONUT_PROPOSAL_ID]\\[\\033[0m\\] \\w \\$ "');
             return {
                 script: `# Source system bashrc if it exists
 [ -f ~/.bashrc ] && source ~/.bashrc
 
-# Custom GAIT initialization  
+# Custom Coconut initialization  
 ${bashScript}`
             };
     }

package/dist/lib/terminal/terminal-manager.d.ts

@@ -9,10 +9,12 @@ export interface TerminalSession {
     lastActivity: Date;
     enableLogging?: boolean;
     logFilePath?: string;
+    backlog: string;
 }
 export declare class TerminalManager {
     private sessions;
     private cleanupInterval;
+    private static readonly MAX_BACKLOG_BYTES;
     constructor();
     createSession(proposalId: string, enableLogging?: boolean, shellPreference?: ShellType, startupCommand?: string): Promise<TerminalSession>;
     getSession(sessionId: string): TerminalSession | undefined;

package/dist/lib/terminal/terminal-manager.js

@@ -7,6 +7,7 @@ import { getShellPath, getShellArgs, prepareShellInit } from './shell-utils.js';
 export class TerminalManager {
     sessions = new Map();
     cleanupInterval;
+    static MAX_BACKLOG_BYTES = 200_000; // ~200KB of recent output
     constructor() {
         // Clean up inactive sessions every 5 minutes
         this.cleanupInterval = setInterval(() => {
@@ -18,7 +19,7 @@ export class TerminalManager {
         // Get the project root directory
         let projectRoot;
         if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-            // GAIT_DEV_ROOT points to the .gait directory in development; project root is its parent
+            // GAIT_DEV_ROOT points to the .nut directory in development; project root is its parent
             projectRoot = path.resolve(process.env.GAIT_DEV_ROOT, '..');
         }
         else if (process.env.GAIT_DATA_PATH) {
@@ -30,8 +31,8 @@ export class TerminalManager {
         // Prepare context information
         const contextInfo = {
             proposalId,
-            proposalPath: path.join(projectRoot, '.gait', 'proposals', `${proposalId}.md`),
-            contextPath: path.join(projectRoot, '.gait', 'context'),
+            proposalPath: path.join(projectRoot, '.nut', 'proposals', `${proposalId}.md`),
+            contextPath: path.join(projectRoot, '.nut', 'context'),
             projectRoot,
         };
         // Get the shell path based on user preference
@@ -45,13 +46,13 @@ export class TerminalManager {
         let tempDirForZsh;
         if (shellName === 'zsh' && needsEnvVar) {
             // For zsh, create a temp directory with .zshrc
-            tempDirForZsh = path.join(projectRoot, '.gait', 'tmp', `zsh-${sessionId}`);
+            tempDirForZsh = path.join(projectRoot, '.nut', 'tmp', `zsh-${sessionId}`);
             fs.mkdirSync(tempDirForZsh, { recursive: true });
             initScriptPath = path.join(tempDirForZsh, '.zshrc');
         }
         else {
             // For other shells, use regular init script
-            initScriptPath = path.join(projectRoot, '.gait', 'tmp', `init-${sessionId}.sh`);
+            initScriptPath = path.join(projectRoot, '.nut', 'tmp', `init-${sessionId}.sh`);
             const tmpDir = path.dirname(initScriptPath);
             fs.mkdirSync(tmpDir, { recursive: true });
         }
@@ -65,7 +66,7 @@ export class TerminalManager {
         // Set up logging if enabled
         let logFilePath;
         if (enableLogging) {
-            const sessionsDir = path.join(projectRoot, '.gait', 'sessions');
+            const sessionsDir = path.join(projectRoot, '.nut', 'sessions');
             try {
                 fs.mkdirSync(sessionsDir, { recursive: true });
                 logFilePath = path.join(sessionsDir, `${sessionId}.log`);
@@ -83,9 +84,9 @@ export class TerminalManager {
         // Prepare environment variables
         const env = {
             ...process.env,
-            GAIT_PROPOSAL_ID: proposalId,
-            GAIT_CONTEXT_PATH: path.join(projectRoot, '.gait', 'context'),
-            GAIT_PROPOSAL_PATH: path.join(projectRoot, '.gait', 'proposals', `${proposalId}.md`),
+            COCONUT_PROPOSAL_ID: proposalId,
+            COCONUT_CONTEXT_PATH: path.join(projectRoot, '.nut', 'context'),
+            COCONUT_PROPOSAL_PATH: path.join(projectRoot, '.nut', 'proposals', `${proposalId}.md`),
             TERM: 'xterm-256color',
             COLORTERM: 'truecolor',
         };
@@ -112,6 +113,7 @@ export class TerminalManager {
             lastActivity: new Date(),
             enableLogging,
             logFilePath,
+            backlog: '',
         };
         this.sessions.set(sessionId, session);
         // Set up PTY event handlers
@@ -128,6 +130,17 @@ export class TerminalManager {
                     console.error('Error writing to session log:', error);
                 }
             }
+            // Maintain in-memory backlog (trim to last MAX_BACKLOG_BYTES)
+            try {
+                // Append and trim to max size
+                session.backlog = (session.backlog + data);
+                if (session.backlog.length > TerminalManager.MAX_BACKLOG_BYTES) {
+                    session.backlog = session.backlog.slice(-TerminalManager.MAX_BACKLOG_BYTES);
+                }
+            }
+            catch (e) {
+                // Best-effort; do not crash on backlog errors
+            }
             if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
                 session.websocket.send(JSON.stringify({
                     type: 'data',
@@ -188,6 +201,15 @@ export class TerminalManager {
         }
         session.websocket = ws;
         session.lastActivity = new Date();
+        // On attach, send a snapshot of recent backlog so refreshed clients render prior output
+        try {
+            if (session.backlog && session.backlog.length > 0 && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'snapshot', data: session.backlog }));
+            }
+        }
+        catch (e) {
+            // Non-fatal; continue with live streaming
+        }
         // Set up WebSocket event handlers
         ws.on('message', (message) => {
             try {

package/dist/routes/api/v1/agents/[id]/route.js

@@ -6,16 +6,16 @@ const app = new Hono();
 function getAgentsPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-        // Dev mode: use project root .gait directory
+        // Dev mode: use project root .nut directory
         basePath = process.env.GAIT_DEV_ROOT;
     }
     else if (process.env.GAIT_DATA_PATH) {
         // Production mode: use GAIT_DATA_PATH (set by CLI)
-        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.gait');
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
     }
     else {
-        // Fallback: use current directory .gait
-        basePath = path.resolve(process.cwd(), '.gait');
+        // Fallback: use current directory .nut
+        basePath = path.resolve(process.cwd(), '.nut');
     }
     return path.join(basePath, 'agents');
 }

package/dist/routes/api/v1/agents/route.js

@@ -6,16 +6,16 @@ const app = new Hono();
 function getAgentsPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-        // Dev mode: use project root .gait directory
+        // Dev mode: use project root .nut directory
         basePath = process.env.GAIT_DEV_ROOT;
     }
     else if (process.env.GAIT_DATA_PATH) {
         // Production mode: use GAIT_DATA_PATH (set by CLI)
-        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.gait');
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
     }
     else {
-        // Fallback: use current directory .gait
-        basePath = path.resolve(process.cwd(), '.gait');
+        // Fallback: use current directory .nut
+        basePath = path.resolve(process.cwd(), '.nut');
     }
     return path.join(basePath, 'agents');
 }

package/dist/routes/api/v1/ai/route.js

@@ -35,15 +35,12 @@ export async function POST(c) {
         if (!userMessage) {
             return c.json({ error: "Message is required" }, 400);
         }
-        // Try environment variable first, then global config
-        let openRouterKey = process.env.OPENROUTER_API_KEY;
-        if (!openRouterKey) {
-            openRouterKey = getGlobalApiKey('openrouter');
-        }
+        // Prefer global config key (set via CLI/UI), fallback to env var
+        let openRouterKey = getGlobalApiKey('openrouter') || process.env.OPENROUTER_API_KEY;
         if (!openRouterKey) {
             return c.json({
                 error: "OpenRouter API key not configured",
-                hint: "Set OPENROUTER_API_KEY environment variable or run 'coconut config set-key -p openrouter' to configure globally"
+                hint: "Set via 'coconut config set-key -p openrouter -k <KEY>' (or 'nut config set-key -p openrouter -k <KEY>'), or set OPENROUTER_API_KEY env var"
             }, 500);
         }
         const baseSystem = systemOverride || getSystemPrompt(context, contextContent);

package/dist/routes/api/v1/chats/[id]/route.js

@@ -3,16 +3,16 @@ import { join, resolve } from "path";
 function getChatsPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-        // Dev mode: use project root .gait directory
+        // Dev mode: use project root .nut directory
         basePath = process.env.GAIT_DEV_ROOT;
     }
     else if (process.env.GAIT_DATA_PATH) {
         // Production mode: use GAIT_DATA_PATH (set by CLI)
-        basePath = resolve(process.env.GAIT_DATA_PATH, '.gait');
+        basePath = resolve(process.env.GAIT_DATA_PATH, '.nut');
     }
     else {
-        // Fallback: use current directory .gait
-        basePath = resolve(process.cwd(), '.gait');
+        // Fallback: use current directory .nut
+        basePath = resolve(process.cwd(), '.nut');
     }
     return join(basePath, 'chats');
 }