tlc-claude-code 1.4.2 → 1.4.5

package/dashboard/dist/App.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text, useApp, useInput } from 'ink';
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useEffect } from 'react';
 // Layout components
 import { Shell } from './components/layout/Shell.js';
 import { Sidebar, SidebarItem } from './components/layout/Sidebar.js';
@@ -20,6 +20,8 @@ import RouterPane from './components/RouterPane.js';
 import { UsagePane } from './components/UsagePane.js';
 import { SettingsPanel } from './components/SettingsPanel.js';
 import { AgentRegistryPane } from './components/AgentRegistryPane.js';
+import { BugsPane } from './components/BugsPane.js';
+import { UpdateBanner } from './components/UpdateBanner.js';
 // Utility components
 import { CommandPalette } from './components/CommandPalette.js';
 import { KeyboardHelp } from './components/KeyboardHelp.js';
@@ -36,6 +38,7 @@ const navItems = [
     { key: 'github', label: 'GitHub', icon: '🐙', shortcut: '7' },
     { key: 'health', label: 'Health', icon: '💚', shortcut: '8' },
     { key: 'router', label: 'Router', icon: '🔀', shortcut: '9' },
+    { key: 'bugs', label: 'Bugs', icon: '🐛', shortcut: 'b' },
     { key: 'settings', label: 'Settings', icon: '⚙️', shortcut: '0' },
 ];
 // Sample data for development
@@ -107,6 +110,7 @@ const commands = [
     { id: 'view:agents', name: 'Go to Agents', description: 'View agents', shortcut: '4', category: 'Navigation' },
     { id: 'view:logs', name: 'Go to Logs', description: 'View logs', shortcut: '6', category: 'Navigation' },
     { id: 'view:router', name: 'Go to Router', description: 'View model router', shortcut: '9', category: 'Navigation' },
+    { id: 'view:bugs', name: 'Go to Bugs', description: 'View and submit bugs', shortcut: 'b', category: 'Navigation' },
     { id: 'cmd:run-tests', name: 'Run Tests', description: 'Run test suite', category: 'Commands' },
     { id: 'cmd:build', name: 'Build Phase', description: 'Build current phase', category: 'Commands' },
 ];
@@ -131,6 +135,24 @@ export function App({ isTTY = true }) {
     // Data state
     const [selectedProject, setSelectedProject] = useState(null);
     const [connectionState] = useState('connected');
+    // Update banner state
+    const [updateInfo, setUpdateInfo] = useState(null);
+    const [updateDismissed, setUpdateDismissed] = useState(false);
+    // Check for updates on mount
+    useEffect(() => {
+        async function checkUpdates() {
+            try {
+                // @ts-ignore - version-checker is a JS module
+                const { checkForUpdates } = await import('../server/lib/version-checker.js');
+                const info = await checkForUpdates();
+                setUpdateInfo(info);
+            }
+            catch {
+                // Silently fail if version checker not available
+            }
+        }
+        checkUpdates();
+    }, []);
     // Keyboard handling
     useInput((input, key) => {
         // Global shortcuts
@@ -180,6 +202,8 @@ export function App({ isTTY = true }) {
                 setActiveView('health');
             if (input === '9')
                 setActiveView('router');
+            if (input === 'b')
+                setActiveView('bugs');
             if (input === '0')
                 setActiveView('settings');
             // Tab cycles through views
@@ -229,6 +253,8 @@ export function App({ isTTY = true }) {
                 return (_jsxs(Box, { flexDirection: "row", flexGrow: 1, children: [_jsx(Box, { width: "50%", flexDirection: "column", children: _jsx(HealthPane, {}) }), _jsx(Box, { width: "50%", flexDirection: "column", marginLeft: 1, children: _jsx(ServicesPane, { services: sampleServices, isActive: true }) })] }));
             case 'router':
                 return (_jsxs(Box, { flexDirection: "row", flexGrow: 1, children: [_jsx(Box, { width: "60%", flexDirection: "column", children: _jsx(RouterPane, {}) }), _jsx(Box, { width: "40%", flexDirection: "column", marginLeft: 1, children: _jsx(UsagePane, {}) })] }));
+            case 'bugs':
+                return _jsx(BugsPane, { isActive: true, isTTY: isTTY });
             case 'settings':
                 return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(SettingsPanel, { config: sampleConfig }), _jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", padding: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "cyan", children: "Quick Links" }), _jsx(Text, { color: "gray", children: "[U] Usage   [Q] Quality   [D] Docs   [W] Workspace   [A] Audit" })] }) })] }));
             default:
@@ -241,5 +267,5 @@ export function App({ isTTY = true }) {
     const renderHeader = () => (_jsx(Header, { title: "TLC Dashboard", subtitle: viewTitle, status: connectionState === 'connected' ? 'online' : 'offline', actions: _jsxs(Box, { children: [_jsx(ConnectionStatus, { state: connectionState }), _jsx(Text, { color: "gray", children: " | " }), _jsx(Text, { dimColor: true, children: "v1.2.24" })] }) }));
     // Render footer/status bar
     const renderFooter = () => (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { dimColor: true, children: "Tab: cycle | 1-0: jump | Ctrl+B: sidebar | Ctrl+K: commands | ?: help | Ctrl+Q: quit" }), _jsx(StatusBar, {})] }));
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Shell, { header: renderHeader(), footer: renderFooter(), sidebar: showSidebar ? renderSidebar() : undefined, showSidebar: showSidebar, sidebarWidth: 20, children: _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Box, { borderStyle: "single", borderColor: "cyan", borderBottom: true, borderTop: false, borderLeft: false, borderRight: false, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: viewTitle }), selectedProject && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u203A " }), _jsx(Text, { children: selectedProject.name })] }))] }), _jsx(Box, { flexGrow: 1, children: renderMainContent() })] }) }), showCommandPalette && (_jsx(Box, { position: "absolute", width: "60%", height: "50%", marginLeft: 10, marginTop: 5, borderStyle: "double", borderColor: "cyan", flexDirection: "column", children: _jsx(CommandPalette, { commands: commands, onSelect: handleCommandSelect, onClose: () => setShowCommandPalette(false) }) })), showHelp && (_jsx(Box, { position: "absolute", width: "70%", height: "80%", marginLeft: 8, marginTop: 3, borderStyle: "double", borderColor: "yellow", flexDirection: "column", children: _jsx(KeyboardHelp, { shortcuts: shortcuts, onClose: () => setShowHelp(false) }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsxs(Shell, { header: renderHeader(), footer: renderFooter(), sidebar: showSidebar ? renderSidebar() : undefined, showSidebar: showSidebar, sidebarWidth: 20, children: [updateInfo && !updateDismissed && (_jsx(UpdateBanner, { current: updateInfo.current, latest: updateInfo.latest, updateAvailable: updateInfo.updateAvailable, changelog: updateInfo.changelog, dismissable: true, onDismiss: () => setUpdateDismissed(true), compact: false, isActive: !showCommandPalette && !showHelp })), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Box, { borderStyle: "single", borderColor: "cyan", borderBottom: true, borderTop: false, borderLeft: false, borderRight: false, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: viewTitle }), selectedProject && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u203A " }), _jsx(Text, { children: selectedProject.name })] }))] }), _jsx(Box, { flexGrow: 1, children: renderMainContent() })] })] }), showCommandPalette && (_jsx(Box, { position: "absolute", width: "60%", height: "50%", marginLeft: 10, marginTop: 5, borderStyle: "double", borderColor: "cyan", flexDirection: "column", children: _jsx(CommandPalette, { commands: commands, onSelect: handleCommandSelect, onClose: () => setShowCommandPalette(false) }) })), showHelp && (_jsx(Box, { position: "absolute", width: "70%", height: "80%", marginLeft: 8, marginTop: 3, borderStyle: "double", borderColor: "yellow", flexDirection: "column", children: _jsx(KeyboardHelp, { shortcuts: shortcuts, onClose: () => setShowHelp(false) }) }))] }));
 }

package/dashboard/dist/api/health-diagnostics.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Health diagnostics module for TLC Dashboard
+ * Provides system health checks with self-repair suggestions
+ */
+export interface DiagnosticCheck {
+    name: string;
+    status: 'ok' | 'warning' | 'error' | 'unknown';
+    message: string;
+    fix: string | null;
+}
+export interface DiagnosticsResult {
+    overall: 'healthy' | 'degraded' | 'unhealthy';
+    checks: DiagnosticCheck[];
+}
+/**
+ * Checks if .tlc.json configuration file exists
+ */
+export declare function checkConfig(projectDir: string): Promise<DiagnosticCheck>;
+/**
+ * Checks if required project files exist
+ */
+export declare function checkRequiredFiles(projectDir: string): Promise<DiagnosticCheck>;
+/**
+ * Runs all diagnostic checks and determines overall health status
+ */
+export declare function runDiagnostics(projectDir: string): Promise<DiagnosticsResult>;

package/dashboard/dist/api/health-diagnostics.js

@@ -0,0 +1,85 @@
+/**
+ * Health diagnostics module for TLC Dashboard
+ * Provides system health checks with self-repair suggestions
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Checks if .tlc.json configuration file exists
+ */
+export async function checkConfig(projectDir) {
+    const configPath = path.join(projectDir, '.tlc.json');
+    try {
+        await fs.access(configPath);
+        return {
+            name: 'TLC Configuration',
+            status: 'ok',
+            message: 'Config found',
+            fix: null,
+        };
+    }
+    catch {
+        return {
+            name: 'TLC Configuration',
+            status: 'warning',
+            message: 'No .tlc.json found',
+            fix: 'Run: tlc init',
+        };
+    }
+}
+/**
+ * Checks if required project files exist
+ */
+export async function checkRequiredFiles(projectDir) {
+    const required = ['package.json', '.planning/ROADMAP.md'];
+    const missing = [];
+    for (const file of required) {
+        const filePath = path.join(projectDir, file);
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            missing.push(file);
+        }
+    }
+    if (missing.length === 0) {
+        return {
+            name: 'Required Files',
+            status: 'ok',
+            message: 'All present',
+            fix: null,
+        };
+    }
+    return {
+        name: 'Required Files',
+        status: 'warning',
+        message: `Missing: ${missing.join(', ')}`,
+        fix: 'Run: tlc init',
+    };
+}
+/**
+ * Runs all diagnostic checks and determines overall health status
+ */
+export async function runDiagnostics(projectDir) {
+    const checks = [];
+    // Run all checks
+    checks.push(await checkConfig(projectDir));
+    checks.push(await checkRequiredFiles(projectDir));
+    // Determine overall status
+    const hasErrors = checks.some(c => c.status === 'error');
+    const hasWarnings = checks.some(c => c.status === 'warning');
+    let overall;
+    if (hasErrors) {
+        overall = 'unhealthy';
+    }
+    else if (hasWarnings) {
+        overall = 'degraded';
+    }
+    else {
+        overall = 'healthy';
+    }
+    return {
+        overall,
+        checks,
+    };
+}

package/dashboard/dist/api/health-diagnostics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/api/health-diagnostics.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { vol } from 'memfs';
+// Mock fs modules with memfs
+vi.mock('fs', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs;
+});
+vi.mock('fs/promises', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs.promises;
+});
+// Import after mocks are set up
+import { checkConfig, checkRequiredFiles, runDiagnostics, } from './health-diagnostics.js';
+describe('health-diagnostics', () => {
+    const projectDir = '/test-project';
+    beforeEach(() => {
+        vol.reset();
+        vol.mkdirSync(projectDir, { recursive: true });
+        process.env.TLC_PROJECT_DIR = projectDir;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        delete process.env.TLC_PROJECT_DIR;
+    });
+    describe('checkConfig', () => {
+        it('returns ok when .tlc.json exists', async () => {
+            vol.fromJSON({
+                [`${projectDir}/.tlc.json`]: '{}',
+            });
+            const result = await checkConfig(projectDir);
+            expect(result.name).toBe('TLC Configuration');
+            expect(result.status).toBe('ok');
+            expect(result.message).toBe('Config found');
+            expect(result.fix).toBeNull();
+        });
+        it('returns warning with fix when .tlc.json missing', async () => {
+            // No .tlc.json file
+            const result = await checkConfig(projectDir);
+            expect(result.name).toBe('TLC Configuration');
+            expect(result.status).toBe('warning');
+            expect(result.message).toBe('No .tlc.json found');
+            expect(result.fix).toBe('Run: tlc init');
+        });
+    });
+    describe('checkRequiredFiles', () => {
+        it('returns ok when all required files exist', async () => {
+            vol.fromJSON({
+                [`${projectDir}/package.json`]: '{}',
+                [`${projectDir}/.planning/ROADMAP.md`]: '# Roadmap',
+            });
+            const result = await checkRequiredFiles(projectDir);
+            expect(result.name).toBe('Required Files');
+            expect(result.status).toBe('ok');
+            expect(result.message).toBe('All present');
+            expect(result.fix).toBeNull();
+        });
+        it('returns warning when files are missing', async () => {
+            vol.fromJSON({
+                [`${projectDir}/package.json`]: '{}',
+                // Missing .planning/ROADMAP.md
+            });
+            const result = await checkRequiredFiles(projectDir);
+            expect(result.name).toBe('Required Files');
+            expect(result.status).toBe('warning');
+            expect(result.message).toContain('.planning/ROADMAP.md');
+            expect(result.fix).toBe('Run: tlc init');
+        });
+        it('lists all missing files in message', async () => {
+            // Both files missing
+            const result = await checkRequiredFiles(projectDir);
+            expect(result.status).toBe('warning');
+            expect(result.message).toContain('package.json');
+            expect(result.message).toContain('.planning/ROADMAP.md');
+        });
+    });
+    describe('runDiagnostics', () => {
+        it('returns all checks in result', async () => {
+            vol.fromJSON({
+                [`${projectDir}/.tlc.json`]: '{}',
+                [`${projectDir}/package.json`]: '{}',
+                [`${projectDir}/.planning/ROADMAP.md`]: '# Roadmap',
+            });
+            const result = await runDiagnostics(projectDir);
+            expect(result.checks).toBeDefined();
+            expect(Array.isArray(result.checks)).toBe(true);
+            expect(result.checks.length).toBeGreaterThan(0);
+        });
+        it('returns healthy when all checks ok', async () => {
+            vol.fromJSON({
+                [`${projectDir}/.tlc.json`]: '{}',
+                [`${projectDir}/package.json`]: '{}',
+                [`${projectDir}/.planning/ROADMAP.md`]: '# Roadmap',
+            });
+            const result = await runDiagnostics(projectDir);
+            expect(result.overall).toBe('healthy');
+        });
+        it('returns degraded when warnings but no errors', async () => {
+            vol.fromJSON({
+                // Missing .tlc.json (warning)
+                [`${projectDir}/package.json`]: '{}',
+                [`${projectDir}/.planning/ROADMAP.md`]: '# Roadmap',
+            });
+            const result = await runDiagnostics(projectDir);
+            expect(result.overall).toBe('degraded');
+        });
+        it('returns unhealthy when any check is error', async () => {
+            // Simulate an error condition by having checkConfig return error
+            // For now, test with missing project directory (causes error)
+            const result = await runDiagnostics('/nonexistent/path');
+            // Even with nonexistent path, we get warnings not errors from our current checks
+            // This test verifies the overall calculation logic
+            expect(['degraded', 'unhealthy']).toContain(result.overall);
+        });
+        it('includes diagnostic check names', async () => {
+            vol.fromJSON({
+                [`${projectDir}/.tlc.json`]: '{}',
+                [`${projectDir}/package.json`]: '{}',
+                [`${projectDir}/.planning/ROADMAP.md`]: '# Roadmap',
+            });
+            const result = await runDiagnostics(projectDir);
+            const checkNames = result.checks.map(c => c.name);
+            expect(checkNames).toContain('TLC Configuration');
+            expect(checkNames).toContain('Required Files');
+        });
+    });
+});

package/dashboard/dist/api/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * API utilities for the TLC Dashboard
+ */
+export { safeFetch, safePost, safePut, safeDelete, type FetchResult, type FetchError, type SafeFetchOptions, } from './safeFetch.js';
+export { getNotes, updateNotes, type GetNotesResult, type UpdateNotesResult } from './notes-api.js';

package/dashboard/dist/api/index.js

@@ -0,0 +1,5 @@
+/**
+ * API utilities for the TLC Dashboard
+ */
+export { safeFetch, safePost, safePut, safeDelete, } from './safeFetch.js';
+export { getNotes, updateNotes } from './notes-api.js';

package/dashboard/dist/api/notes-api.d.ts

@@ -0,0 +1,18 @@
+export interface GetNotesResult {
+    content: string;
+    lastModified: string | null;
+    error?: string;
+}
+export interface UpdateNotesResult {
+    success: boolean;
+    lastModified?: string;
+    error?: string;
+}
+/**
+ * Reads the content of PROJECT.md and returns it with the last modified timestamp.
+ */
+export declare function getNotes(): Promise<GetNotesResult>;
+/**
+ * Updates the content of PROJECT.md and returns the new last modified timestamp.
+ */
+export declare function updateNotes(content: string): Promise<UpdateNotesResult>;

package/dashboard/dist/api/notes-api.js

@@ -0,0 +1,68 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Gets the project directory path.
+ * Uses TLC_PROJECT_DIR env var if set, otherwise uses current working directory.
+ */
+function getProjectDir() {
+    return process.env.TLC_PROJECT_DIR || process.cwd();
+}
+/**
+ * Gets the path to PROJECT.md file.
+ */
+function getProjectMdPath() {
+    return path.join(getProjectDir(), 'PROJECT.md');
+}
+/**
+ * Reads the content of PROJECT.md and returns it with the last modified timestamp.
+ */
+export async function getNotes() {
+    const filePath = getProjectMdPath();
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const stats = await fs.stat(filePath);
+        const lastModified = stats.mtime.toISOString();
+        return {
+            content,
+            lastModified,
+        };
+    }
+    catch (error) {
+        const nodeError = error;
+        // File not found - return empty content without error
+        if (nodeError.code === 'ENOENT') {
+            return {
+                content: '',
+                lastModified: null,
+            };
+        }
+        // Other errors - return empty content with error message
+        return {
+            content: '',
+            lastModified: null,
+            error: nodeError.message,
+        };
+    }
+}
+/**
+ * Updates the content of PROJECT.md and returns the new last modified timestamp.
+ */
+export async function updateNotes(content) {
+    const filePath = getProjectMdPath();
+    try {
+        await fs.writeFile(filePath, content, 'utf-8');
+        const stats = await fs.stat(filePath);
+        const lastModified = stats.mtime.toISOString();
+        return {
+            success: true,
+            lastModified,
+        };
+    }
+    catch (error) {
+        const nodeError = error;
+        return {
+            success: false,
+            error: nodeError.message,
+        };
+    }
+}

package/dashboard/dist/api/notes-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dashboard/dist/api/notes-api.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { vol } from 'memfs';
+// Mock fs modules with memfs
+vi.mock('fs', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs;
+});
+vi.mock('fs/promises', async () => {
+    const memfs = await import('memfs');
+    return memfs.fs.promises;
+});
+// Import after mocks are set up
+import { getNotes, updateNotes } from './notes-api.js';
+describe('notes-api', () => {
+    const projectDir = '/test-project';
+    const projectMdPath = `${projectDir}/PROJECT.md`;
+    const mockContent = '# Project Name\n\nThis is a test project.';
+    beforeEach(() => {
+        vol.reset();
+        // Set up project directory
+        vol.mkdirSync(projectDir, { recursive: true });
+        // Set the project directory for tests
+        process.env.TLC_PROJECT_DIR = projectDir;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        delete process.env.TLC_PROJECT_DIR;
+    });
+    describe('getNotes', () => {
+        it('returns content from PROJECT.md', async () => {
+            vol.fromJSON({
+                [projectMdPath]: mockContent,
+            });
+            const result = await getNotes();
+            expect(result.content).toBe(mockContent);
+        });
+        it('returns empty content when file missing', async () => {
+            // No PROJECT.md file created
+            const result = await getNotes();
+            expect(result.content).toBe('');
+            expect(result.lastModified).toBeNull();
+        });
+        it('returns lastModified timestamp', async () => {
+            vol.fromJSON({
+                [projectMdPath]: mockContent,
+            });
+            const result = await getNotes();
+            expect(result.lastModified).toBeDefined();
+            expect(result.lastModified).not.toBeNull();
+            // Should be an ISO timestamp
+            expect(result.lastModified).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+        });
+        it('handles read errors gracefully', async () => {
+            // Create a directory with the same name as PROJECT.md to cause read error
+            vol.mkdirSync(projectMdPath, { recursive: true });
+            const result = await getNotes();
+            expect(result.content).toBe('');
+            expect(result.lastModified).toBeNull();
+            expect(result.error).toBeDefined();
+        });
+        it('uses custom project directory from env', async () => {
+            const customDir = '/custom/path';
+            const customPath = `${customDir}/PROJECT.md`;
+            vol.mkdirSync(customDir, { recursive: true });
+            vol.fromJSON({
+                [customPath]: '# Custom Project',
+            });
+            process.env.TLC_PROJECT_DIR = customDir;
+            const result = await getNotes();
+            expect(result.content).toBe('# Custom Project');
+        });
+    });
+    describe('updateNotes', () => {
+        it('saves content to PROJECT.md', async () => {
+            const newContent = '# Updated Project\n\nNew content.';
+            const result = await updateNotes(newContent);
+            expect(result.success).toBe(true);
+            const savedContent = vol.readFileSync(projectMdPath, 'utf-8');
+            expect(savedContent).toBe(newContent);
+        });
+        it('creates file if missing', async () => {
+            const newContent = '# New Project';
+            // File doesn't exist yet
+            const result = await updateNotes(newContent);
+            expect(result.success).toBe(true);
+            const savedContent = vol.readFileSync(projectMdPath, 'utf-8');
+            expect(savedContent).toBe(newContent);
+        });
+        it('returns new lastModified', async () => {
+            const newContent = '# Updated';
+            const result = await updateNotes(newContent);
+            expect(result.lastModified).toBeDefined();
+            // Should be an ISO timestamp
+            expect(result.lastModified).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+        });
+        it('handles write errors gracefully', async () => {
+            // Try to write to a path that doesn't exist and can't be created
+            process.env.TLC_PROJECT_DIR = '/nonexistent/deeply/nested/path';
+            const result = await updateNotes('content');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('uses custom project directory from env', async () => {
+            const customDir = '/custom/path';
+            const customPath = `${customDir}/PROJECT.md`;
+            vol.mkdirSync(customDir, { recursive: true });
+            process.env.TLC_PROJECT_DIR = customDir;
+            await updateNotes('# Custom content');
+            const savedContent = vol.readFileSync(customPath, 'utf-8');
+            expect(savedContent).toBe('# Custom content');
+        });
+    });
+});

package/dashboard/dist/api/safeFetch.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Self-healing error boundary utilities for fetch operations.
+ * Provides consistent error handling, timeout support, and typed responses.
+ */
+export interface FetchResult<T> {
+    data: T | null;
+    error: FetchError | null;
+    status: 'success' | 'error';
+}
+export interface FetchError {
+    type: 'http' | 'network' | 'timeout' | 'parse' | 'unknown';
+    code?: number;
+    message: string;
+    original?: Error;
+}
+export interface SafeFetchOptions extends RequestInit {
+    timeout?: number;
+}
+/**
+ * Safe fetch wrapper that never throws.
+ * Always returns a FetchResult with either data or error.
+ *
+ * @param url - The URL to fetch
+ * @param options - Fetch options plus optional timeout (default 10s)
+ * @returns Promise<FetchResult<T>> - Always resolves, never rejects
+ *
+ * @example
+ * ```typescript
+ * const { data, error } = await safeFetch<RouterData>('/api/router');
+ * if (error) {
+ *   // Handle error - render error state
+ *   return <ErrorState error={error} onRetry={() => refresh()} />;
+ * }
+ * // Use data safely
+ * ```
+ */
+export declare function safeFetch<T>(url: string, options?: SafeFetchOptions): Promise<FetchResult<T>>;
+/**
+ * POST helper with JSON body
+ */
+export declare function safePost<T, B = unknown>(url: string, body: B, options?: SafeFetchOptions): Promise<FetchResult<T>>;
+/**
+ * PUT helper with JSON body
+ */
+export declare function safePut<T, B = unknown>(url: string, body: B, options?: SafeFetchOptions): Promise<FetchResult<T>>;
+/**
+ * DELETE helper
+ */
+export declare function safeDelete<T>(url: string, options?: SafeFetchOptions): Promise<FetchResult<T>>;
+export default safeFetch;