feat(cli-executor): add streaming option and enhance output handling

- Introduced a `stream` parameter to control output streaming vs. caching.
- Enhanced status determination logic to prioritize valid output over exit codes.
- Updated output structure to include full stdout and stderr when not streaming.

feat(cli-history-store): extend conversation turn schema and migration

- Added `cached`, `stdout_full`, and `stderr_full` fields to the conversation turn schema.
- Implemented database migration to add new columns if they do not exist.
- Updated upsert logic to handle new fields.

feat(codex-lens): implement global symbol index for fast lookups

- Created `GlobalSymbolIndex` class to manage project-wide symbol indexing.
- Added methods for adding, updating, and deleting symbols in the global index.
- Integrated global index updates into directory indexing processes.

feat(codex-lens): optimize search functionality with global index

- Enhanced `ChainSearchEngine` to utilize the global symbol index for faster searches.
- Added configuration option to enable/disable global symbol indexing.
- Updated tests to validate global index functionality and performance.

Author: catlog22

.claude/CLAUDE.md

@@ -15,11 +15,20 @@ Available CLI endpoints are dynamically defined by the config file:
 - Custom API endpoints registered via the Dashboard
 - Managed through the CCW Dashboard Status page
 
-## Agent Execution
+## Tool Execution
 
+### Agent Calls
 - **Always use `run_in_background: false`** for Task tool agent calls: `Task({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
 - **TaskOutput usage**: Only use `TaskOutput({ task_id: "xxx", block: false })` + sleep loop to poll completion status. NEVER read intermediate output during agent/CLI execution - wait for final result only
 
+### CLI Tool Calls (ccw cli)
+- **Always use `run_in_background: true`** for Bash tool when calling ccw cli:
+  ```
+  Bash({ command: "ccw cli -p '...' --tool gemini", run_in_background: true })
+  ```
+- **After CLI call**: Stop immediately - let CLI execute in background, do NOT poll with TaskOutput
+- **View output later**: Use `ccw cli output <id>` to view cached execution results
+
 ## Code Diagnostics
 
 - **Prefer `mcp__ide__getDiagnostics`** for code error checking over shell-based TypeScript compilation

.claude/commands/workflow/lite-plan.md

@@ -38,7 +38,7 @@ Phase 1: Task Analysis & Exploration
    ├─ Parse input (description or .md file)
    ├─ intelligent complexity assessment (Low/Medium/High)
    ├─ Exploration decision (auto-detect or --explore flag)
-   ├─ ⚠️ Context protection: If file reading ≥50k chars → force cli-explore-agent
+   ├─ Context protection: If file reading ≥50k chars → force cli-explore-agent
    └─ Decision:
       ├─ needsExploration=true → Launch parallel cli-explore-agents (1-4 based on complexity)
       └─ needsExploration=false → Skip to Phase 2/3

.claude/workflows/cli-tools-usage.md

@@ -65,13 +65,13 @@ RULES: $(cat ~/.claude/workflows/cli-templates/protocols/[mode]-protocol.md) $(c
 ccw cli -p "<PROMPT>" --tool <gemini|qwen|codex> --mode <analysis|write>
 ```
 
-**⚠️ CRITICAL**: `--mode` parameter is **MANDATORY** for all CLI executions. No defaults are assumed.
+**Note**: `--mode` defaults to `analysis` if not specified. Explicitly specify `--mode write` for file operations.
 
 ### Core Principles
 
 - **Use tools early and often** - Tools are faster and more thorough
 - **Unified CLI** - Always use `ccw cli -p` for consistent parameter handling
-- **Mode is MANDATORY** - ALWAYS explicitly specify `--mode analysis|write` (no implicit defaults)
+- **Default mode is analysis** - Omit `--mode` for read-only operations, explicitly use `--mode write` for file modifications
 - **One template required** - ALWAYS reference exactly ONE template in RULES (use universal fallback if no specific match)
 - **Write protection** - Require EXPLICIT `--mode write` for file operations
 - **Use double quotes for shell expansion** - Always wrap prompts in double quotes `"..."` to enable `$(cat ...)` command substitution; NEVER use single quotes or escape characters (`\$`, `\"`, `\'`)
@@ -183,6 +183,33 @@ ASSISTANT RESPONSE: [Previous output]
 
 **Tool Behavior**: Codex uses native `codex resume`; Gemini/Qwen assembles context as single prompt
 
+### Streaming vs Caching
+
+**Default behavior**: Non-streaming with full output caching (can retrieve later via `output` subcommand)
+
+```bash
+ccw cli -p "..." --tool gemini                   # Default: output cached, no streaming
+ccw cli -p "..." --tool gemini --stream          # Streaming: real-time output, no caching
+```
+
+| Mode | Flag | Output | Cached |
+|------|------|--------|--------|
+| Non-streaming (default) | (none) | After completion | ✅ Yes |
+| Streaming | `--stream` | Real-time | ❌ No |
+
+### Output Viewing
+
+View cached execution output with pagination:
+
+```bash
+ccw cli output <execution-id>                    # View full output
+ccw cli output <id> --offset 0 --limit 10000     # Paginated view
+ccw cli output <id> --output-type stdout         # Stdout only
+ccw cli output <id> --raw                        # Raw content (for piping)
+```
+
+**Note**: `output` subcommand views execution results. `--cache` parameter injects context into prompt - different concepts.
+
 ---
 
 ## Prompt Template

ccw/src/cli.ts

@@ -174,7 +174,7 @@ export function run(argv: string[]): void {
     .option('--cd <path>', 'Working directory')
     .option('--includeDirs <dirs>', 'Additional directories (--include-directories for gemini/qwen, --add-dir for codex/claude)')
     .option('--timeout <ms>', 'Timeout in milliseconds', '300000')
-    .option('--no-stream', 'Disable streaming output')
+    .option('--stream', 'Enable streaming output (default: non-streaming with caching)')
     .option('--limit <n>', 'History limit')
     .option('--status <status>', 'Filter by status')
     .option('--category <category>', 'Execution category: user, internal, insight', 'user')
@@ -190,6 +190,11 @@ export function run(argv: string[]): void {
     .option('--memory', 'Target memory storage')
     .option('--storage-cache', 'Target cache storage')
     .option('--config', 'Target config storage')
+    // Cache subcommand options
+    .option('--offset <n>', 'Character offset for cache pagination', '0')
+    .option('--output-type <type>', 'Output type: stdout, stderr, both', 'both')
+    .option('--turn <n>', 'Turn number for cache (default: latest)')
+    .option('--raw', 'Raw output only (no formatting)')
     .action((subcommand, args, options) => cliCommand(subcommand, args, options));
 
   // Memory command

ccw/src/commands/cli.ts

@@ -24,6 +24,7 @@ import {
   projectExists,
   getStorageLocationInstructions
 } from '../tools/storage-manager.js';
+import { getHistoryStore } from '../tools/cli-history-store.js';
 
 // Dashboard notification settings
 const DASHBOARD_PORT = process.env.CCW_PORT || 3456;
@@ -74,7 +75,7 @@ interface CliExecOptions {
   cd?: string;
   includeDirs?: string;
   timeout?: string;
-  noStream?: boolean;
+  stream?: boolean; // Enable streaming (default: false, caches output)
   resume?: string | boolean; // true = last, string = execution ID, comma-separated for merge
   id?: string; // Custom execution ID (e.g., IMPL-001-step1)
   noNative?: boolean; // Force prompt concatenation instead of native resume
@@ -104,6 +105,14 @@ interface StorageOptions {
   force?: boolean;
 }
 
+interface OutputViewOptions {
+  offset?: string;
+  limit?: string;
+  outputType?: 'stdout' | 'stderr' | 'both';
+  turn?: string;
+  raw?: boolean;
+}
+
 /**
  * Show storage information and management options
  */
@@ -287,6 +296,71 @@ function showStorageHelp(): void {
   console.log();
 }
 
+/**
+ * Show cached output for a conversation with pagination
+ */
+async function outputAction(conversationId: string | undefined, options: OutputViewOptions): Promise<void> {
+  if (!conversationId) {
+    console.error(chalk.red('Error: Conversation ID is required'));
+    console.error(chalk.gray('Usage: ccw cli output <conversation-id> [--offset N] [--limit N]'));
+    process.exit(1);
+  }
+
+  const store = getHistoryStore(process.cwd());
+  const result = store.getCachedOutput(
+    conversationId,
+    options.turn ? parseInt(options.turn) : undefined,
+    {
+      offset: parseInt(options.offset || '0'),
+      limit: parseInt(options.limit || '10000'),
+      outputType: options.outputType || 'both'
+    }
+  );
+
+  if (!result) {
+    console.error(chalk.red(`Error: Execution not found: ${conversationId}`));
+    process.exit(1);
+  }
+
+  if (options.raw) {
+    // Raw output only (for piping)
+    if (result.stdout) console.log(result.stdout.content);
+    return;
+  }
+
+  // Formatted output
+  console.log(chalk.bold.cyan('Execution Output\n'));
+  console.log(`  ${chalk.gray('ID:')}        ${result.conversationId}`);
+  console.log(`  ${chalk.gray('Turn:')}      ${result.turnNumber}`);
+  console.log(`  ${chalk.gray('Cached:')}    ${result.cached ? chalk.green('Yes') : chalk.yellow('No')}`);
+  console.log(`  ${chalk.gray('Status:')}    ${result.status}`);
+  console.log(`  ${chalk.gray('Time:')}      ${result.timestamp}`);
+  console.log();
+
+  if (result.stdout) {
+    console.log(`  ${chalk.gray('Stdout:')} (${result.stdout.totalBytes} bytes, offset ${result.stdout.offset})`);
+    console.log(chalk.gray('  ' + '-'.repeat(60)));
+    console.log(result.stdout.content);
+    console.log(chalk.gray('  ' + '-'.repeat(60)));
+    if (result.stdout.hasMore) {
+      console.log(chalk.yellow(`  ... ${result.stdout.totalBytes - result.stdout.offset - result.stdout.content.length} more bytes available`));
+      console.log(chalk.gray(`  Use --offset ${result.stdout.offset + result.stdout.content.length} to continue`));
+    }
+    console.log();
+  }
+
+  if (result.stderr && result.stderr.content) {
+    console.log(`  ${chalk.gray('Stderr:')} (${result.stderr.totalBytes} bytes, offset ${result.stderr.offset})`);
+    console.log(chalk.gray('  ' + '-'.repeat(60)));
+    console.log(result.stderr.content);
+    console.log(chalk.gray('  ' + '-'.repeat(60)));
+    if (result.stderr.hasMore) {
+      console.log(chalk.yellow(`  ... ${result.stderr.totalBytes - result.stderr.offset - result.stderr.content.length} more bytes available`));
+    }
+    console.log();
+  }
+}
+
 /**
  * Test endpoint for debugging multi-line prompt parsing
  * Shows exactly how Commander.js parsed the arguments
@@ -391,7 +465,7 @@ async function statusAction(): Promise<void> {
  * @param {Object} options - CLI options
  */
 async function execAction(positionalPrompt: string | undefined, options: CliExecOptions): Promise<void> {
-  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, timeout, noStream, resume, id, noNative, cache, injectMode } = options;
+  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, timeout, stream, resume, id, noNative, cache, injectMode } = options;
 
   // Priority: 1. --file, 2. --prompt/-p option, 3. positional argument
   let finalPrompt: string | undefined;
@@ -584,10 +658,10 @@ async function execAction(positionalPrompt: string | undefined, options: CliExec
     custom_id: id || null
   });
 
-  // Streaming output handler
-  const onOutput = noStream ? null : (chunk: any) => {
+  // Streaming output handler - only active when --stream flag is passed
+  const onOutput = stream ? (chunk: any) => {
     process.stdout.write(chunk.data);
-  };
+  } : null;
 
   try {
     const result = await cliExecutorTool.execute({
@@ -600,11 +674,12 @@ async function execAction(positionalPrompt: string | undefined, options: CliExec
       timeout: timeout ? parseInt(timeout, 10) : 300000,
       resume,
       id, // custom execution ID
-      noNative
+      noNative,
+      stream: !!stream // stream=true → streaming enabled, stream=false/undefined → cache output
     }, onOutput);
 
-    // If not streaming, print output now
-    if (noStream && result.stdout) {
+    // If not streaming (default), print output now
+    if (!stream && result.stdout) {
       console.log(result.stdout);
     }
 
@@ -815,6 +890,10 @@ export async function cliCommand(
       await storageAction(argsArray[0], options as unknown as StorageOptions);
       break;
 
+    case 'output':
+      await outputAction(argsArray[0], options as unknown as OutputViewOptions);
+      break;
+
     case 'test-parse':
       // Test endpoint to debug multi-line prompt parsing
       testParseAction(argsArray, options as CliExecOptions);
@@ -845,6 +924,7 @@ export async function cliCommand(
         console.log(chalk.gray('    storage [cmd]       Manage CCW storage (info/clean/config)'));
         console.log(chalk.gray('    history             Show execution history'));
         console.log(chalk.gray('    detail <id>         Show execution detail'));
+        console.log(chalk.gray('    output <id>         Show execution output with pagination'));
         console.log(chalk.gray('    test-parse [args]   Debug CLI argument parsing'));
         console.log();
         console.log('  Options:');

ccw/src/tools/cli-executor.ts

@@ -73,6 +73,7 @@ const ParamsSchema = z.object({
   noNative: z.boolean().optional(), // Force prompt concatenation instead of native resume
   category: z.enum(['user', 'internal', 'insight']).default('user'), // Execution category for tracking
   parentExecutionId: z.string().optional(), // Parent execution ID for fork/retry scenarios
+  stream: z.boolean().default(false), // false = cache full output (default), true = stream output via callback
 });
 
 // Execution category types
@@ -863,24 +864,36 @@ async function executeCliTool(
       const endTime = Date.now();
       const duration = endTime - startTime;
 
-      // Determine status
+      // Determine status - prioritize output content over exit code
       let status: 'success' | 'error' | 'timeout' = 'success';
       if (timedOut) {
         status = 'timeout';
       } else if (code !== 0) {
-        // Check if HTTP 429 but results exist (Gemini quirk)
-        if (stderr.includes('429') && stdout.trim()) {
+        // Non-zero exit code doesn't always mean failure
+        // Check if there's valid output (AI response) - treat as success
+        const hasValidOutput = stdout.trim().length > 0;
+        const hasFatalError = stderr.includes('FATAL') ||
+                              stderr.includes('Authentication failed') ||
+                              stderr.includes('API key') ||
+                              stderr.includes('rate limit exceeded');
+
+        if (hasValidOutput && !hasFatalError) {
+          // Has output and no fatal errors - treat as success despite exit code
           status = 'success';
         } else {
           status = 'error';
         }
       }
 
-      // Create new turn
+      // Create new turn - cache full output when not streaming (default)
+      const shouldCache = !parsed.data.stream;
       const newTurnOutput = {
-        stdout: stdout.substring(0, 10240), // Truncate to 10KB
-        stderr: stderr.substring(0, 2048),  // Truncate to 2KB
-        truncated: stdout.length > 10240 || stderr.length > 2048
+        stdout: stdout.substring(0, 10240), // Truncate preview to 10KB
+        stderr: stderr.substring(0, 2048),  // Truncate preview to 2KB
+        truncated: stdout.length > 10240 || stderr.length > 2048,
+        cached: shouldCache,
+        stdout_full: shouldCache ? stdout : undefined,
+        stderr_full: shouldCache ? stderr : undefined
       };
 
       // Determine base turn number for merge scenarios