@corbat-tech/coco 2.5.2 → 2.6.0

package/dist/cli/index.js

@@ -1050,6 +1050,20 @@ var init_anthropic = __esm({
             if (event.type === "content_block_start") {
               const contentBlock = event.content_block;
               if (contentBlock.type === "tool_use") {
+                if (currentToolCall) {
+                  getLogger().warn(
+                    `[Anthropic] content_block_stop missing for tool '${currentToolCall.name}' \u2014 finalizing early to prevent data bleed.`
+                  );
+                  try {
+                    currentToolCall.input = currentToolInputJson ? JSON.parse(currentToolInputJson) : {};
+                  } catch {
+                    currentToolCall.input = {};
+                  }
+                  yield {
+                    type: "tool_use_end",
+                    toolCall: { ...currentToolCall }
+                  };
+                }
                 currentToolCall = {
                   id: contentBlock.id,
                   name: contentBlock.name
@@ -1650,6 +1664,30 @@ var init_openai = __esm({
             }
           };
           const timeoutInterval = setInterval(checkTimeout, 5e3);
+          const providerName = this.name;
+          const parseArguments = (builder) => {
+            let input = {};
+            try {
+              input = builder.arguments ? JSON.parse(builder.arguments) : {};
+            } catch (error) {
+              console.warn(
+                `[${providerName}] Failed to parse tool call arguments for ${builder.name}: ${builder.arguments?.slice(0, 300)}`
+              );
+              try {
+                if (builder.arguments) {
+                  const repaired = jsonrepair(builder.arguments);
+                  input = JSON.parse(repaired);
+                  console.log(`[${providerName}] \u2713 Successfully repaired JSON for ${builder.name}`);
+                }
+              } catch {
+                console.error(
+                  `[${providerName}] Cannot repair JSON for ${builder.name}, using empty object`
+                );
+                console.error(`[${providerName}] Original error:`, error);
+              }
+            }
+            return input;
+          };
           try {
             for await (const chunk of stream) {
               const delta = chunk.choices[0]?.delta;
@@ -1661,7 +1699,7 @@ var init_openai = __esm({
               }
               if (delta?.tool_calls) {
                 for (const toolCallDelta of delta.tool_calls) {
-                  const index = toolCallDelta.index;
+                  const index = toolCallDelta.index ?? toolCallBuilders.size;
                   if (!toolCallBuilders.has(index)) {
                     toolCallBuilders.set(index, {
                       id: toolCallDelta.id ?? "",
@@ -1696,34 +1734,28 @@ var init_openai = __esm({
                   }
                 }
               }
-            }
-            for (const [, builder] of toolCallBuilders) {
-              let input = {};
-              try {
-                input = builder.arguments ? JSON.parse(builder.arguments) : {};
-              } catch (error) {
-                console.warn(
-                  `[${this.name}] Failed to parse tool call arguments for ${builder.name}: ${builder.arguments?.slice(0, 300)}`
-                );
-                try {
-                  if (builder.arguments) {
-                    const repaired = jsonrepair(builder.arguments);
-                    input = JSON.parse(repaired);
-                    console.log(`[${this.name}] \u2713 Successfully repaired JSON for ${builder.name}`);
-                  }
-                } catch {
-                  console.error(
-                    `[${this.name}] Cannot repair JSON for ${builder.name}, using empty object`
-                  );
-                  console.error(`[${this.name}] Original error:`, error);
+              const finishReason = chunk.choices[0]?.finish_reason;
+              if (finishReason && toolCallBuilders.size > 0) {
+                for (const [, builder] of toolCallBuilders) {
+                  yield {
+                    type: "tool_use_end",
+                    toolCall: {
+                      id: builder.id,
+                      name: builder.name,
+                      input: parseArguments(builder)
+                    }
+                  };
                 }
+                toolCallBuilders.clear();
               }
+            }
+            for (const [, builder] of toolCallBuilders) {
               yield {
                 type: "tool_use_end",
                 toolCall: {
                   id: builder.id,
                   name: builder.name,
-                  input
+                  input: parseArguments(builder)
                 }
               };
             }
@@ -1892,7 +1924,8 @@ var init_openai = __esm({
           if (msg.role === "system") {
             result.push({ role: "system", content: this.contentToString(msg.content) });
           } else if (msg.role === "user") {
-            if (Array.isArray(msg.content) && msg.content[0]?.type === "tool_result") {
+            if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
+              const textParts = [];
               for (const block of msg.content) {
                 if (block.type === "tool_result") {
                   const toolResult = block;
@@ -1901,8 +1934,16 @@ var init_openai = __esm({
                     tool_call_id: toolResult.tool_use_id,
                     content: toolResult.content
                   });
+                } else if (block.type === "text") {
+                  textParts.push(block.text);
                 }
               }
+              if (textParts.length > 0) {
+                console.warn(
+                  `[${this.name}] User message has mixed tool_result and text blocks \u2014 text emitted as a separate user message.`
+                );
+                result.push({ role: "user", content: textParts.join("") });
+              }
             } else if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "image")) {
               const parts = [];
               for (const block of msg.content) {
@@ -1947,6 +1988,10 @@ var init_openai = __esm({
                       arguments: JSON.stringify(block.input)
                     }
                   });
+                } else {
+                  console.warn(
+                    `[${this.name}] Unexpected block type '${block.type}' in assistant message \u2014 dropping. This may indicate a message history corruption.`
+                  );
                 }
               }
               if (textParts.length > 0) {
@@ -6526,8 +6571,18 @@ CONVERSATION:
             wasCompacted: false
           };
         }
-        const messagesToSummarize = conversationMessages.slice(0, -this.config.preserveLastN);
-        const messagesToPreserve = conversationMessages.slice(-this.config.preserveLastN);
+        let preserveStart = conversationMessages.length - this.config.preserveLastN;
+        if (preserveStart > 0) {
+          while (preserveStart > 0) {
+            const first = conversationMessages[preserveStart];
+            if (!first) break;
+            const isToolResult = Array.isArray(first.content) && first.content.length > 0 && first.content[0]?.type === "tool_result";
+            if (!isToolResult) break;
+            preserveStart--;
+          }
+        }
+        const messagesToSummarize = conversationMessages.slice(0, preserveStart);
+        const messagesToPreserve = conversationMessages.slice(preserveStart);
         if (messagesToSummarize.length === 0) {
           return {
             messages,
@@ -7086,9 +7141,12 @@ YOU ARE AN EXECUTION AGENT, NOT A CONVERSATIONAL ASSISTANT.
 - EVERY action requires a TOOL CALL. Text responses are ONLY for brief confirmations AFTER tools execute.
 
 **Execution Process:**
-1. **Analyze**: Understand what the user wants (in your head, don't output this)
+1. **Orient**: Output ONE line stating the *goal* of the next step \u2014 not the tool, the intent.
+   - Good: "Confirming the typo is gone\u2026" / "Checking tests still pass\u2026" / "Reading the config to understand current structure\u2026"
+   - Bad: "I'll use grep to search." (restates the tool, not the goal)
+   - Skip this for obvious single-step tasks ("create hello.js" \u2192 just create it).
 2. **Execute**: IMMEDIATELY CALL THE APPROPRIATE TOOLS (this is mandatory, not optional)
-3. **Respond**: Brief confirmation of what was done (AFTER tools executed)
+3. **Respond**: Brief confirmation of what was done (AFTER all tools executed)
 
 **Critical Rules:**
 - User says "create X with Y" \u2192 Immediately call write_file/edit_file tool, no discussion
@@ -7173,19 +7231,43 @@ If a file tool fails with "outside project directory", the system will automatic
 
 **For structured content** (documentation, tutorials, summaries, explanations with multiple sections, or when the user asks for "markdown"):
 
-1. Wrap your entire response in a single markdown code block:
-   \`\`\`markdown
+1. Wrap your entire response in a single tilde markdown block:
+   ~~~markdown
    Your content here...
+   ~~~
+
+2. **CRITICAL: Bare ~~~ closes the outer block** \u2014 Only use bare ~~~ (without a lang tag) as the VERY LAST line to close the outer block. Writing ~~~ anywhere else inside the block will break rendering.
+
+3. **ALL inner fenced blocks use standard backtick syntax:**
+   - Code: \`\`\`javascript / \`\`\`typescript / \`\`\`python / \`\`\`bash / etc.
+   - Shell commands: \`\`\`bash
+   - ASCII diagrams: \`\`\`ascii
+   - Tree structures / file paths: \`\`\`text
+   - Any other fenced content: \`\`\`<lang>
+
+   Example:
+   ~~~markdown
+   ## Section
+
+   Some text here.
+
+   \`\`\`bash
+   echo "hello"
+   ls -la
    \`\`\`
 
-2. **CRITICAL: Never close the markdown block prematurely** - The closing \`\`\` must ONLY appear at the very end.
+   \`\`\`ascii
+   \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+   \u2502 Service \u2502
+   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+   \`\`\`
 
-3. **For code examples inside markdown**, use TILDES (~~~) instead of backticks:
-   ~~~javascript
-   function example() { return "hello"; }
+   More text after blocks.
    ~~~
 
-4. **Include all content in ONE block**: headers, lists, tables, quotes, code examples.
+   **Inner blocks open with \`\`\`lang and close with \`\`\`. The only ~~~ inside the markdown block is the final bare ~~~ at the very end.**
+
+4. **Include all content in ONE block**: headers, lists, tables, quotes, code, commands, diagrams.
 
 **When to use markdown block:**
 - User asks for documentation, summary, tutorial, guide
@@ -8768,8 +8850,8 @@ async function killOrphanedTestProcesses() {
   }
   let killed = 0;
   try {
-    const { execa: execa13 } = await import('execa');
-    const result = await execa13("pgrep", ["-f", "vitest|jest.*--worker"], {
+    const { execa: execa14 } = await import('execa');
+    const result = await execa14("pgrep", ["-f", "vitest|jest.*--worker"], {
       reject: false
     });
     const pids = result.stdout.split("\n").map((s) => parseInt(s.trim(), 10)).filter((pid) => !isNaN(pid) && pid !== process.pid && pid !== process.ppid);
@@ -14330,6 +14412,15 @@ __export(bash_exports, {
   commandExistsTool: () => commandExistsTool,
   getEnvTool: () => getEnvTool
 });
+function getShellCommandPart(command) {
+  const firstNewline = command.indexOf("\n");
+  if (firstNewline === -1) return command;
+  const firstLine = command.slice(0, firstNewline);
+  if (/<<-?\s*['"]?\w/.test(firstLine)) {
+    return firstLine;
+  }
+  return command;
+}
 function isEnvVarSafe(name) {
   if (SAFE_ENV_VARS.has(name)) {
     return true;
@@ -14350,14 +14441,14 @@ function truncateOutput(output, maxLength = 5e4) {
 
 [Output truncated - ${output.length - maxLength} more characters]`;
 }
-var DEFAULT_TIMEOUT_MS, MAX_OUTPUT_SIZE, DANGEROUS_PATTERNS, SAFE_ENV_VARS, SENSITIVE_ENV_PATTERNS, bashExecTool, bashBackgroundTool, commandExistsTool, getEnvTool, bashTools;
+var DEFAULT_TIMEOUT_MS, MAX_OUTPUT_SIZE, DANGEROUS_PATTERNS_FULL, DANGEROUS_PATTERNS_SHELL_ONLY, SAFE_ENV_VARS, SENSITIVE_ENV_PATTERNS, bashExecTool, bashBackgroundTool, commandExistsTool, getEnvTool, bashTools;
 var init_bash = __esm({
   "src/tools/bash.ts"() {
     init_registry4();
     init_errors();
     DEFAULT_TIMEOUT_MS = 12e4;
     MAX_OUTPUT_SIZE = 1024 * 1024;
-    DANGEROUS_PATTERNS = [
+    DANGEROUS_PATTERNS_FULL = [
       /\brm\s+-rf\s+\/(?!\w)/,
       // rm -rf / (root)
       /\bsudo\s+rm\s+-rf/,
@@ -14370,14 +14461,6 @@ var init_bash = __esm({
       // Format filesystem
       /\bformat\s+/,
       // Windows format
-      /`[^`]+`/,
-      // Backtick command substitution
-      /\$\([^)]+\)/,
-      // $() command substitution
-      /\beval\s+/,
-      // eval command
-      /\bsource\s+/,
-      // source command (can execute arbitrary scripts)
       />\s*\/etc\//,
       // Write to /etc
       />\s*\/root\//,
@@ -14391,6 +14474,16 @@ var init_bash = __esm({
       /\bwget\s+.*\|\s*(ba)?sh/
       // wget | sh pattern
     ];
+    DANGEROUS_PATTERNS_SHELL_ONLY = [
+      /`[^`]+`/,
+      // Backtick command substitution
+      /\$\([^)]+\)/,
+      // $() command substitution
+      /\beval\s+/,
+      // eval command (shell eval, not JS eval())
+      /\bsource\s+/
+      // source command (can execute arbitrary scripts)
+    ];
     SAFE_ENV_VARS = /* @__PURE__ */ new Set([
       // System info (non-sensitive)
       "PATH",
@@ -14457,13 +14550,21 @@ Examples:
         env: z.record(z.string(), z.string()).optional().describe("Environment variables")
       }),
       async execute({ command, cwd, timeout, env: env2 }) {
-        for (const pattern of DANGEROUS_PATTERNS) {
+        const shellPart = getShellCommandPart(command);
+        for (const pattern of DANGEROUS_PATTERNS_FULL) {
           if (pattern.test(command)) {
             throw new ToolError(`Potentially dangerous command blocked: ${command.slice(0, 100)}`, {
               tool: "bash_exec"
             });
           }
         }
+        for (const pattern of DANGEROUS_PATTERNS_SHELL_ONLY) {
+          if (pattern.test(shellPart)) {
+            throw new ToolError(`Potentially dangerous command blocked: ${command.slice(0, 100)}`, {
+              tool: "bash_exec"
+            });
+          }
+        }
         const startTime = performance.now();
         const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS;
         const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
@@ -14545,13 +14646,21 @@ Examples:
         env: z.record(z.string(), z.string()).optional().describe("Environment variables")
       }),
       async execute({ command, cwd, env: env2 }) {
-        for (const pattern of DANGEROUS_PATTERNS) {
+        const shellPart = getShellCommandPart(command);
+        for (const pattern of DANGEROUS_PATTERNS_FULL) {
           if (pattern.test(command)) {
             throw new ToolError(`Potentially dangerous command blocked: ${command.slice(0, 100)}`, {
               tool: "bash_background"
             });
           }
         }
+        for (const pattern of DANGEROUS_PATTERNS_SHELL_ONLY) {
+          if (pattern.test(shellPart)) {
+            throw new ToolError(`Potentially dangerous command blocked: ${command.slice(0, 100)}`, {
+              tool: "bash_background"
+            });
+          }
+        }
         try {
           const filteredEnv = {};
           for (const [key, value] of Object.entries(process.env)) {
@@ -18787,6 +18896,680 @@ var init_tools = __esm({
   }
 });
 
+// src/cli/repl/hooks/types.ts
+function isHookEvent(value) {
+  return typeof value === "string" && HOOK_EVENTS.includes(value);
+}
+function isHookType(value) {
+  return value === "command" || value === "prompt";
+}
+function isHookAction(value) {
+  return value === "allow" || value === "deny" || value === "modify";
+}
+var HOOK_EVENTS;
+var init_types8 = __esm({
+  "src/cli/repl/hooks/types.ts"() {
+    HOOK_EVENTS = [
+      "PreToolUse",
+      "PostToolUse",
+      "Stop",
+      "SubagentStop",
+      "PreCompact",
+      "SessionStart",
+      "SessionEnd"
+    ];
+  }
+});
+function createHookRegistry() {
+  return new HookRegistry();
+}
+var HookRegistry;
+var init_registry5 = __esm({
+  "src/cli/repl/hooks/registry.ts"() {
+    init_types8();
+    HookRegistry = class {
+      /** Hooks indexed by event type for O(1) lookup */
+      hooksByEvent;
+      /** Hooks indexed by ID for quick access */
+      hooksById;
+      constructor() {
+        this.hooksByEvent = /* @__PURE__ */ new Map();
+        this.hooksById = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Register a hook
+       *
+       * @param hook - Hook definition to register
+       * @throws Error if hook with same ID already exists
+       */
+      register(hook) {
+        if (this.hooksById.has(hook.id)) {
+          throw new Error(`Hook with ID '${hook.id}' already exists`);
+        }
+        this.hooksById.set(hook.id, hook);
+        const eventHooks = this.hooksByEvent.get(hook.event) ?? [];
+        eventHooks.push(hook);
+        this.hooksByEvent.set(hook.event, eventHooks);
+      }
+      /**
+       * Unregister a hook by ID
+       *
+       * @param hookId - ID of hook to remove
+       * @returns true if hook was removed, false if not found
+       */
+      unregister(hookId) {
+        const hook = this.hooksById.get(hookId);
+        if (!hook) {
+          return false;
+        }
+        this.hooksById.delete(hookId);
+        const eventHooks = this.hooksByEvent.get(hook.event);
+        if (eventHooks) {
+          const index = eventHooks.findIndex((h) => h.id === hookId);
+          if (index !== -1) {
+            eventHooks.splice(index, 1);
+          }
+          if (eventHooks.length === 0) {
+            this.hooksByEvent.delete(hook.event);
+          }
+        }
+        return true;
+      }
+      /**
+       * Get all hooks for an event type
+       *
+       * @param event - Event type to query
+       * @returns Array of hooks for the event (empty if none)
+       */
+      getHooksForEvent(event) {
+        return this.hooksByEvent.get(event) ?? [];
+      }
+      /**
+       * Get hooks that match a specific event and optionally a tool
+       *
+       * Filters hooks by:
+       * 1. Event type match
+       * 2. Hook enabled status
+       * 3. Tool name pattern match (if toolName provided)
+       *
+       * @param event - Event type to match
+       * @param toolName - Optional tool name to match against matcher patterns
+       * @returns Array of matching enabled hooks
+       */
+      getMatchingHooks(event, toolName) {
+        const eventHooks = this.getHooksForEvent(event);
+        return eventHooks.filter((hook) => {
+          if (hook.enabled === false) {
+            return false;
+          }
+          if (!hook.matcher) {
+            return true;
+          }
+          if (!toolName) {
+            return !hook.matcher;
+          }
+          return this.matchesPattern(toolName, hook.matcher);
+        });
+      }
+      /**
+       * Load hooks from a config file
+       *
+       * Expects a JSON file with structure:
+       * ```json
+       * {
+       *   "version": 1,
+       *   "hooks": [...]
+       * }
+       * ```
+       *
+       * @param filePath - Path to hooks config file (JSON)
+       * @throws Error if file cannot be read or parsed
+       */
+      async loadFromFile(filePath) {
+        try {
+          await access(filePath);
+          const content = await readFile(filePath, "utf-8");
+          const config = JSON.parse(content);
+          if (typeof config.version !== "number") {
+            throw new Error("Invalid hooks config: missing version");
+          }
+          if (!Array.isArray(config.hooks)) {
+            throw new Error("Invalid hooks config: hooks must be an array");
+          }
+          this.clear();
+          for (const hook of config.hooks) {
+            this.validateHookDefinition(hook);
+            this.register(hook);
+          }
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return;
+          }
+          throw error;
+        }
+      }
+      /**
+       * Save hooks to a config file
+       *
+       * Creates the directory if it doesn't exist.
+       *
+       * @param filePath - Path to save hooks config
+       */
+      async saveToFile(filePath) {
+        await mkdir(dirname(filePath), { recursive: true });
+        const config = {
+          version: 1,
+          hooks: this.getAllHooks()
+        };
+        await writeFile(filePath, JSON.stringify(config, null, 2), "utf-8");
+      }
+      /**
+       * Clear all registered hooks
+       */
+      clear() {
+        this.hooksByEvent.clear();
+        this.hooksById.clear();
+      }
+      /**
+       * Get all registered hooks
+       *
+       * @returns Array of all hook definitions
+       */
+      getAllHooks() {
+        return Array.from(this.hooksById.values());
+      }
+      /**
+       * Get a hook by ID
+       *
+       * @param hookId - Hook ID to find
+       * @returns Hook definition or undefined if not found
+       */
+      getHookById(hookId) {
+        return this.hooksById.get(hookId);
+      }
+      /**
+       * Check if registry has any hooks for an event
+       *
+       * @param event - Event to check
+       * @returns true if any hooks are registered for the event
+       */
+      hasHooksForEvent(event) {
+        const hooks = this.hooksByEvent.get(event);
+        return hooks !== void 0 && hooks.length > 0;
+      }
+      /**
+       * Update an existing hook
+       *
+       * @param hookId - ID of hook to update
+       * @param updates - Partial hook definition with updates
+       * @returns true if hook was updated, false if not found
+       */
+      updateHook(hookId, updates) {
+        const existing = this.hooksById.get(hookId);
+        if (!existing) {
+          return false;
+        }
+        const eventChanging = updates.event && updates.event !== existing.event;
+        const oldEvent = existing.event;
+        Object.assign(existing, updates);
+        if (eventChanging && updates.event) {
+          const oldEventHooks = this.hooksByEvent.get(oldEvent);
+          if (oldEventHooks) {
+            const index = oldEventHooks.findIndex((h) => h.id === hookId);
+            if (index !== -1) {
+              oldEventHooks.splice(index, 1);
+            }
+            if (oldEventHooks.length === 0) {
+              this.hooksByEvent.delete(oldEvent);
+            }
+          }
+          const newEventHooks = this.hooksByEvent.get(updates.event) ?? [];
+          newEventHooks.push(existing);
+          this.hooksByEvent.set(updates.event, newEventHooks);
+        }
+        return true;
+      }
+      /**
+       * Enable or disable a hook
+       *
+       * @param hookId - ID of hook to toggle
+       * @param enabled - New enabled state
+       * @returns true if hook was updated, false if not found
+       */
+      setEnabled(hookId, enabled) {
+        return this.updateHook(hookId, { enabled });
+      }
+      /**
+       * Get count of registered hooks
+       */
+      get size() {
+        return this.hooksById.size;
+      }
+      /**
+       * Check if a tool name matches a glob-like pattern
+       *
+       * Supported patterns:
+       * - `*` matches any tool
+       * - `Edit*` matches Edit, EditFile, etc. (prefix match)
+       * - `*File` matches ReadFile, WriteFile, etc. (suffix match)
+       * - `*Code*` matches anything containing "Code"
+       * - `Bash` exact match
+       *
+       * @param toolName - Tool name to check
+       * @param pattern - Glob-like pattern
+       * @returns true if tool name matches pattern
+       */
+      matchesPattern(toolName, pattern) {
+        if (pattern === "*") {
+          return true;
+        }
+        if (!pattern.includes("*")) {
+          return toolName === pattern;
+        }
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+        const regexPattern = escaped.replace(/\*/g, ".*");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(toolName);
+      }
+      /**
+       * Validate a hook definition has required fields
+       *
+       * @param hook - Hook to validate
+       * @throws Error if hook is invalid
+       */
+      validateHookDefinition(hook) {
+        if (!hook || typeof hook !== "object") {
+          throw new Error("Hook definition must be an object");
+        }
+        const h = hook;
+        if (typeof h.id !== "string" || h.id.length === 0) {
+          throw new Error("Hook definition must have a non-empty id");
+        }
+        if (typeof h.event !== "string") {
+          throw new Error("Hook definition must have an event type");
+        }
+        if (!isHookEvent(h.event)) {
+          throw new Error(
+            `Invalid hook event type: ${h.event}. Valid events: ${HOOK_EVENTS.join(", ")}`
+          );
+        }
+        if (typeof h.type !== "string") {
+          throw new Error("Hook definition must have a type (command or prompt)");
+        }
+        if (!isHookType(h.type)) {
+          throw new Error(`Invalid hook type: ${h.type}. Valid types: command, prompt`);
+        }
+        if (h.type === "command" && typeof h.command !== "string") {
+          throw new Error("Command hooks must have a command string");
+        }
+        if (h.type === "prompt" && typeof h.prompt !== "string") {
+          throw new Error("Prompt hooks must have a prompt string");
+        }
+      }
+    };
+  }
+});
+function createHookExecutor(options) {
+  return new HookExecutor(options);
+}
+var DEFAULT_TIMEOUT_MS5, MAX_OUTPUT_SIZE3, HookExecutor;
+var init_executor = __esm({
+  "src/cli/repl/hooks/executor.ts"() {
+    DEFAULT_TIMEOUT_MS5 = 3e4;
+    MAX_OUTPUT_SIZE3 = 64 * 1024;
+    HookExecutor = class {
+      defaultTimeout;
+      shell;
+      cwd;
+      /**
+       * Create a new HookExecutor
+       *
+       * @param options - Configuration options for the executor
+       */
+      constructor(options) {
+        this.defaultTimeout = options?.defaultTimeout ?? DEFAULT_TIMEOUT_MS5;
+        this.shell = options?.shell ?? (process.platform === "win32" ? "cmd.exe" : "/bin/bash");
+        this.cwd = options?.cwd ?? process.cwd();
+      }
+      /**
+       * Execute all hooks for an event from the registry
+       *
+       * @description Retrieves hooks from the registry that match the event and context,
+       * executes them in order, and aggregates the results. Execution stops early if
+       * a hook denies the operation (for PreToolUse events).
+       *
+       * @param registry - The hook registry to query for hooks
+       * @param context - The execution context with event details
+       * @returns Aggregated results from all hook executions
+       *
+       * @example
+       * ```typescript
+       * const result = await executor.executeHooks(registry, context);
+       * console.log(`Executed ${result.results.length} hooks in ${result.duration}ms`);
+       * ```
+       */
+      async executeHooks(registry, context) {
+        const startTime = performance.now();
+        const hooks = registry.getHooksForEvent(context.event);
+        const matchingHooks = hooks.filter((hook) => this.matchesContext(hook, context));
+        const enabledHooks = matchingHooks.filter((hook) => hook.enabled !== false);
+        if (enabledHooks.length === 0) {
+          return {
+            event: context.event,
+            results: [],
+            allSucceeded: true,
+            shouldContinue: true,
+            duration: performance.now() - startTime
+          };
+        }
+        const results = [];
+        let shouldContinue = true;
+        let modifiedInput;
+        let allSucceeded = true;
+        for (const hook of enabledHooks) {
+          if (!shouldContinue) {
+            break;
+          }
+          let result;
+          try {
+            if (hook.type === "command") {
+              result = await this.executeCommandHook(hook, context);
+            } else {
+              result = await this.executePromptHook(hook, context);
+            }
+          } catch (error) {
+            result = {
+              hookId: hook.id,
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+              duration: 0
+            };
+          }
+          results.push(result);
+          if (!result.success) {
+            allSucceeded = false;
+            if (!hook.continueOnError) {
+              shouldContinue = false;
+            }
+          }
+          if (result.action === "deny") {
+            shouldContinue = false;
+          } else if (result.action === "modify" && result.modifiedInput) {
+            modifiedInput = result.modifiedInput;
+          }
+          if (hook.type === "command" && result.exitCode === 1 && context.event === "PreToolUse") {
+            shouldContinue = false;
+          }
+        }
+        return {
+          event: context.event,
+          results,
+          allSucceeded,
+          shouldContinue,
+          modifiedInput,
+          duration: performance.now() - startTime
+        };
+      }
+      /**
+       * Execute a single command hook via shell
+       *
+       * @description Runs the hook's command in a shell subprocess with environment
+       * variables set based on the hook context. Handles timeouts and captures
+       * stdout/stderr.
+       *
+       * @param hook - The hook definition containing the command to execute
+       * @param context - The execution context
+       * @returns Result of the command execution
+       */
+      async executeCommandHook(hook, context) {
+        const startTime = performance.now();
+        if (!hook.command) {
+          return {
+            hookId: hook.id,
+            success: false,
+            error: "Command hook has no command defined",
+            duration: performance.now() - startTime
+          };
+        }
+        const timeoutMs = hook.timeout ?? this.defaultTimeout;
+        const env2 = this.buildEnvironment(context);
+        try {
+          const options = {
+            cwd: this.cwd,
+            timeout: timeoutMs,
+            env: { ...process.env, ...env2 },
+            shell: this.shell,
+            reject: false,
+            maxBuffer: MAX_OUTPUT_SIZE3
+          };
+          const result = await execa(hook.command, options);
+          const stdout = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
+          const stderr = typeof result.stderr === "string" ? result.stderr : String(result.stderr ?? "");
+          const exitCode = result.exitCode ?? 0;
+          const success = exitCode === 0;
+          const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+          return {
+            hookId: hook.id,
+            success,
+            output: output || void 0,
+            error: !success && stderr ? stderr : void 0,
+            duration: performance.now() - startTime,
+            exitCode
+          };
+        } catch (error) {
+          if (error.timedOut) {
+            return {
+              hookId: hook.id,
+              success: false,
+              error: `Hook timed out after ${timeoutMs}ms`,
+              duration: performance.now() - startTime
+            };
+          }
+          return {
+            hookId: hook.id,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            duration: performance.now() - startTime
+          };
+        }
+      }
+      /**
+       * Execute a single prompt hook via LLM
+       *
+       * @description Evaluates the hook's prompt using an LLM to determine the action
+       * to take. Currently simplified - returns "allow" by default. Full implementation
+       * would require LLM provider integration.
+       *
+       * @param hook - The hook definition containing the prompt to evaluate
+       * @param context - The execution context
+       * @returns Result of the prompt evaluation with action
+       *
+       * @remarks
+       * This is a simplified implementation. A full implementation would:
+       * 1. Format the prompt with context variables
+       * 2. Send the prompt to an LLM provider
+       * 3. Parse the response for action (allow/deny/modify)
+       * 4. Extract any modified input if action is "modify"
+       */
+      async executePromptHook(hook, context) {
+        const startTime = performance.now();
+        if (!hook.prompt) {
+          return {
+            hookId: hook.id,
+            success: false,
+            error: "Prompt hook has no prompt defined",
+            duration: performance.now() - startTime
+          };
+        }
+        const formattedPrompt = this.formatPrompt(hook.prompt, context);
+        const action = "allow";
+        return {
+          hookId: hook.id,
+          success: true,
+          output: `Prompt evaluated: ${formattedPrompt.slice(0, 100)}...`,
+          duration: performance.now() - startTime,
+          action
+        };
+      }
+      /**
+       * Build environment variables for hook execution
+       *
+       * @description Creates a set of environment variables that provide context
+       * to command hooks. Variables include event type, tool information, session ID,
+       * and project path.
+       *
+       * @param context - The hook execution context
+       * @returns Record of environment variable names to values
+       */
+      buildEnvironment(context) {
+        const env2 = {
+          COCO_HOOK_EVENT: context.event,
+          COCO_SESSION_ID: context.sessionId,
+          COCO_PROJECT_PATH: context.projectPath,
+          COCO_HOOK_TIMESTAMP: context.timestamp.toISOString()
+        };
+        if (context.toolName) {
+          env2.COCO_TOOL_NAME = context.toolName;
+        }
+        if (context.toolInput) {
+          try {
+            env2.COCO_TOOL_INPUT = JSON.stringify(context.toolInput);
+          } catch {
+            env2.COCO_TOOL_INPUT = String(context.toolInput);
+          }
+        }
+        if (context.toolResult) {
+          try {
+            env2.COCO_TOOL_RESULT = JSON.stringify(context.toolResult);
+          } catch {
+            env2.COCO_TOOL_RESULT = String(context.toolResult);
+          }
+        }
+        if (context.metadata) {
+          for (const [key, value] of Object.entries(context.metadata)) {
+            const envKey = `COCO_META_${key.toUpperCase().replace(/[^A-Z0-9_]/g, "_")}`;
+            try {
+              env2[envKey] = typeof value === "string" ? value : JSON.stringify(value);
+            } catch {
+              env2[envKey] = String(value);
+            }
+          }
+        }
+        return env2;
+      }
+      /**
+       * Check if a hook matches the given context
+       *
+       * @description Evaluates whether a hook should be executed based on its
+       * matcher pattern and the context's tool name. Supports glob-like patterns.
+       *
+       * @param hook - The hook definition to check
+       * @param context - The execution context
+       * @returns true if the hook should be executed
+       */
+      matchesContext(hook, context) {
+        if (!hook.matcher) {
+          return true;
+        }
+        if (!context.toolName) {
+          return true;
+        }
+        return this.matchPattern(hook.matcher, context.toolName);
+      }
+      /**
+       * Match a glob-like pattern against a string
+       *
+       * @description Supports simple glob patterns:
+       * - "*" matches any sequence of characters
+       * - "?" matches any single character
+       * - Exact match otherwise
+       *
+       * @param pattern - The pattern to match
+       * @param value - The value to match against
+       * @returns true if the value matches the pattern
+       */
+      matchPattern(pattern, value) {
+        if (!pattern.includes("*") && !pattern.includes("?")) {
+          return pattern === value;
+        }
+        const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(value);
+      }
+      /**
+       * Format a prompt template with context values
+       *
+       * @description Replaces template variables in the prompt with values from
+       * the context. Variables are in the format {{variableName}}.
+       *
+       * Supported variables:
+       * - {{event}} - The hook event type
+       * - {{toolName}} - Name of the tool (if applicable)
+       * - {{toolInput}} - JSON string of tool input
+       * - {{toolResult}} - JSON string of tool result
+       * - {{sessionId}} - Session ID
+       * - {{projectPath}} - Project path
+       *
+       * @param prompt - The prompt template
+       * @param context - The execution context
+       * @returns Formatted prompt with variables replaced
+       */
+      formatPrompt(prompt, context) {
+        let formatted = prompt;
+        formatted = formatted.replace(/\{\{event\}\}/g, context.event);
+        formatted = formatted.replace(/\{\{toolName\}\}/g, context.toolName ?? "N/A");
+        formatted = formatted.replace(/\{\{sessionId\}\}/g, context.sessionId);
+        formatted = formatted.replace(/\{\{projectPath\}\}/g, context.projectPath);
+        if (context.toolInput) {
+          try {
+            formatted = formatted.replace(
+              /\{\{toolInput\}\}/g,
+              JSON.stringify(context.toolInput, null, 2)
+            );
+          } catch {
+            formatted = formatted.replace(/\{\{toolInput\}\}/g, String(context.toolInput));
+          }
+        } else {
+          formatted = formatted.replace(/\{\{toolInput\}\}/g, "N/A");
+        }
+        if (context.toolResult) {
+          try {
+            formatted = formatted.replace(
+              /\{\{toolResult\}\}/g,
+              JSON.stringify(context.toolResult, null, 2)
+            );
+          } catch {
+            formatted = formatted.replace(/\{\{toolResult\}\}/g, String(context.toolResult));
+          }
+        } else {
+          formatted = formatted.replace(/\{\{toolResult\}\}/g, "N/A");
+        }
+        return formatted;
+      }
+    };
+  }
+});
+
+// src/cli/repl/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  HOOK_EVENTS: () => HOOK_EVENTS,
+  HookExecutor: () => HookExecutor,
+  HookRegistry: () => HookRegistry,
+  createHookExecutor: () => createHookExecutor,
+  createHookRegistry: () => createHookRegistry,
+  isHookAction: () => isHookAction,
+  isHookEvent: () => isHookEvent,
+  isHookType: () => isHookType
+});
+var init_hooks = __esm({
+  "src/cli/repl/hooks/index.ts"() {
+    init_types8();
+    init_registry5();
+    init_executor();
+  }
+});
+
 // src/cli/repl/input/message-queue.ts
 function createMessageQueue(maxSize = 50) {
   let messages = [];
@@ -23100,9 +23883,9 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
       },
       bash: {
         async exec(command, options = {}) {
-          const { execa: execa13 } = await import('execa');
+          const { execa: execa14 } = await import('execa');
           try {
-            const result = await execa13(command, {
+            const result = await execa14(command, {
               shell: true,
               cwd: options.cwd || projectPath,
               timeout: options.timeout,
@@ -31847,10 +32630,10 @@ var resumeCommand = {
 
 // src/cli/repl/version-check.ts
 init_version();
-var NPM_REGISTRY_URL = "https://registry.npmjs.org/@corbat-tech/coco";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@corbat-tech/coco/latest";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var FETCH_TIMEOUT_MS = 2e3;
-var STARTUP_TIMEOUT_MS = 2500;
+var FETCH_TIMEOUT_MS = 5e3;
+var STARTUP_TIMEOUT_MS = 5500;
 var CACHE_DIR = path34__default.join(os4__default.homedir(), ".coco");
 var CACHE_FILE = path34__default.join(CACHE_DIR, "version-check-cache.json");
 function compareVersions(a, b) {
@@ -31898,7 +32681,7 @@ async function fetchLatestVersion() {
         return null;
       }
       const data = await response.json();
-      return data["dist-tags"]?.latest ?? null;
+      return data.version ?? null;
     } finally {
       clearTimeout(timeout);
     }
@@ -31970,10 +32753,14 @@ function printUpdateBanner(updateInfo) {
   console.log();
 }
 async function checkForUpdatesInteractive() {
+  let startupTimerId;
   const updateInfo = await Promise.race([
     checkForUpdates(),
-    new Promise((resolve4) => setTimeout(() => resolve4(null), STARTUP_TIMEOUT_MS))
+    new Promise((resolve4) => {
+      startupTimerId = setTimeout(() => resolve4(null), STARTUP_TIMEOUT_MS);
+    })
   ]);
+  clearTimeout(startupTimerId);
   if (!updateInfo) return;
   const p45 = await import('@clack/prompts');
   printUpdateBanner(updateInfo);
@@ -31986,10 +32773,10 @@ async function checkForUpdatesInteractive() {
     console.log(chalk25.dim(`  Running: ${updateInfo.updateCommand}`));
     console.log();
     try {
-      const { execa: execa13 } = await import('execa');
+      const { execa: execa14 } = await import('execa');
       const [cmd, ...args] = updateInfo.updateCommand.split(" ");
       if (!cmd) return;
-      await execa13(cmd, args, { stdio: "inherit", timeout: 12e4 });
+      await execa14(cmd, args, { stdio: "inherit", timeout: 12e4 });
       console.log();
       console.log(chalk25.green("  \u2713 Updated! Run coco again to start the new version."));
       console.log();
@@ -32077,6 +32864,8 @@ var rawMarkdownBuffer = "";
 var inCodeBlock = false;
 var codeBlockLang = "";
 var codeBlockLines = [];
+var inNestedCodeBlock = false;
+var codeBlockFenceChar = "";
 var streamingIndicatorActive = false;
 var streamingIndicatorInterval = null;
 var streamingIndicatorFrame = 0;
@@ -32120,6 +32909,7 @@ function flushLineBuffer() {
       stopStreamingIndicator();
     }
     inCodeBlock = false;
+    codeBlockFenceChar = "";
     codeBlockLang = "";
     codeBlockLines = [];
   }
@@ -32127,6 +32917,8 @@ function flushLineBuffer() {
 function resetLineBuffer() {
   lineBuffer = "";
   inCodeBlock = false;
+  inNestedCodeBlock = false;
+  codeBlockFenceChar = "";
   codeBlockLang = "";
   codeBlockLines = [];
   stopStreamingIndicator();
@@ -32149,28 +32941,100 @@ function renderStreamChunk(chunk) {
   }
 }
 function processAndOutputLine(line) {
-  const codeBlockMatch = line.match(/^```(\w*)$/);
+  line = line.replace(/^[\u200B\uFEFF\u200C\u200D\u2060\u00AD]+/, "");
+  const tildeFenceMatch = line.match(/^~~~(\w*)$/);
+  if (tildeFenceMatch) {
+    const lang = tildeFenceMatch[1] || "";
+    if (!inCodeBlock) {
+      if (lang) {
+        inCodeBlock = true;
+        inNestedCodeBlock = false;
+        codeBlockFenceChar = "~~~";
+        codeBlockLang = lang;
+        codeBlockLines = [];
+        if (codeBlockLang === "markdown" || codeBlockLang === "md") {
+          startStreamingIndicator();
+        }
+      } else {
+        const formatted = formatMarkdownLine(line);
+        const termWidth = getTerminalWidth2();
+        const wrapped = wrapText(formatted, termWidth);
+        for (const wl of wrapped) {
+          console.log(wl);
+        }
+      }
+    } else if (codeBlockFenceChar === "~~~") {
+      if (lang && !inNestedCodeBlock) {
+        inNestedCodeBlock = true;
+        codeBlockLines.push(line);
+      } else if (!lang && inNestedCodeBlock) {
+        inNestedCodeBlock = false;
+        codeBlockLines.push(line);
+      } else if (!lang && !inNestedCodeBlock) {
+        stopStreamingIndicator();
+        renderCodeBlock(codeBlockLang, codeBlockLines);
+        inCodeBlock = false;
+        inNestedCodeBlock = false;
+        codeBlockFenceChar = "";
+        codeBlockLang = "";
+        codeBlockLines = [];
+      } else {
+        codeBlockLines.push(line);
+      }
+    } else {
+      if (lang && !inNestedCodeBlock) {
+        inNestedCodeBlock = true;
+        codeBlockLines.push(line);
+      } else if (!lang && inNestedCodeBlock) {
+        inNestedCodeBlock = false;
+        codeBlockLines.push(line);
+      } else {
+        codeBlockLines.push(line);
+      }
+    }
+    return;
+  }
+  const codeBlockMatch = line.match(/^(`{3,4})(\w*)$/);
   if (codeBlockMatch) {
+    const fenceChars = codeBlockMatch[1];
+    const lang = codeBlockMatch[2] || "";
     if (!inCodeBlock) {
       inCodeBlock = true;
-      codeBlockLang = codeBlockMatch[1] || "";
+      inNestedCodeBlock = false;
+      codeBlockFenceChar = fenceChars;
+      codeBlockLang = lang;
       codeBlockLines = [];
       if (codeBlockLang === "markdown" || codeBlockLang === "md") {
         startStreamingIndicator();
       }
-    } else {
+    } else if (!lang && inNestedCodeBlock && fenceChars === "```") {
+      inNestedCodeBlock = false;
+      codeBlockLines.push(line);
+    } else if (!inNestedCodeBlock && lang && fenceChars === "```") {
+      inNestedCodeBlock = true;
+      codeBlockLines.push(line);
+    } else if (!lang && !inNestedCodeBlock && codeBlockFenceChar === fenceChars) {
       stopStreamingIndicator();
       renderCodeBlock(codeBlockLang, codeBlockLines);
       inCodeBlock = false;
+      inNestedCodeBlock = false;
+      codeBlockFenceChar = "";
       codeBlockLang = "";
       codeBlockLines = [];
+    } else {
+      codeBlockLines.push(line);
     }
     return;
   }
   if (inCodeBlock) {
     codeBlockLines.push(line);
   } else {
-    console.log(formatMarkdownLine(line));
+    const formatted = formatMarkdownLine(line);
+    const termWidth = getTerminalWidth2();
+    const wrapped = wrapText(formatted, termWidth);
+    for (const wl of wrapped) {
+      console.log(wl);
+    }
   }
 }
 function renderCodeBlock(lang, lines) {
@@ -32481,8 +33345,9 @@ function wrapText(text13, maxWidth) {
   }
   const lines = [];
   let remaining = text13;
-  while (stripAnsi2(remaining).length > maxWidth) {
+  while (true) {
     const plain = stripAnsi2(remaining);
+    if (plain.length <= maxWidth) break;
     let breakPoint = maxWidth;
     const lastSpace = plain.lastIndexOf(" ", maxWidth);
     if (lastSpace > maxWidth * 0.5) {
@@ -32511,8 +33376,8 @@ function wrapText(text13, maxWidth) {
       rawPos = ansiPositions[ansiIdx].end;
       ansiIdx++;
     }
-    lines.push(remaining.slice(0, rawPos));
-    remaining = remaining.slice(rawPos).trimStart();
+    lines.push(remaining.slice(0, rawPos) + "\x1B[0m");
+    remaining = "\x1B[0m" + remaining.slice(rawPos).trimStart();
   }
   if (remaining) {
     lines.push(remaining);
@@ -32552,16 +33417,54 @@ function getToolIcon(toolName, input) {
 function renderToolStart(toolName, input, metadata) {
   const icon = getToolIcon(toolName, { ...input, wouldCreate: metadata?.isCreate });
   const summary = formatToolSummary(toolName, input);
-  let label = toolName;
   if (toolName === "write_file") {
-    label = chalk25.yellow.bold("MODIFY") + " " + chalk25.cyan(String(input.path || ""));
+    const label = chalk25.yellow.bold("MODIFY") + " " + chalk25.cyan(String(input.path || ""));
     console.log(`
 ${icon} ${label}`);
+    const preview = renderContentPreview(String(input.content || ""), 3);
+    if (preview) console.log(preview);
+    return;
+  }
+  if (toolName === "edit_file") {
+    console.log(`
+${icon} ${chalk25.yellow.bold("EDIT")} ${chalk25.cyan(String(input.path || ""))}`);
+    const editPreview = renderEditPreview(
+      String(input.old_string || ""),
+      String(input.new_string || "")
+    );
+    if (editPreview) console.log(editPreview);
     return;
   }
   console.log(`
 ${icon} ${chalk25.cyan.bold(toolName)} ${chalk25.dim(summary)}`);
 }
+function renderContentPreview(content, maxLines) {
+  const maxWidth = Math.max(getTerminalWidth2() - 6, 40);
+  const lines = content.split("\n");
+  const preview = [];
+  for (const line of lines) {
+    if (preview.length >= maxLines) break;
+    const trimmed = line.trimEnd();
+    if (trimmed.length === 0 && preview.length === 0) continue;
+    const truncated = trimmed.length > maxWidth ? trimmed.slice(0, maxWidth - 1) + "\u2026" : trimmed;
+    preview.push(`   ${truncated}`);
+  }
+  if (preview.length === 0) return "";
+  const totalNonEmpty = lines.filter((l) => l.trim().length > 0).length;
+  const more = totalNonEmpty > maxLines ? chalk25.dim(` \u2026 +${totalNonEmpty - maxLines} lines`) : "";
+  return chalk25.dim(preview.join("\n")) + more;
+}
+function renderEditPreview(oldStr, newStr) {
+  const maxWidth = Math.max(getTerminalWidth2() - 8, 30);
+  const firstOld = oldStr.split("\n").find((l) => l.trim().length > 0) ?? "";
+  const firstNew = newStr.split("\n").find((l) => l.trim().length > 0) ?? "";
+  if (!firstOld && !firstNew) return "";
+  const truncate2 = (s) => s.length > maxWidth ? s.slice(0, maxWidth - 1) + "\u2026" : s;
+  const lines = [];
+  if (firstOld) lines.push(chalk25.dim("   ") + chalk25.red(`- ${truncate2(firstOld.trim())}`));
+  if (firstNew) lines.push(chalk25.dim("   ") + chalk25.green(`+ ${truncate2(firstNew.trim())}`));
+  return lines.join("\n");
+}
 function renderToolEnd(result) {
   const status = result.result.success ? chalk25.green("\u2713") : chalk25.red("\u2717");
   const duration = chalk25.dim(`${result.duration.toFixed(0)}ms`);
@@ -32570,6 +33473,8 @@ function renderToolEnd(result) {
   if (!result.result.success && result.result.error) {
     console.log(chalk25.red(`  \u2514\u2500 ${result.result.error}`));
   }
+  const details = formatResultDetails(result);
+  if (details) console.log(details);
 }
 function formatToolSummary(toolName, input) {
   switch (toolName) {
@@ -32580,6 +33485,7 @@ function formatToolSummary(toolName, input) {
       return String(input.path || "");
     case "list_directory":
       return String(input.path || ".");
+    case "grep":
     case "search_files": {
       const pattern = String(input.pattern || "");
       const path54 = input.path ? ` in ${input.path}` : "";
@@ -32587,7 +33493,8 @@ function formatToolSummary(toolName, input) {
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
-      return cmd.length > 50 ? cmd.slice(0, 47) + "..." : cmd;
+      const max = Math.max(getTerminalWidth2() - 20, 50);
+      return cmd.length > max ? cmd.slice(0, max - 1) + "\u2026" : cmd;
     }
     default:
       return formatToolInput(input);
@@ -32611,15 +33518,16 @@ function formatResultPreview(result) {
           return chalk25.dim(`(${files} files, ${dirs} dirs)`);
         }
         break;
+      case "grep":
       case "search_files":
         if (Array.isArray(data.matches)) {
-          return chalk25.dim(`(${data.matches.length} matches)`);
+          const n = data.matches.length;
+          return n === 0 ? chalk25.yellow("\xB7 no matches") : chalk25.dim(`\xB7 ${n} match${n === 1 ? "" : "es"}`);
         }
         break;
       case "bash_exec":
-        if (data.exitCode === 0) {
-          const lines = String(data.stdout || "").split("\n").length;
-          return chalk25.dim(`(${lines} lines)`);
+        if (data.exitCode !== void 0 && data.exitCode !== 0) {
+          return chalk25.red(`(exit ${data.exitCode})`);
         }
         break;
       case "write_file":
@@ -32630,6 +33538,47 @@ function formatResultPreview(result) {
   }
   return "";
 }
+function formatResultDetails(result) {
+  if (!result.result.success) return "";
+  const { name, result: toolResult } = result;
+  const maxWidth = Math.max(getTerminalWidth2() - 8, 40);
+  try {
+    const data = JSON.parse(toolResult.output);
+    if ((name === "grep" || name === "search_files") && Array.isArray(data.matches)) {
+      const matches = data.matches;
+      if (matches.length === 0) return "";
+      const MAX_SHOWN = 3;
+      const shown = matches.slice(0, MAX_SHOWN);
+      const lines = shown.map(({ file, line, content }) => {
+        const location = chalk25.cyan(`${file}:${line}`);
+        const snippet = content.trim();
+        const truncated = snippet.length > maxWidth ? snippet.slice(0, maxWidth - 1) + "\u2026" : snippet;
+        return `  ${chalk25.dim("\u2502")} ${location} ${chalk25.dim(truncated)}`;
+      });
+      if (matches.length > MAX_SHOWN) {
+        lines.push(`  ${chalk25.dim(`\u2502 \u2026 +${matches.length - MAX_SHOWN} more`)}`);
+      }
+      return lines.join("\n");
+    }
+    if (name === "bash_exec" && data.exitCode === 0) {
+      const stdout = String(data.stdout || "").trimEnd();
+      if (!stdout) return "";
+      const outputLines = stdout.split("\n").filter((l) => l.trim());
+      if (outputLines.length > 6) return "";
+      const shown = outputLines.slice(0, 4);
+      const lines = shown.map((l) => {
+        const truncated = l.length > maxWidth ? l.slice(0, maxWidth - 1) + "\u2026" : l;
+        return `  ${chalk25.dim("\u2502")} ${chalk25.dim(truncated)}`;
+      });
+      if (outputLines.length > 4) {
+        lines.push(`  ${chalk25.dim(`\u2502 \u2026 +${outputLines.length - 4} more`)}`);
+      }
+      return lines.join("\n");
+    }
+  } catch {
+  }
+  return "";
+}
 function formatToolInput(input) {
   const entries = Object.entries(input);
   if (entries.length === 0) return "";
@@ -38026,7 +38975,7 @@ init_errors();
 init_paths();
 var fs36 = await import('fs/promises');
 var path38 = await import('path');
-var crypto3 = await import('crypto');
+var crypto2 = await import('crypto');
 var GLOBAL_MEMORIES_DIR = path38.join(COCO_HOME, "memories");
 var PROJECT_MEMORIES_DIR = ".coco/memories";
 var DEFAULT_MAX_MEMORIES = 1e3;
@@ -38108,7 +39057,7 @@ Examples:
         { tool: "create_memory" }
       );
     }
-    const id = crypto3.randomUUID();
+    const id = crypto2.randomUUID();
     const memory = {
       id,
       key,
@@ -38223,7 +39172,7 @@ var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
 init_registry4();
 init_errors();
 var fs37 = await import('fs/promises');
-var crypto4 = await import('crypto');
+var crypto3 = await import('crypto');
 var CHECKPOINT_FILE = ".coco/checkpoints.json";
 var DEFAULT_MAX_CHECKPOINTS = 50;
 var STASH_PREFIX = "coco-cp";
@@ -38278,7 +39227,7 @@ Examples:
     description: z.string().min(1).max(200).describe("Description of this checkpoint")
   }),
   async execute({ description }) {
-    const id = crypto4.randomUUID().slice(0, 8);
+    const id = crypto3.randomUUID().slice(0, 8);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const stashMessage = `${STASH_PREFIX}-${id}-${description.replace(/\s+/g, "-").slice(0, 50)}`;
     const changedFiles = await getChangedFiles();
@@ -39289,7 +40238,7 @@ var imageTools = [readImageTool];
 init_registry4();
 init_errors();
 var path43 = await import('path');
-var DANGEROUS_PATTERNS2 = [
+var DANGEROUS_PATTERNS = [
   /\bDROP\s+(?:TABLE|DATABASE|INDEX|VIEW)\b/i,
   /\bTRUNCATE\b/i,
   /\bALTER\s+TABLE\b/i,
@@ -39299,7 +40248,7 @@ var DANGEROUS_PATTERNS2 = [
   /\bCREATE\s+(?:TABLE|DATABASE|INDEX)\b/i
 ];
 function isDangerousSql(sql2) {
-  return DANGEROUS_PATTERNS2.some((pattern) => pattern.test(sql2));
+  return DANGEROUS_PATTERNS.some((pattern) => pattern.test(sql2));
 }
 var sqlQueryTool = defineTool({
   name: "sql_query",
@@ -41368,6 +42317,115 @@ function findNextWordBoundary(line, pos) {
   while (i < line.length && line[i] === " ") i++;
   return i;
 }
+function countVisualRows(text13, startCol, termCols) {
+  let rows = 1;
+  let col = startCol;
+  for (const char of text13) {
+    if (char === "\n") {
+      if (col > 0) rows++;
+      col = 0;
+    } else {
+      col++;
+      if (col >= termCols) {
+        rows++;
+        col = 0;
+      }
+    }
+  }
+  return rows;
+}
+function getCursorVisualPos(text13, cursorPos, promptLen, termCols) {
+  let row = 0;
+  let col = promptLen;
+  for (let i = 0; i < cursorPos; i++) {
+    if (text13[i] === "\n") {
+      if (col > 0) row++;
+      col = 0;
+    } else {
+      col++;
+      if (col >= termCols) {
+        row++;
+        col = 0;
+      }
+    }
+  }
+  return { row, col };
+}
+function computeWordWrap(text13, startCol, termCols) {
+  const passthrough = {
+    display: text13,
+    toDisplayPos: (p45) => p45,
+    toOrigPos: (p45) => p45
+  };
+  if (!text13 || termCols <= 1) return passthrough;
+  const origToDisp = new Int32Array(text13.length + 1);
+  const dispToOrig = [];
+  let display = "";
+  let col = startCol;
+  function emitChar(ch, origIdx) {
+    origToDisp[origIdx] = display.length;
+    dispToOrig.push(origIdx);
+    display += ch;
+    col = ch === "\n" ? 0 : col + 1;
+  }
+  function injectNewline() {
+    dispToOrig.push(-1);
+    display += "\n";
+    col = 0;
+  }
+  let i = 0;
+  while (i < text13.length) {
+    const ch = text13[i];
+    if (ch === "\n") {
+      emitChar("\n", i++);
+      continue;
+    }
+    if (ch !== " ") {
+      let wordEnd = i;
+      while (wordEnd < text13.length && text13[wordEnd] !== " " && text13[wordEnd] !== "\n") {
+        wordEnd++;
+      }
+      const wordLen = wordEnd - i;
+      if (col > 0 && col + wordLen > termCols) {
+        injectNewline();
+      }
+      for (let k = i; k < wordEnd; k++) {
+        emitChar(text13[k], k);
+        if (col >= termCols && k + 1 < wordEnd) {
+          injectNewline();
+        }
+      }
+      i = wordEnd;
+    } else {
+      emitChar(" ", i++);
+      if (col >= termCols) {
+        col = 0;
+      } else {
+        let nextWordEnd = i;
+        while (nextWordEnd < text13.length && text13[nextWordEnd] !== " " && text13[nextWordEnd] !== "\n") {
+          nextWordEnd++;
+        }
+        const nextWordLen = nextWordEnd - i;
+        if (nextWordLen > 0 && col + nextWordLen > termCols) {
+          injectNewline();
+        }
+      }
+    }
+  }
+  origToDisp[text13.length] = display.length;
+  return {
+    display,
+    toDisplayPos: (origPos) => origToDisp[Math.min(origPos, text13.length)] ?? display.length,
+    toOrigPos: (displayPos) => {
+      const dp = Math.max(0, Math.min(displayPos, dispToOrig.length - 1));
+      for (let d = dp; d >= 0; d--) {
+        const orig = dispToOrig[d];
+        if (orig !== void 0 && orig >= 0) return orig;
+      }
+      return 0;
+    }
+  };
+}
 function createInputHandler(_session) {
   const savedHistory = loadHistory();
   const sessionHistory = [...savedHistory];
@@ -41382,6 +42440,7 @@ function createInputHandler(_session) {
   let lastCursorRow = 0;
   let lastContentRows = 1;
   let isFirstRender = true;
+  let lastCtrlCTime = 0;
   let isPasting = false;
   let pasteBuffer = "";
   let isReadingClipboard = false;
@@ -41423,7 +42482,9 @@ function createInputHandler(_session) {
     process.stdout.write("\r" + ansiEscapes.eraseDown);
     const separator = chalk25.dim("\u2500".repeat(termCols));
     let output = separator + "\n";
-    output += prompt.str + currentLine;
+    const ww = computeWordWrap(currentLine, prompt.visualLen, termCols);
+    const displayLine = ww.display;
+    output += prompt.str + displayLine;
     completions = findCompletions(currentLine);
     selectedCompletion = Math.min(selectedCompletion, Math.max(0, completions.length - 1));
     if (cursorPos === currentLine.length && completions.length > 0 && completions[selectedCompletion]) {
@@ -41432,9 +42493,23 @@ function createInputHandler(_session) {
         output += chalk25.dim.gray(ghost);
       }
     }
-    const totalContentLen = prompt.visualLen + currentLine.length;
-    const contentRows = totalContentLen === 0 ? 1 : Math.ceil(totalContentLen / termCols);
-    const contentExactFill = totalContentLen > 0 && totalContentLen % termCols === 0;
+    const hasWrapped = displayLine.includes("\n");
+    const contentRows = hasWrapped ? countVisualRows(displayLine, prompt.visualLen, termCols) : (() => {
+      const len = prompt.visualLen + displayLine.length;
+      return len === 0 ? 1 : Math.ceil(len / termCols);
+    })();
+    const contentExactFill = hasWrapped ? (() => {
+      const { col } = getCursorVisualPos(
+        displayLine,
+        displayLine.length,
+        prompt.visualLen,
+        termCols
+      );
+      return col === 0 && displayLine.length > 0;
+    })() : (() => {
+      const len = prompt.visualLen + displayLine.length;
+      return len > 0 && len % termCols === 0;
+    })();
     output += (contentExactFill ? "" : "\n") + separator;
     const showMenu = completions.length > 0 && currentLine.startsWith("/") && currentLine.length >= 1;
     let extraLinesBelow = 0;
@@ -41491,10 +42566,19 @@ function createInputHandler(_session) {
     const totalUp = extraLinesBelow + 1 + contentRows;
     output += ansiEscapes.cursorUp(totalUp);
     output += ansiEscapes.cursorDown(1);
-    const cursorAbsolutePos = prompt.visualLen + cursorPos;
-    const onExactBoundary = cursorAbsolutePos > 0 && cursorAbsolutePos % termCols === 0;
-    const finalLine = onExactBoundary ? cursorAbsolutePos / termCols - 1 : Math.floor(cursorAbsolutePos / termCols);
-    const finalCol = onExactBoundary ? 0 : cursorAbsolutePos % termCols;
+    const displayCursorPos = cursorPos === 0 ? 0 : ww.toDisplayPos(cursorPos);
+    let finalLine;
+    let finalCol;
+    if (hasWrapped) {
+      const pos = getCursorVisualPos(displayLine, displayCursorPos, prompt.visualLen, termCols);
+      finalLine = pos.row;
+      finalCol = pos.col;
+    } else {
+      const cursorAbsolutePos = prompt.visualLen + cursorPos;
+      const onExactBoundary = cursorAbsolutePos > 0 && cursorAbsolutePos % termCols === 0;
+      finalLine = onExactBoundary ? cursorAbsolutePos / termCols - 1 : Math.floor(cursorAbsolutePos / termCols);
+      finalCol = onExactBoundary ? 0 : cursorAbsolutePos % termCols;
+    }
     output += "\r";
     if (finalLine > 0) {
       output += ansiEscapes.cursorDown(finalLine);
@@ -41515,8 +42599,8 @@ function createInputHandler(_session) {
     lastMenuLines = 0;
   }
   function insertTextAtCursor(text13) {
-    const cleaned = text13.replace(/[\r\n]+/g, " ");
-    const printable = cleaned.replace(/[^\x20-\x7E\u00A0-\uFFFF]/g, "");
+    const cleaned = text13.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const printable = cleaned.replace(/[^\n\x20-\x7E\u00A0-\uFFFF]/g, "");
     if (printable.length === 0) return;
     currentLine = currentLine.slice(0, cursorPos) + printable + currentLine.slice(cursorPos);
     cursorPos += printable.length;
@@ -41583,10 +42667,27 @@ function createInputHandler(_session) {
             return;
           }
           if (key === "") {
+            if (currentLine.length > 0) {
+              currentLine = "";
+              cursorPos = 0;
+              selectedCompletion = 0;
+              historyIndex = -1;
+              lastCtrlCTime = 0;
+              render();
+              return;
+            }
+            const now = Date.now();
+            if (now - lastCtrlCTime < 800) {
+              cleanup();
+              console.log("\n\u{1F44B} Goodbye!");
+              saveHistory(sessionHistory);
+              process.exit(0);
+            }
+            lastCtrlCTime = now;
             cleanup();
-            console.log("\n\u{1F44B} Goodbye!");
-            saveHistory(sessionHistory);
-            process.exit(0);
+            console.log(chalk25.dim("(Press Ctrl+C again to exit)"));
+            resolve4("");
+            return;
           }
           if (key === "") {
             if (currentLine.length === 0) {
@@ -41724,7 +42825,10 @@ function createInputHandler(_session) {
                 selectedCompletion = Math.min(targetIndex, completions.length - 1);
               }
               render();
-            } else if (sessionHistory.length > 0 && completions.length === 0) {
+            } else if (cursorPos > 0) {
+              cursorPos = 0;
+              render();
+            } else if (sessionHistory.length > 0) {
               if (historyIndex === -1) {
                 tempLine = currentLine;
                 historyIndex = sessionHistory.length - 1;
@@ -41750,7 +42854,10 @@ function createInputHandler(_session) {
                 selectedCompletion = currentCol;
               }
               render();
-            } else if (historyIndex !== -1 && completions.length === 0) {
+            } else if (cursorPos < currentLine.length) {
+              cursorPos = currentLine.length;
+              render();
+            } else if (historyIndex !== -1) {
               if (historyIndex < sessionHistory.length - 1) {
                 historyIndex++;
                 currentLine = sessionHistory[historyIndex] ?? "";
@@ -41895,7 +43002,9 @@ function createSpinner(message) {
         const elapsed = startTime ? Math.floor((Date.now() - startTime) / 1e3) : 0;
         const elapsedStr = elapsed > 0 ? chalk25.dim(` (${elapsed}s)`) : "";
         const toolCountStr = formatToolCount();
-        spinner19.succeed(`${finalMessage || currentMessage}${toolCountStr}${elapsedStr}`);
+        const rawMsg = finalMessage || currentMessage;
+        const cleanMsg = rawMsg.replace(/\u2026$|\.\.\.$/, "").trimEnd();
+        spinner19.succeed(`${cleanMsg}${toolCountStr}${elapsedStr}`);
         spinner19 = null;
       }
       startTime = null;
@@ -42742,7 +43851,20 @@ var ParallelToolExecutor = class {
         }
         nextTaskIndex++;
         activeCount++;
-        const taskPromise = this.executeSingleTool(
+        const execPromise = options.hookRegistry && options.hookExecutor ? this.executeSingleToolWithHooks(
+          task.toolCall,
+          task.index,
+          total,
+          registry,
+          options
+        ).then(({ executed: executed2, skipped: wasSkipped, reason }) => {
+          if (wasSkipped) {
+            const skipReason = reason ?? "Blocked by hook";
+            skipped.push({ toolCall: task.toolCall, reason: skipReason });
+            onToolSkipped?.(task.toolCall, skipReason);
+          }
+          return executed2 ?? null;
+        }) : this.executeSingleTool(
           task.toolCall,
           task.index,
           total,
@@ -42751,14 +43873,23 @@ var ParallelToolExecutor = class {
           onToolEnd,
           signal,
           onPathAccessDenied
-        ).then((result) => {
-          task.result = result;
-          task.completed = true;
-          results[task.index - 1] = result;
-          activeCount--;
-          startNextTask();
-          return result;
-        });
+        );
+        const taskPromise = execPromise.then(
+          (result) => {
+            task.result = result;
+            task.completed = true;
+            results[task.index - 1] = result;
+            activeCount--;
+            startNextTask();
+            return result;
+          },
+          (err) => {
+            task.completed = true;
+            activeCount--;
+            startNextTask();
+            throw err;
+          }
+        );
         task.promise = taskPromise;
         processingPromises.push(taskPromise);
       }
@@ -42789,7 +43920,11 @@ var ParallelToolExecutor = class {
     if (!result.success && result.error && onPathAccessDenied) {
       const dirPath = extractDeniedPath(result.error);
       if (dirPath) {
-        const authorized = await onPathAccessDenied(dirPath);
+        let authorized = false;
+        try {
+          authorized = await onPathAccessDenied(dirPath);
+        } catch {
+        }
         if (authorized) {
           result = await registry.execute(toolCall.name, toolCall.input, { signal });
         }
@@ -43077,7 +44212,13 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
           const result = await promptAllowPath(dirPath);
           options.onAfterConfirmation?.();
           return result;
-        }
+        },
+        // Pass hooks through so PreToolUse/PostToolUse hooks fire during execution
+        hookRegistry: options.hookRegistry,
+        hookExecutor: options.hookExecutor,
+        sessionId: session.id,
+        projectPath: session.projectPath,
+        onHookExecuted: options.onHookExecuted
       });
       for (const executed of parallelResult.executed) {
         executedTools.push(executed);
@@ -43149,6 +44290,16 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
           content: executedCall.result.output,
           is_error: !executedCall.result.success
         });
+      } else {
+        console.warn(
+          `[AgentLoop] No result found for tool call ${toolCall.name}:${toolCall.id} \u2014 injecting error placeholder to keep history valid`
+        );
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolCall.id,
+          content: "Tool execution result unavailable (internal error)",
+          is_error: true
+        });
       }
     }
     let stuckInErrorLoop = false;
@@ -43719,7 +44870,13 @@ function formatGitShort(ctx) {
   return chalk25.dim("\u{1F33F} ") + branch + dirty;
 }
 init_full_access_mode();
-function formatStatusBar(projectPath, config, gitCtx) {
+function formatContextUsage(percent) {
+  const label = `ctx ${percent.toFixed(0)}%`;
+  if (percent >= 90) return chalk25.red(label);
+  if (percent >= 75) return chalk25.yellow(label);
+  return chalk25.dim(label);
+}
+function formatStatusBar(projectPath, config, gitCtx, contextUsagePercent) {
   const parts = [];
   const projectName = path34__default.basename(projectPath);
   parts.push(chalk25.dim("\u{1F4C1}") + chalk25.magenta(projectName));
@@ -43735,10 +44892,13 @@ function formatStatusBar(projectPath, config, gitCtx) {
   if (gitCtx) {
     parts.push(formatGitShort(gitCtx));
   }
+  if (contextUsagePercent !== void 0 && contextUsagePercent > 0) {
+    parts.push(formatContextUsage(contextUsagePercent));
+  }
   return "  " + parts.join(chalk25.dim(" \u2022 "));
 }
-function renderStatusBar(projectPath, config, gitCtx) {
-  const statusLine = formatStatusBar(projectPath, config, gitCtx);
+function renderStatusBar(projectPath, config, gitCtx, contextUsagePercent) {
+  const statusLine = formatStatusBar(projectPath, config, gitCtx, contextUsagePercent);
   console.log();
   console.log(statusLine);
 }
@@ -43871,6 +45031,24 @@ async function startRepl(options = {}) {
       `[MCP] Initialization failed: ${mcpError instanceof Error ? mcpError.message : String(mcpError)}`
     );
   }
+  let hookRegistry;
+  let hookExecutor;
+  try {
+    const hooksConfigPath = `${projectPath}/.coco/hooks.json`;
+    const { createHookRegistry: createHookRegistry2, createHookExecutor: createHookExecutor2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+    const registry = createHookRegistry2();
+    await registry.loadFromFile(hooksConfigPath);
+    if (registry.size > 0) {
+      hookRegistry = registry;
+      hookExecutor = createHookExecutor2();
+      logger.info(`[Hooks] Loaded ${registry.size} hook(s) from ${hooksConfigPath}`);
+    }
+  } catch (hookError) {
+    const msg = hookError instanceof Error ? hookError.message : String(hookError);
+    if (!msg.includes("ENOENT")) {
+      logger.warn(`[Hooks] Failed to load hooks: ${msg}`);
+    }
+  }
   const inputHandler = createInputHandler();
   const { createConcurrentCapture: createConcurrentCapture2 } = await Promise.resolve().then(() => (init_concurrent_capture_v2(), concurrent_capture_v2_exports));
   const { createFeedbackSystem: createFeedbackSystem2 } = await Promise.resolve().then(() => (init_feedback_system(), feedback_system_exports));
@@ -43903,6 +45081,8 @@ async function startRepl(options = {}) {
     }).finally(() => process.exit(0));
   };
   process.once("SIGTERM", sigtermHandler);
+  let warned75 = false;
+  let warned90 = false;
   while (true) {
     let autoInput = null;
     if (pendingQueuedMessages.length > 0) {
@@ -43929,6 +45109,10 @@ async function startRepl(options = {}) {
       break;
     }
     if (!input && !hasPendingImage()) continue;
+    if (input && ["exit", "quit", "q"].includes(input.trim().toLowerCase())) {
+      console.log(chalk25.dim("\nGoodbye!"));
+      break;
+    }
     let agentMessage = null;
     if (input && isSlashCommand(input)) {
       const prevProviderType = session.config.provider.type;
@@ -44154,6 +45338,8 @@ async function startRepl(options = {}) {
       );
       process.once("SIGINT", sigintHandler);
       let streamStarted = false;
+      let llmCallCount = 0;
+      let lastToolGroup = null;
       const result = await executeAgentTurn(session, effectiveMessage, provider, toolRegistry, {
         onStream: (chunk) => {
           if (!streamStarted) {
@@ -44172,7 +45358,8 @@ async function startRepl(options = {}) {
         },
         onToolEnd: (result2) => {
           const elapsed = activeSpinner && typeof activeSpinner.getElapsed === "function" ? activeSpinner.getElapsed() : 0;
-          if (elapsed >= 30) {
+          if (elapsed >= 3) {
+            inputEcho.clear();
             activeSpinner?.stop();
             activeSpinner = null;
             turnActiveSpinner = null;
@@ -44181,10 +45368,13 @@ async function startRepl(options = {}) {
           }
           renderToolStart(result2.name, result2.input);
           renderToolEnd(result2);
+          lastToolGroup = getToolGroup(result2.name);
           if (!result2.result.success && result2.result.error && looksLikeTechnicalJargon(result2.result.error)) {
             pendingExplanations.push(humanizeWithLLM(result2.result.error, result2.name, provider));
           }
-          if (isQualityLoop()) {
+          if (isQualityLoop() && llmCallCount > 0) {
+            setSpinner(`Processing results (iter. ${llmCallCount})...`);
+          } else if (isQualityLoop()) {
             setSpinner("Processing results & checking quality...");
           } else {
             setSpinner("Processing...");
@@ -44195,18 +45385,22 @@ async function startRepl(options = {}) {
           console.log(chalk25.yellow(`\u2298 Skipped ${tc.name}: ${reason}`));
         },
         onThinkingStart: () => {
-          setSpinner("Thinking...");
+          llmCallCount++;
+          const iterPrefix = isQualityLoop() && llmCallCount > 1 ? `Iter. ${llmCallCount} \xB7 ` : "";
+          const afterText = lastToolGroup ? `after ${lastToolGroup} \xB7 ` : "";
+          setSpinner(`${iterPrefix}${afterText}Thinking...`);
           thinkingStartTime = Date.now();
           thinkingInterval = setInterval(() => {
             if (!thinkingStartTime) return;
             const elapsed = Math.floor((Date.now() - thinkingStartTime) / 1e3);
             if (elapsed < 4) return;
+            const prefix = isQualityLoop() && llmCallCount > 1 ? `Iter. ${llmCallCount} \xB7 ` : "";
             if (isQualityLoop()) {
-              if (elapsed < 8) setSpinner("Analyzing request...");
-              else if (elapsed < 15) setSpinner("Running quality checks...");
-              else if (elapsed < 25) setSpinner("Iterating for quality...");
-              else if (elapsed < 40) setSpinner("Verifying implementation...");
-              else setSpinner(`Quality iteration in progress... (${elapsed}s)`);
+              if (elapsed < 8) setSpinner(`${prefix}Analyzing results...`);
+              else if (elapsed < 15) setSpinner(`${prefix}Running quality checks...`);
+              else if (elapsed < 25) setSpinner(`${prefix}Iterating for quality...`);
+              else if (elapsed < 40) setSpinner(`${prefix}Verifying implementation...`);
+              else setSpinner(`${prefix}Still working... (${elapsed}s)`);
             } else {
               if (elapsed < 8) setSpinner("Analyzing request...");
               else if (elapsed < 12) setSpinner("Planning approach...");
@@ -44217,7 +45411,15 @@ async function startRepl(options = {}) {
         },
         onThinkingEnd: () => {
           clearThinkingInterval();
-          clearSpinner();
+          const thinkingElapsed = activeSpinner?.getElapsed() ?? 0;
+          if (thinkingElapsed >= 2) {
+            inputEcho.clear();
+            activeSpinner?.stop();
+            activeSpinner = null;
+            turnActiveSpinner = null;
+          } else {
+            clearSpinner();
+          }
         },
         onToolPreparing: (toolName) => {
           setSpinner(getToolPreparingDescription(toolName));
@@ -44231,7 +45433,10 @@ async function startRepl(options = {}) {
           concurrentCapture.resumeCapture();
           inputEcho.resume();
         },
-        signal: abortController.signal
+        signal: abortController.signal,
+        // Wire lifecycle hooks (PreToolUse/PostToolUse) if configured in .coco/hooks.json
+        hookRegistry,
+        hookExecutor
       });
       clearThinkingInterval();
       clearSpinner();
@@ -44317,20 +45522,34 @@ async function startRepl(options = {}) {
         if (ctx) gitContext = ctx;
       }).catch(() => {
       });
-      renderStatusBar(session.projectPath, session.config, gitContext);
+      const usageBefore = getContextUsagePercent(session);
+      let usageForDisplay = usageBefore;
       try {
-        const usageBefore = getContextUsagePercent(session);
         const compactionResult = await checkAndCompactContext(session, provider);
         if (compactionResult?.wasCompacted) {
-          const usageAfter = getContextUsagePercent(session);
+          usageForDisplay = getContextUsagePercent(session);
           console.log(
             chalk25.dim(
-              `Context compacted (${usageBefore.toFixed(0)}% -> ${usageAfter.toFixed(0)}%)`
+              `Context compacted (${usageBefore.toFixed(0)}% -> ${usageForDisplay.toFixed(0)}%)`
             )
           );
+          warned75 = false;
+          warned90 = false;
         }
       } catch {
       }
+      renderStatusBar(session.projectPath, session.config, gitContext, usageForDisplay);
+      if (usageForDisplay >= 90 && !warned90) {
+        warned90 = true;
+        console.log(
+          chalk25.red("  \u2717 Context critical (" + usageForDisplay.toFixed(0) + "%) \u2014 use /clear to start fresh")
+        );
+      } else if (usageForDisplay >= 75 && !warned75) {
+        warned75 = true;
+        console.log(
+          chalk25.yellow("  \u26A0  Context at " + usageForDisplay.toFixed(0) + "% \u2014 use /clear to start fresh or /compact to summarize")
+        );
+      }
       console.log();
     } catch (error) {
       clearThinkingInterval();
@@ -44498,6 +45717,37 @@ async function checkProjectTrust(projectPath) {
   console.log(chalk25.green("  \u2713 Access granted") + chalk25.dim(" \u2022 /trust to manage"));
   return true;
 }
+function getToolGroup(toolName) {
+  switch (toolName) {
+    case "run_tests":
+      return "running tests";
+    case "bash_exec":
+      return "running command";
+    case "web_search":
+    case "web_fetch":
+      return "web search";
+    case "read_file":
+    case "list_directory":
+    case "glob_files":
+    case "tree":
+      return "reading files";
+    case "grep_search":
+    case "semantic_search":
+    case "codebase_map":
+      return "searching code";
+    case "write_file":
+      return "writing file";
+    case "edit_file":
+      return "editing file";
+    case "git_status":
+    case "git_diff":
+    case "git_commit":
+    case "git_log":
+      return "git";
+    default:
+      return toolName.replace(/_/g, " ");
+  }
+}
 function getToolPreparingDescription(toolName) {
   switch (toolName) {
     case "write_file":