osborn 0.8.0 → 0.8.1

package/bin/cli.js

@@ -41,10 +41,6 @@ Example:
   process.exit(0)
 }
 
-// Run the agent using tsx
-const agentPath = join(__dirname, '..', 'src', 'index.ts')
-const tsxPath = join(__dirname, '..', 'node_modules', '.bin', 'tsx')
-
 // Determine mode (default to 'dev' if no mode specified)
 let mode = 'dev'
 if (args.includes('start')) {
@@ -54,11 +50,31 @@ if (args.includes('start')) {
   args.splice(args.indexOf('dev'), 1)
 }
 
-const child = spawn(tsxPath, [agentPath, mode, ...args], {
-  stdio: 'inherit',
-  cwd: join(__dirname, '..'),
-  env: process.env,
-})
+// Use src/index.ts (dev) if available, otherwise dist/index.js (npm install)
+import { existsSync } from 'fs'
+const srcPath = join(__dirname, '..', 'src', 'index.ts')
+const distPath = join(__dirname, '..', 'dist', 'index.js')
+
+let child
+if (existsSync(srcPath)) {
+  // Dev mode: run via tsx
+  const tsxPath = join(__dirname, '..', 'node_modules', '.bin', 'tsx')
+  child = spawn(tsxPath, [srcPath, mode, ...args], {
+    stdio: 'inherit',
+    cwd: join(__dirname, '..'),
+    env: process.env,
+  })
+} else if (existsSync(distPath)) {
+  // Production: run compiled JS directly
+  child = spawn('node', [distPath, mode, ...args], {
+    stdio: 'inherit',
+    cwd: join(__dirname, '..'),
+    env: process.env,
+  })
+} else {
+  console.error('Error: Neither src/index.ts nor dist/index.js found')
+  process.exit(1)
+}
 
 child.on('error', (err) => {
   console.error('Failed to start agent:', err.message)

package/dist/claude-auth.d.ts

@@ -29,8 +29,8 @@ export interface ClaudeAuthHandle {
  */
 export declare function isClaudeAuthenticated(): boolean;
 /**
- * Check auth via `claude auth status --json` (most reliable).
- * Uses execSync to avoid node-pty PATH issues on macOS.
+ * Check auth via `claude auth status` (most reliable).
+ * Uses resolved path to avoid posix_spawnp PATH issues.
  */
 export declare function checkClaudeAuthStatus(): Promise<boolean>;
 /**

package/dist/claude-auth.js

@@ -15,8 +15,61 @@
  */
 import * as pty from 'node-pty';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { execSync } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
+/**
+ * Resolve the full path to the `claude` binary.
+ * node-pty uses posix_spawnp which may not find binaries in nvm/homebrew paths.
+ * Shell-based `which` resolves the full PATH including .zshrc/.bashrc additions.
+ * Also checks Docker/Linux global npm paths for Fly.io/container deployments.
+ */
+let _cachedClaudePath = null;
+function resolveClaudePath() {
+    if (_cachedClaudePath)
+        return _cachedClaudePath;
+    // 1. Shell-based resolution — picks up nvm, homebrew, etc.
+    try {
+        const resolved = execSync('which claude', { encoding: 'utf-8', timeout: 5000 }).trim();
+        if (resolved && existsSync(resolved)) {
+            _cachedClaudePath = resolved;
+            return resolved;
+        }
+    }
+    catch { }
+    // 2. Fallback: check common locations (macOS, Linux, Docker, nvm)
+    const candidates = [
+        // Linux / Docker / Fly.io (npm install -g @anthropic-ai/claude-code)
+        '/usr/local/bin/claude',
+        '/usr/bin/claude',
+        // macOS Homebrew (Apple Silicon)
+        '/opt/homebrew/bin/claude',
+        // nvm (current node version — macOS/Linux)
+        join(homedir(), '.nvm/versions/node', process.version, 'bin/claude'),
+        // macOS Homebrew cask (Intel)
+        '/usr/local/Caskroom/claude-code/latest/claude',
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            console.log(`🔑 Found claude at: ${p}`);
+            _cachedClaudePath = p;
+            return p;
+        }
+    }
+    // 3. Try npm global bin directory (covers custom npm prefix, Docker variants)
+    try {
+        const npmBin = execSync('npm bin -g', { encoding: 'utf-8', timeout: 5000 }).trim();
+        const npmClaudePath = join(npmBin, 'claude');
+        if (existsSync(npmClaudePath)) {
+            console.log(`🔑 Found claude at: ${npmClaudePath} (via npm bin -g)`);
+            _cachedClaudePath = npmClaudePath;
+            return npmClaudePath;
+        }
+    }
+    catch { }
+    console.warn('⚠️ Could not resolve claude binary path — falling back to "claude"');
+    return 'claude'; // last resort — let posix_spawnp try
+}
 // ─────────────────────────────────────────
 // Constants
 // ─────────────────────────────────────────
@@ -68,13 +121,14 @@ export function isClaudeAuthenticated() {
     }
 }
 /**
- * Check auth via `claude auth status --json` (most reliable).
- * Uses execSync to avoid node-pty PATH issues on macOS.
+ * Check auth via `claude auth status` (most reliable).
+ * Uses resolved path to avoid posix_spawnp PATH issues.
  */
 export async function checkClaudeAuthStatus() {
     try {
-        const { execSync } = await import('child_process');
-        const output = execSync('claude auth status', {
+        const claudePath = resolveClaudePath();
+        console.log(`🔑 Checking auth via: ${claudePath} auth status`);
+        const output = execSync(`"${claudePath}" auth status`, {
             encoding: 'utf-8',
             timeout: 10_000,
             env: { ...process.env },
@@ -157,8 +211,9 @@ export function runClaudeAuthFlow(callbacks) {
         },
     };
     const done = new Promise((resolve, reject) => {
-        console.log('🔑 Starting Claude Code authentication flow (setup-token)...');
-        const proc = pty.spawn('claude', ['setup-token'], {
+        const claudePath = resolveClaudePath();
+        console.log(`🔑 Starting Claude Code authentication flow: ${claudePath} setup-token`);
+        const proc = pty.spawn(claudePath, ['setup-token'], {
             name: 'xterm-color',
             cols: 500, // Wide to prevent Ink URL wrapping
             rows: 30,

package/dist/claude-llm.js

@@ -9,7 +9,7 @@
 import { llm, shortuuid, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { EventEmitter } from 'events';
-import { saveSessionMetadata } from './config.js';
+import { saveSessionMetadata, getSessionWorkspace } from './config.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -736,14 +736,10 @@ class ClaudeLLMStream extends llm.LLMStream {
             // Build Claude Agent SDK options
             const resumeSessionId = this.#opts.resumeSessionId;
             const continueSession = this.#opts.continueSession;
-            // Session workspace path for system prompt — uses sessionBaseDir (not cwd) so
-            // workspace always lives in the Osborn install dir regardless of cwd setting
+            // Session workspace path for system prompt — lives under ~/.claude/projects/{slug}/osb/{sessionId}/
             const sessionId = this.#sessionId || this.#opts.resumeSessionId || null;
-            const baseDir = this.#opts.sessionBaseDir || this.#opts.workingDirectory;
-            const workspacePath = sessionId
-                ? (baseDir
-                    ? `${baseDir}/.osborn/sessions/${sessionId}/`
-                    : `.osborn/sessions/${sessionId}/`)
+            const workspacePath = sessionId && this.#opts.workingDirectory
+                ? getSessionWorkspace(this.#opts.workingDirectory, sessionId)
                 : null;
             const allowedTools = this.#opts.allowedTools || [];
             const sdkOptions = {
@@ -775,12 +771,12 @@ class ClaudeLLMStream extends llm.LLMStream {
                         console.log('input,', input, 'input.file_path', filePath, 'agent_type', agentType);
                         console.log(`🔍 canUseTool: ${toolName} filePath="${filePath}" keys=${Object.keys(input || {}).join(',')}`);
                         console.log(`🔍 canUseTool _options keys=[${Object.keys(_options || {}).join(', ')}] title="${_options?.title || ''}" decisionReason="${_options?.decisionReason || ''}" blockedPath="${_options?.blockedPath || ''}"`);
-                        if (filePath.includes('.osborn/sessions/') || filePath.includes('.osborn/research/')) {
-                            // Block writes to spec.md and library/ — the fast brain manages these
+                        if (filePath.includes('/osb/') || filePath.includes('.osborn/sessions/') || filePath.includes('.osborn/research/')) {
+                            // Block writes to spec.md — the fast brain manages it
                             const fileName = filePath.split('/').pop() || '';
-                            if (fileName === 'spec.md' || filePath.includes('/library/')) {
-                                console.log(`🚫 Blocked research agent write to managed file: ${filePath} (fast brain handles spec.md and library/)`);
-                                return { behavior: 'deny', message: 'spec.md and library/ are managed by the fast brain sub-agent. Do NOT write to them. Return your findings in your response text — the fast brain will organize them into spec.md and library/ automatically.' };
+                            if (fileName === 'spec.md') {
+                                console.log(`🚫 Blocked research agent write to managed file: ${filePath} (fast brain handles spec.md)`);
+                                return { behavior: 'deny', message: 'spec.md is managed by the fast brain. Do NOT write to it. Return your findings in your response text — the fast brain will organize them into spec.md automatically.' };
                             }
                             console.log(`✅ Auto-approved ${toolName} to workspace: ${filePath}`);
                             return { behavior: 'allow', updatedInput: input };
@@ -824,10 +820,10 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         }
                                         // All other agents (main, researcher, reasoner, etc.): workspace only
                                         const filePath = String(toolInput.file_path || '');
-                                        if (filePath && !filePath.includes('.osborn/sessions/') && !filePath.includes('.osborn/research/')) {
+                                        if (filePath && !filePath.includes('/osb/') && !filePath.includes('.osborn/sessions/') && !filePath.includes('.osborn/research/')) {
                                             console.log(`🚫 Research mode: blocked write to ${filePath} (agent_type: ${agentType ?? 'main'})`);
                                             this.#eventEmitter.emit('tool_blocked', { name: toolName, reason: 'Research mode: writes restricted to session workspace' });
-                                            return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' }, reason: 'Research mode: write to .osborn/sessions/ only.' };
+                                            return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' }, reason: 'Research mode: writes restricted to session workspace.' };
                                         }
                                     }
                                     console.log(`🔧 Claude: ${toolName}`);

package/dist/config.d.ts

@@ -168,6 +168,25 @@ export declare function getMostRecentSessionId(projectPath?: string): Promise<st
  * Check if a session exists
  */
 export declare function sessionExists(sessionId: string, projectPath?: string): boolean;
+export interface ClaudeSessionEntry {
+    sessionId: string;
+    projectSlug: string;
+    projectPath: string;
+    cwd: string;
+    timestamp: Date;
+    lastMessage?: string;
+    messageCount: number;
+    filePath: string;
+    fileSize: number;
+}
+/**
+ * Scan ALL Claude Code projects for sessions.
+ * Returns lightweight metadata for every main session JSONL across all projects.
+ * Uses existing getSessionPreview() for last message + message count.
+ *
+ * @param limit - Max sessions to return (default 100, sorted by recency)
+ */
+export declare function listAllClaudeSessions(limit?: number): Promise<ClaudeSessionEntry[]>;
 /**
  * Session summary for context briefing when switching sessions
  */
@@ -229,23 +248,28 @@ export declare function deleteSessionMetadata(projectPath: string, sessionId: st
  * Clean up metadata for sessions that no longer exist
  */
 export declare function cleanupOrphanedMetadata(projectPath: string): Promise<number>;
-export declare function getSessionWorkspace(projectPath: string, sessionId: string): string;
-export declare function ensureSessionWorkspace(projectPath: string, sessionId: string): string;
+/**
+ * Get the session workspace path.
+ * @param workingDir - The project working directory (used to compute project slug)
+ * @param sessionId - The session UUID
+ */
+export declare function getSessionWorkspace(workingDir: string, sessionId: string): string;
+export declare function ensureSessionWorkspace(workingDir: string, sessionId: string): string;
 /**
  * Rename a session workspace folder to match the SDK session ID.
  * Returns the new path, or null if rename was not needed/possible.
  */
-export declare function renameSessionWorkspace(projectPath: string, oldSessionId: string, newSessionId: string): string | null;
-export declare function getResearchDir(projectPath: string, sessionId: string): string;
-export declare function ensureResearchDir(projectPath: string, sessionId: string): string;
+export declare function renameSessionWorkspace(workingDir: string, oldSessionId: string, newSessionId: string): string | null;
+export declare function getResearchDir(workingDir: string, sessionId: string): string;
+export declare function ensureResearchDir(workingDir: string, sessionId: string): string;
 /**
  * Read the session spec document (spec.md) if it exists
  */
-export declare function readSessionSpec(projectPath: string, sessionId: string): string | null;
+export declare function readSessionSpec(workingDir: string, sessionId: string): string | null;
 /**
- * List files in the session library directory
+ * List files in the session library directory (deprecated — library removed)
  */
-export declare function listLibraryFiles(projectPath: string, sessionId: string): string[];
+export declare function listLibraryFiles(_workingDir: string, _sessionId: string): string[];
 export interface ResearchArtifact {
     fileName: string;
     filePath: string;
@@ -253,11 +277,9 @@ export interface ResearchArtifact {
     size: number;
     updatedAt: string;
 }
-export declare function listResearchArtifacts(projectPath: string, sessionId: string): ResearchArtifact[];
+export declare function listResearchArtifacts(workingDir: string, sessionId: string): ResearchArtifact[];
 /**
- * List artifacts in a session workspace.
- * When sessionId is provided, scans the per-session folder (.osborn/sessions/{sessionId}/).
- * Without sessionId, falls back to the flat .osborn/sessions/ directory (legacy).
+ * List artifacts in a session workspace (osb/{sessionId}/ under Claude's project dir).
  */
-export declare function listWorkspaceArtifacts(projectPath: string, sessionId?: string): ResearchArtifact[];
+export declare function listWorkspaceArtifacts(workingDir: string, sessionId?: string): ResearchArtifact[];
 export {};

package/dist/config.js

@@ -503,6 +503,116 @@ export function sessionExists(sessionId, projectPath) {
     const sessionFile = join(sessionDir, `${sessionId}.jsonl`);
     return existsSync(sessionFile);
 }
+/**
+ * Reverse a project slug back to a path (best-effort — replace leading dash, then dashes→slashes).
+ * "-Users-foo-bar" → "/Users/foo/bar"
+ */
+function slugToPath(slug) {
+    return slug.replace(/^-/, '/').replace(/-/g, '/');
+}
+const UUID_JSONL_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+/**
+ * Extract cwd from first user message in a JSONL file.
+ * Reuses the existing readline-based parsing pattern.
+ */
+async function extractCwd(filePath) {
+    return new Promise((resolve) => {
+        const fileStream = createReadStream(filePath, { end: 8192 }); // first 8KB
+        const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === 'user' && obj.cwd) {
+                    rl.close();
+                    fileStream.destroy();
+                    resolve(obj.cwd);
+                }
+            }
+            catch { }
+        });
+        rl.on('close', () => resolve(''));
+        rl.on('error', () => resolve(''));
+    });
+}
+/**
+ * Scan ALL Claude Code projects for sessions.
+ * Returns lightweight metadata for every main session JSONL across all projects.
+ * Uses existing getSessionPreview() for last message + message count.
+ *
+ * @param limit - Max sessions to return (default 100, sorted by recency)
+ */
+export async function listAllClaudeSessions(limit = 100) {
+    const projectsDir = getClaudeProjectsDir();
+    if (!existsSync(projectsDir))
+        return [];
+    // 1. Discover all project folders
+    const projectFolders = readdirSync(projectsDir).filter(name => {
+        const fullPath = join(projectsDir, name);
+        try {
+            return statSync(fullPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    // 2. Collect all JSONL files with stat info (fast — no file reads yet)
+    const candidates = [];
+    for (const slug of projectFolders) {
+        const projectDir = join(projectsDir, slug);
+        try {
+            const files = readdirSync(projectDir);
+            for (const file of files) {
+                if (!UUID_JSONL_RE.test(file))
+                    continue;
+                const fullPath = join(projectDir, file);
+                try {
+                    const stats = statSync(fullPath);
+                    if (stats.size > 500) { // Skip trivially small files
+                        candidates.push({
+                            filePath: fullPath,
+                            slug,
+                            sessionId: file.replace('.jsonl', ''),
+                            mtime: stats.mtime,
+                            size: stats.size,
+                        });
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    // 3. Sort by mtime descending, take top N for detailed reads
+    candidates.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const topCandidates = candidates.slice(0, limit);
+    // 4. Read metadata using existing getSessionPreview + cwd extraction
+    const sessions = [];
+    for (const c of topCandidates) {
+        try {
+            const [preview, cwd] = await Promise.all([
+                getSessionPreview(c.filePath),
+                extractCwd(c.filePath),
+            ]);
+            if (preview.messageCount < 2)
+                continue;
+            sessions.push({
+                sessionId: c.sessionId,
+                projectSlug: c.slug,
+                projectPath: cwd || slugToPath(c.slug),
+                cwd: cwd || slugToPath(c.slug),
+                timestamp: c.mtime,
+                lastMessage: preview.lastMessage,
+                messageCount: preview.messageCount,
+                filePath: c.filePath,
+                fileSize: c.size,
+            });
+        }
+        catch { }
+    }
+    return sessions;
+}
 /**
  * Get a summary of a session for context briefing
  * Extracts last few messages and mode info for realtime agent
@@ -729,15 +839,22 @@ export async function cleanupOrphanedMetadata(projectPath) {
     return cleanedCount;
 }
 // ============================================================
-// SESSION WORKSPACE - For research artifacts and session library
+// SESSION WORKSPACE — Co-located with Claude's native JSONL
+// ~/.claude/projects/{slug}/osb/{sessionId}/
 // ============================================================
-export function getSessionWorkspace(projectPath, sessionId) {
-    return join(projectPath, '.osborn', 'sessions', sessionId);
+/**
+ * Get the session workspace path.
+ * @param workingDir - The project working directory (used to compute project slug)
+ * @param sessionId - The session UUID
+ */
+export function getSessionWorkspace(workingDir, sessionId) {
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+    const slug = projectPathToClaudeFolderName(workingDir);
+    return join(claudeDir, 'projects', slug, 'osb', sessionId);
 }
-export function ensureSessionWorkspace(projectPath, sessionId) {
-    const dir = getSessionWorkspace(projectPath, sessionId);
-    const libraryDir = join(dir, 'library');
-    mkdirSync(libraryDir, { recursive: true });
+export function ensureSessionWorkspace(workingDir, sessionId) {
+    const dir = getSessionWorkspace(workingDir, sessionId);
+    mkdirSync(dir, { recursive: true });
     // Create default spec.md if it doesn't exist (won't overwrite on resumed sessions)
     const specPath = join(dir, 'spec.md');
     if (!existsSync(specPath)) {
@@ -783,11 +900,11 @@ export function ensureSessionWorkspace(projectPath, sessionId) {
  * Rename a session workspace folder to match the SDK session ID.
  * Returns the new path, or null if rename was not needed/possible.
  */
-export function renameSessionWorkspace(projectPath, oldSessionId, newSessionId) {
+export function renameSessionWorkspace(workingDir, oldSessionId, newSessionId) {
     if (oldSessionId === newSessionId)
         return null;
-    const oldDir = getSessionWorkspace(projectPath, oldSessionId);
-    const newDir = getSessionWorkspace(projectPath, newSessionId);
+    const oldDir = getSessionWorkspace(workingDir, oldSessionId);
+    const newDir = getSessionWorkspace(workingDir, newSessionId);
     if (!existsSync(oldDir))
         return null;
     if (existsSync(newDir))
@@ -797,22 +914,22 @@ export function renameSessionWorkspace(projectPath, oldSessionId, newSessionId)
         return newDir;
     }
     catch (err) {
-        console.error(`⚠️ Failed to rename workspace ${oldSessionId} → ${newSessionId}:`, err);
+        console.error(`Failed to rename workspace ${oldSessionId} → ${newSessionId}:`, err);
         return null;
     }
 }
 // Deprecated aliases for backward compatibility
-export function getResearchDir(projectPath, sessionId) {
-    return getSessionWorkspace(projectPath, sessionId);
+export function getResearchDir(workingDir, sessionId) {
+    return getSessionWorkspace(workingDir, sessionId);
 }
-export function ensureResearchDir(projectPath, sessionId) {
-    return ensureSessionWorkspace(projectPath, sessionId);
+export function ensureResearchDir(workingDir, sessionId) {
+    return ensureSessionWorkspace(workingDir, sessionId);
 }
 /**
  * Read the session spec document (spec.md) if it exists
  */
-export function readSessionSpec(projectPath, sessionId) {
-    const specPath = join(getSessionWorkspace(projectPath, sessionId), 'spec.md');
+export function readSessionSpec(workingDir, sessionId) {
+    const specPath = join(getSessionWorkspace(workingDir, sessionId), 'spec.md');
     if (!existsSync(specPath))
         return null;
     try {
@@ -823,18 +940,10 @@ export function readSessionSpec(projectPath, sessionId) {
     }
 }
 /**
- * List files in the session library directory
+ * List files in the session library directory (deprecated — library removed)
  */
-export function listLibraryFiles(projectPath, sessionId) {
-    const libraryDir = join(getSessionWorkspace(projectPath, sessionId), 'library');
-    if (!existsSync(libraryDir))
-        return [];
-    try {
-        return readdirSync(libraryDir);
-    }
-    catch {
-        return [];
-    }
+export function listLibraryFiles(_workingDir, _sessionId) {
+    return [];
 }
 function classifyFile(fileName) {
     const ext = fileName.split('.').pop()?.toLowerCase() || '';
@@ -863,8 +972,8 @@ function scanDirForArtifacts(dir) {
                     scan(fullPath);
                 }
                 else {
-                    // Skip internal index files and .index/ folder
-                    if (entry.startsWith('search-index') || entry === '.index')
+                    // Skip internal index files
+                    if (entry.startsWith('search-index'))
                         continue;
                     results.push({
                         fileName: entry,
@@ -881,17 +990,15 @@ function scanDirForArtifacts(dir) {
     scan(dir);
     return results;
 }
-export function listResearchArtifacts(projectPath, sessionId) {
-    return scanDirForArtifacts(getSessionWorkspace(projectPath, sessionId));
+export function listResearchArtifacts(workingDir, sessionId) {
+    return scanDirForArtifacts(getSessionWorkspace(workingDir, sessionId));
 }
 /**
- * List artifacts in a session workspace.
- * When sessionId is provided, scans the per-session folder (.osborn/sessions/{sessionId}/).
- * Without sessionId, falls back to the flat .osborn/sessions/ directory (legacy).
+ * List artifacts in a session workspace (osb/{sessionId}/ under Claude's project dir).
  */
-export function listWorkspaceArtifacts(projectPath, sessionId) {
-    const dir = sessionId
-        ? join(projectPath, '.osborn', 'sessions', sessionId)
-        : join(projectPath, '.osborn', 'sessions');
+export function listWorkspaceArtifacts(workingDir, sessionId) {
+    if (!sessionId)
+        return [];
+    const dir = getSessionWorkspace(workingDir, sessionId);
     return scanDirForArtifacts(dir);
 }

package/dist/fast-brain.d.ts

@@ -5,7 +5,7 @@
  * The realtime voice model is a thin teleprompter — it speaks what this module returns.
  *
  * Capabilities:
- * - Read/write session files (spec.md + library/)
+ * - Read/write session files (spec.md)
  * - Web search for quick factual lookups
  * - Record user decisions and preferences into spec.md
  * - Trigger deep research (via callbacks to index.ts)
@@ -71,7 +71,7 @@ export declare function askFastBrain(workingDir: string, sessionId: string, ques
 }): Promise<FastBrainResponse>;
 /**
  * Process a batch of research content chunks through the fast brain.
- * Updates spec.md and library/ files incrementally during research.
+ * Updates spec.md incrementally during research.
  *
  * @param isRefinement - true for the final post-research consolidation pass (higher token budget)
  */
@@ -88,7 +88,7 @@ export declare function processResearchChunk(workingDir: string, sessionId: stri
  */
 export declare function augmentResearchResult(workingDir: string, sessionId: string, task: string, agentResult: string): Promise<string>;
 /**
- * Update spec.md and library/ files after research completes.
+ * Update spec.md after research completes.
  * Reads FULL untruncated data directly from Claude Agent SDK JSONL files
  * instead of receiving pre-truncated content chunks.
  *
@@ -97,7 +97,7 @@ export declare function augmentResearchResult(workingDir: string, sessionId: str
  * - readSessionHistory() — last 50 assistant messages (agent reasoning/analysis)
  * - getSubagentTranscripts() — all sub-agent findings
  *
- * Returns { spec, libraryFiles } or null if update failed.
+ * Returns { spec } or null if update failed.
  */
 export declare function updateSpecFromJSONL(workingDir: string, sessionId: string, task: string, researchLog: string[], sessionBaseDir?: string): Promise<{
     spec: string | null;
@@ -139,8 +139,8 @@ export declare function generateProactivePrompt(workingDir: string, sessionId: s
  * Generate a structured visual document (comparison table, Mermaid diagram,
  * analysis, or summary) from research findings.
  *
- * Reads spec.md, JSONL results, and library for context.
- * Writes the result to library/ and returns the filename + content.
+ * Reads spec.md and JSONL results for context.
+ * Writes the result to workspace and returns the filename + content.
  */
 export declare function generateVisualDocument(workingDir: string, sessionId: string, request: string, documentType: 'comparison' | 'diagram' | 'analysis' | 'summary', sessionBaseDir?: string): Promise<{
     fileName: string;