@dugleelabs/copair 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { join as join9 } from "path";
+import { join as join13 } from "path";
 
 // src/cli/args.ts
 import { Command } from "commander";
@@ -32,6 +32,9 @@ function parseArgs(argv = process.argv) {
   };
 }
 
+// src/providers/interface.ts
+var NATIVE_SEARCH_MARKER = "_native_web_search";
+
 // src/core/conversation.ts
 var ConversationManager = class {
   messages = [];
@@ -366,6 +369,12 @@ function formatToolCall(name, argsJson) {
       case "grep":
         raw = `grep: ${args.pattern ?? ""}`;
         break;
+      case "web_search":
+        raw = `copair search: "${args.query ?? ""}"`;
+        break;
+      case "_native_web_search":
+        raw = `provider search: "${args.query ?? ""}"`;
+        break;
       default:
         raw = name;
         break;
@@ -419,7 +428,7 @@ var Renderer = class {
             this.endToolIndicator();
           }
           const raw = chunk.text ?? "";
-          const display = textFilter ? textFilter(raw) : raw;
+          const display = textFilter ? textFilter.write(raw) : raw;
           if (display && this.mdWriter) this.mdWriter.write(display);
           fullText += raw;
           if (display) this.bridge?.emit("stream-text", display);
@@ -492,6 +501,11 @@ Error: ${chunk.error}
           break;
       }
     }
+    if (textFilter) {
+      const trailing = textFilter.flush();
+      if (trailing && this.mdWriter) this.mdWriter.write(trailing);
+      if (trailing) this.bridge?.emit("stream-text", trailing);
+    }
     if (this.mdWriter) {
       this.mdWriter.flush();
       this.mdWriter = null;
@@ -545,33 +559,41 @@ Error: ${chunk.error}
    */
   showGitDiff(output) {
     if (!output.trim()) return;
-    if (this.inkMode) return;
-    const maxLines = 80;
-    const lines = output.split("\n");
-    const display = lines.slice(0, maxLines);
-    process.stderr.write("\n");
-    for (const line of display) {
-      if (line.startsWith("+++") || line.startsWith("---")) {
-        process.stderr.write(chalk3.bold.white(line) + "\n");
-      } else if (line.startsWith("+")) {
-        process.stderr.write(chalk3.bgGreen.black(line) + "\n");
-      } else if (line.startsWith("-")) {
-        process.stderr.write(chalk3.bgRedBright.black(line) + "\n");
-      } else if (line.startsWith("@@")) {
-        process.stderr.write(chalk3.cyan(line) + "\n");
-      } else if (line.startsWith("diff ")) {
-        process.stderr.write(chalk3.bold.yellow(line) + "\n");
-      } else if (line.startsWith("index ")) {
-        process.stderr.write(chalk3.gray(line) + "\n");
-      } else {
-        process.stderr.write(chalk3.gray(line) + "\n");
+    if (!this.inkMode) {
+      const maxLines = 80;
+      const lines = output.split("\n");
+      const display = lines.slice(0, maxLines);
+      process.stderr.write("\n");
+      for (const line of display) {
+        if (line.startsWith("+++") || line.startsWith("---")) {
+          process.stderr.write(chalk3.bold.white(line) + "\n");
+        } else if (line.startsWith("+")) {
+          process.stderr.write(chalk3.bgGreen.black(line) + "\n");
+        } else if (line.startsWith("-")) {
+          process.stderr.write(chalk3.bgRedBright.black(line) + "\n");
+        } else if (line.startsWith("@@")) {
+          process.stderr.write(chalk3.cyan(line) + "\n");
+        } else if (line.startsWith("diff ")) {
+          process.stderr.write(chalk3.bold.yellow(line) + "\n");
+        } else if (line.startsWith("index ")) {
+          process.stderr.write(chalk3.gray(line) + "\n");
+        } else {
+          process.stderr.write(chalk3.gray(line) + "\n");
+        }
       }
-    }
-    if (lines.length > maxLines) {
-      process.stderr.write(chalk3.gray(`  ... ${lines.length - maxLines} more lines
+      if (lines.length > maxLines) {
+        process.stderr.write(chalk3.gray(`  ... ${lines.length - maxLines} more lines
 `));
+      }
+      process.stderr.write("\n");
+    }
+    if (this.bridge) {
+      const lines = output.split("\n");
+      this.bridge.emit("diff", {
+        filePath: extractDiffFilePath(lines),
+        hunks: [{ oldStart: 0, newStart: 0, lines }]
+      });
     }
-    process.stderr.write("\n");
   }
   /**
    * Show a diff snippet for file mutations (write/edit).
@@ -694,6 +716,68 @@ function formatDuration(ms) {
   if (ms < 1e3) return `${Math.round(ms)}ms`;
   return `${(ms / 1e3).toFixed(1)}s`;
 }
+function extractDiffFilePath(lines) {
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      const match = line.match(/b\/(.+)$/);
+      if (match) return match[1];
+    }
+  }
+  return "git diff";
+}
+
+// src/core/logger.ts
+var SECRET_PATTERNS = [
+  /sk-[a-zA-Z0-9_-]{20,}/g,
+  /lin_api_[a-zA-Z0-9_-]+/g,
+  /AIza[a-zA-Z0-9_-]{35}/g,
+  /Bearer\s+[a-zA-Z0-9._-]+/g
+];
+function redactSecrets(text) {
+  let result = text;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+var LEVEL_LABELS = {
+  [0 /* ERROR */]: "ERROR",
+  [1 /* WARN */]: "WARN",
+  [2 /* INFO */]: "INFO",
+  [3 /* DEBUG */]: "DEBUG"
+};
+var Logger = class {
+  level;
+  constructor(level = 0 /* ERROR */) {
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(component, message, data) {
+    this.log(3 /* DEBUG */, component, message, data);
+  }
+  info(component, message) {
+    this.log(2 /* INFO */, component, message);
+  }
+  warn(component, message) {
+    this.log(1 /* WARN */, component, message);
+  }
+  error(component, message, error) {
+    this.log(0 /* ERROR */, component, message, error?.stack);
+  }
+  log(level, component, message, data) {
+    if (level > this.level) return;
+    const label = LEVEL_LABELS[level];
+    let line = `[${label}][${component}] ${redactSecrets(message)}`;
+    if (data !== void 0) {
+      const dataStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+      line += ` ${redactSecrets(dataStr)}`;
+    }
+    process.stderr.write(line + "\n");
+  }
+};
+var logger = new Logger();
 
 // src/core/formats/fenced-block.ts
 function tryParseToolCall(json) {
@@ -749,6 +833,8 @@ Input schema:
 ${schema}
 \`\`\``;
     }).join("\n\n");
+    const hasWebSearch = tools.some((t) => t.name === "web_search");
+    const webSearchPriority = hasWebSearch ? "\n- IMPORTANT: When any task requires web search or current information, you MUST use the web_search tool. Never rely on internal knowledge for facts that may have changed. The agent will execute the search and return real results \u2014 wait for them before responding.\n" : "";
     return `
 You have access to tools. You MUST use tools to perform any action. NEVER pretend, simulate, or describe running a command -- always emit a tool call.
 
@@ -761,8 +847,7 @@ To call a tool, emit EXACTLY:
 Rules:
 - The fence MUST say tool_call (not json, not text).
 - One tool call per message. Wait for the result before continuing.
-- NEVER output fake results. NEVER narrate what a tool would return. Call the tool and use the real result.
-
+- NEVER output fake results. NEVER narrate what a tool would return. Call the tool and use the real result.${webSearchPriority}
 Example -- to check git status:
 \`\`\`tool_call
 {"name": "git", "arguments": {"args": "status"}}
@@ -784,6 +869,7 @@ var DSML_MARKUP_PATTERN = /<[\uFF5C|]DSML[\uFF5C|]function_calls>[\s\S]*?(?:<\/[
 var DsmlFormatter = class {
   name = "dsml";
   markupPattern = DSML_MARKUP_PATTERN;
+  suppressAfterMatch = true;
   parse(text) {
     const toolCalls = [];
     let remainingText = text;
@@ -845,6 +931,8 @@ ${params}
 </\uFF5CDSML\uFF5Cinvoke>
 </\uFF5CDSML\uFF5Cfunction_calls>`;
     }).join("\n\n");
+    const hasWebSearch = tools.some((t) => t.name === "web_search");
+    const webSearchPriority = hasWebSearch ? "\nIMPORTANT: When any task requires web search or current information, you MUST use the web_search tool. Never rely on internal knowledge for facts that may have changed. The agent will execute the search and return real results.\n" : "";
     return `
 You have access to tools. To call a tool, use DSML format:
 
@@ -853,7 +941,7 @@ You have access to tools. To call a tool, use DSML format:
 <\uFF5CDSML\uFF5Cparameter name="param" string="true">value<\uFF5CDSML\uFF5Cparameter>
 </\uFF5CDSML\uFF5Cinvoke>
 </\uFF5CDSML\uFF5Cfunction_calls>
-
+${webSearchPriority}
 ## Tools
 
 ${toolDescriptions}
@@ -868,6 +956,9 @@ var MARKUP_PATTERN2 = /<tool_call>[\s\S]*?(?:<\/tool_call>|$)/g;
 var QwenXmlFormatter = class {
   name = "qwen-xml";
   markupPattern = MARKUP_PATTERN2;
+  openTag = "<tool_call>";
+  closeTag = "</tool_call>";
+  suppressAfterMatch = true;
   parse(text) {
     const toolCalls = [];
     let remainingText = text;
@@ -897,6 +988,8 @@ Input schema:
 ${schema}
 \`\`\``;
     }).join("\n\n");
+    const hasWebSearch = tools.some((t) => t.name === "web_search");
+    const webSearchPriority = hasWebSearch ? "\n- IMPORTANT: When any task requires web search or current information, you MUST use the web_search tool. Never rely on internal knowledge for facts that may have changed. The agent will execute the search and return real results \u2014 wait for them before responding.\n" : "";
     return `
 You have access to tools. You MUST use tools to perform any action. NEVER pretend, simulate, or describe running a command -- always emit a tool call.
 
@@ -909,7 +1002,7 @@ To call a tool, emit EXACTLY:
 Rules:
 - One tool call per message. Wait for the result before continuing.
 - NEVER output fake results. NEVER narrate what a tool would return. Call the tool and use the real result.
-
+- NEVER continue talking after emitting a tool call. Stop immediately after </tool_call> and wait for the result.${webSearchPriority}
 Example -- to check git status:
 <tool_call>
 {"name": "git", "arguments": {"args": "status"}}
@@ -942,10 +1035,85 @@ function createFormatter(name) {
       return new FencedBlockFormatter();
   }
 }
-function buildTextFilter(formatter) {
-  return (text) => {
-    return text.replace(new RegExp(formatter.markupPattern.source, formatter.markupPattern.flags), "");
-  };
+var StreamingMarkupFilter = class {
+  buffer = "";
+  suppressing = false;
+  /** Set to true once the first complete tool-call block has been processed.
+   *  When `suppressAfterMatch` is enabled, all further text is discarded. */
+  matchSeen = false;
+  openTag;
+  closeTag;
+  suppressAfterMatch;
+  fallbackRe;
+  constructor(formatter) {
+    if (formatter.openTag && formatter.closeTag) {
+      this.openTag = formatter.openTag;
+      this.closeTag = formatter.closeTag;
+      this.suppressAfterMatch = formatter.suppressAfterMatch ?? false;
+    } else {
+      this.suppressAfterMatch = false;
+      this.fallbackRe = new RegExp(
+        formatter.markupPattern.source,
+        formatter.markupPattern.flags
+      );
+    }
+  }
+  /** Feed the next streaming chunk; returns text safe to display. */
+  write(chunk) {
+    if (!this.openTag || !this.closeTag) {
+      return this.fallbackRe ? chunk.replace(this.fallbackRe, "") : chunk;
+    }
+    if (this.suppressAfterMatch && this.matchSeen) return "";
+    this.buffer += chunk;
+    let output = "";
+    while (this.buffer.length > 0) {
+      if (!this.suppressing) {
+        const idx = this.buffer.indexOf(this.openTag);
+        if (idx === -1) {
+          const hold = this._partialPrefixLen(this.buffer, this.openTag);
+          output += this.buffer.slice(0, this.buffer.length - hold);
+          this.buffer = hold > 0 ? this.buffer.slice(this.buffer.length - hold) : "";
+          break;
+        }
+        output += this.buffer.slice(0, idx);
+        this.buffer = this.buffer.slice(idx + this.openTag.length);
+        this.suppressing = true;
+      } else {
+        const idx = this.buffer.indexOf(this.closeTag);
+        if (idx === -1) break;
+        this.buffer = this.buffer.slice(idx + this.closeTag.length);
+        this.suppressing = false;
+        this.matchSeen = true;
+        if (this.suppressAfterMatch) {
+          this.buffer = "";
+          break;
+        }
+      }
+    }
+    return output;
+  }
+  /** Call once after the stream ends to flush any held-back text. */
+  flush() {
+    if (!this.openTag) return "";
+    if (this.suppressing || this.suppressAfterMatch && this.matchSeen) {
+      this.buffer = "";
+      this.suppressing = false;
+      return "";
+    }
+    const out = this.buffer;
+    this.buffer = "";
+    return out;
+  }
+  /** Returns the length of the longest suffix of `text` that is a prefix of `tag`. */
+  _partialPrefixLen(text, tag) {
+    for (let len = Math.min(tag.length - 1, text.length); len > 0; len--) {
+      if (text.endsWith(tag.slice(0, len))) return len;
+    }
+    return 0;
+  }
+};
+function buildStreamingFilter(formatter) {
+  return new StreamingMarkupFilter(formatter);
 }
 
 // src/core/agent.ts
@@ -970,7 +1138,7 @@ var Agent = class {
     this.renderer = new Renderer(options.bridge);
     this.options = options;
     this.formatter = resolveFormatter(provider.name, model, options.toolCallFormat);
-    this.textFilter = buildTextFilter(this.formatter);
+    this.textFilter = buildStreamingFilter(this.formatter);
   }
   get model() {
     return this._model;
@@ -1018,21 +1186,30 @@ ${summary}`
     this._model = newModel;
     this.contextWindow = new ContextWindowManager(newProvider.maxContextWindow);
     this.formatter = resolveFormatter(newProvider.name, newModel, this.options.toolCallFormat);
-    this.textFilter = buildTextFilter(this.formatter);
+    this.textFilter = buildStreamingFilter(this.formatter);
   }
   async handleMessage(userInput) {
     this.conversation.appendText("user", userInput);
     let totalUsage = null;
     let lastInputTokens = 0;
+    let agentWebSearchFailed = false;
     while (true) {
       const messages = await this.contextWindow.checkAndTruncate(
         this.conversation.getHistory(),
         this.provider
       );
       const allTools = this.toolRegistry.getAllDefinitions();
-      const tools = this.provider.supportsToolCalling ? allTools : [];
+      let tools = this.provider.supportsToolCalling ? allTools : [];
+      if (agentWebSearchFailed && this.provider.supportsNativeSearch) {
+        logger.info("web_search", "Falling back to provider native search (agent search unavailable)");
+        tools = tools.map(
+          (t) => t.name === "web_search" ? { name: NATIVE_SEARCH_MARKER, description: t.description, inputSchema: t.inputSchema } : t
+        );
+        agentWebSearchFailed = false;
+      }
       const toolSystemPrompt = !this.provider.supportsToolCalling && allTools.length > 0 ? this.formatter.buildSystemPrompt(allTools) : void 0;
-      const systemPrompt = toolSystemPrompt ? [this.options.systemPrompt, toolSystemPrompt].filter(Boolean).join("\n\n") : this.options.systemPrompt;
+      const webSearchHint = allTools.some((t) => t.name === "web_search") ? "When the user asks you to search the web, or requests current/up-to-date information, you MUST call the web_search tool. Never answer such queries from training knowledge alone \u2014 always invoke the tool and base your response on its results." : void 0;
+      const systemPrompt = [this.options.systemPrompt, toolSystemPrompt, webSearchHint].filter(Boolean).join("\n\n") || void 0;
       const stream = this.provider.chat(messages, tools, {
         model: this._model,
         stream: true,
@@ -1044,18 +1221,21 @@ ${summary}`
         stream,
         this.textFilter
       );
-      let toolCalls = nativeToolCalls;
+      const nonNativeToolCalls = nativeToolCalls.filter(
+        (tc) => tc.name !== NATIVE_SEARCH_MARKER
+      );
+      let toolCalls = nonNativeToolCalls;
       let cleanedText = fullText;
       if (fullText) {
         const parsed = this.formatter.parse(fullText);
         if (parsed.toolCalls.length > 0) {
           const nativeKeys = new Set(
-            nativeToolCalls.map((tc) => `${tc.name}:${tc.arguments}`)
+            nonNativeToolCalls.map((tc) => `${tc.name}:${tc.arguments}`)
           );
           const uniqueParsed = parsed.toolCalls.filter(
             (tc) => !nativeKeys.has(`${tc.name}:${tc.arguments}`)
           );
-          toolCalls = [...nativeToolCalls, ...uniqueParsed];
+          toolCalls = [...nonNativeToolCalls, ...uniqueParsed];
           cleanedText = parsed.remainingText;
         }
       }
@@ -1132,6 +1312,14 @@ ${summary}`
             }
           }
         }
+        if (tc.name === "web_search" && result.isError) {
+          if (this.provider.supportsNativeSearch) {
+            agentWebSearchFailed = true;
+            logger.info("web_search", "Agent web search failed \u2014 will fall back to provider native search on next turn");
+          }
+        } else if (tc.name === "web_search" && !result.isError) {
+          agentWebSearchFailed = false;
+        }
         toolResults.push({
           type: "tool_result",
           toolUseId: tc.id,
@@ -1196,6 +1384,10 @@ var ContextConfigSchema = z.object({
   max_sessions: z.number().int().positive().default(1),
   knowledge_max_size: z.number().int().positive().default(8192)
 });
+var KnowledgeConfigSchema = z.object({
+  warn_size_kb: z.number().int().positive().default(8),
+  max_size_kb: z.number().int().positive().default(16)
+});
 var UIConfigSchema = z.object({
   bordered_input: z.boolean().default(true),
   status_bar: z.boolean().default(true),
@@ -1215,6 +1407,7 @@ var CopairConfigSchema = z.object({
   web_search: WebSearchConfigSchema.optional(),
   identity: IdentityConfigSchema.default({ name: "Copair", email: "copair[bot]@noreply.dugleelabs.io" }),
   context: ContextConfigSchema.default(() => ContextConfigSchema.parse({})),
+  knowledge: KnowledgeConfigSchema.default(() => KnowledgeConfigSchema.parse({})),
   ui: UIConfigSchema.default(() => UIConfigSchema.parse({}))
 });
 
@@ -1274,7 +1467,7 @@ function loadYamlFile(filePath) {
 }
 function loadConfig(projectDir) {
   const globalPath = resolve2(homedir(), ".copair", "config.yaml");
-  const projectPath = projectDir ? resolve2(projectDir, ".copair.yaml") : resolve2(process.cwd(), ".copair.yaml");
+  const projectPath = projectDir ? resolve2(projectDir, ".copair", "config.yaml") : resolve2(process.cwd(), ".copair", "config.yaml");
   const globalConfig = loadYamlFile(globalPath);
   const projectConfig = loadYamlFile(projectPath);
   if (!globalConfig && !projectConfig) {
@@ -1286,6 +1479,9 @@ function loadConfig(projectDir) {
   } else {
     merged = globalConfig ?? projectConfig;
   }
+  if (merged.version === void 0) {
+    merged = { ...merged, version: CURRENT_CONFIG_VERSION };
+  }
   const version = merged.version;
   if (typeof version === "number" && version > CURRENT_CONFIG_VERSION) {
     throw new Error(
@@ -1360,7 +1556,7 @@ var ProviderRegistry = class {
 
 // src/providers/openai.ts
 import OpenAI from "openai";
-function toOpenAIMessages(messages, systemPrompt) {
+function toOpenAIMessages(messages, systemPrompt, supportsToolCalling = true) {
   const result = [];
   if (systemPrompt) {
     result.push({ role: "system", content: systemPrompt });
@@ -1374,6 +1570,22 @@ function toOpenAIMessages(messages, systemPrompt) {
       continue;
     }
     if (msg.role === "user") {
+      if (!supportsToolCalling) {
+        const parts = [];
+        for (const b of msg.content) {
+          if (b.type === "tool_result") {
+            const label = b.isError ? "Tool error" : "Tool result";
+            parts.push(`[${label}: ${b.toolUseId}]
+${b.content ?? ""}`);
+          } else if (b.type === "text" && b.text) {
+            parts.push(b.text);
+          }
+        }
+        if (parts.length > 0) {
+          result.push({ role: "user", content: parts.join("\n\n") });
+        }
+        continue;
+      }
       const textParts = msg.content.filter((b) => b.type === "text");
       const toolResults = msg.content.filter((b) => b.type === "tool_result");
       for (const tr of toolResults) {
@@ -1393,6 +1605,14 @@ function toOpenAIMessages(messages, systemPrompt) {
     }
     if (msg.role === "assistant") {
       const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      if (!supportsToolCalling) {
+        const toolCallTexts = msg.content.filter((b) => b.type === "tool_use").map((b) => `<tool_call>
+${JSON.stringify({ name: b.name, arguments: b.input })}
+</tool_call>`);
+        const combined = [text, ...toolCallTexts].filter(Boolean).join("\n");
+        result.push({ role: "assistant", content: combined || null });
+        continue;
+      }
       const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
         id: b.id,
         type: "function",
@@ -1439,7 +1659,7 @@ function createOpenAIProvider(config, modelAlias) {
     supportsStreaming,
     maxContextWindow,
     async *chat(messages, tools, options) {
-      const openaiMessages = toOpenAIMessages(messages, options.systemPrompt);
+      const openaiMessages = toOpenAIMessages(messages, options.systemPrompt, supportsToolCalling);
       const openaiTools = supportsToolCalling ? toOpenAITools(tools) : void 0;
       if (options.stream && supportsStreaming) {
         const stream = await client.chat.completions.create({
@@ -1574,10 +1794,15 @@ function toAnthropicMessages(messages) {
   return result;
 }
 function toAnthropicTools(tools) {
-  if (tools.length === 0) return void 0;
-  return tools.map((t) => {
-    if (t.name === "web_search") {
-      return { type: "web_search_20250305", name: "web_search" };
+  if (tools.length === 0) return { tools: void 0, builtInToolNames: /* @__PURE__ */ new Set() };
+  const builtInToolNames = /* @__PURE__ */ new Set();
+  const converted = tools.map((t) => {
+    if (t.name === NATIVE_SEARCH_MARKER) {
+      builtInToolNames.add("web_search");
+      return {
+        type: "web_search_20250305",
+        name: "web_search"
+      };
     }
     return {
       name: t.name,
@@ -1585,6 +1810,7 @@ function toAnthropicTools(tools) {
       input_schema: t.inputSchema
     };
   });
+  return { tools: converted, builtInToolNames };
 }
 function createAnthropicProvider(config, modelAlias) {
   const modelConfig = config.models[modelAlias];
@@ -1600,10 +1826,11 @@ function createAnthropicProvider(config, modelAlias) {
     name: "anthropic",
     supportsToolCalling: true,
     supportsStreaming: true,
+    supportsNativeSearch: true,
     maxContextWindow,
     async *chat(messages, tools, options) {
       const anthropicMessages = toAnthropicMessages(messages);
-      const anthropicTools = toAnthropicTools(tools);
+      const { tools: anthropicTools, builtInToolNames } = toAnthropicTools(tools);
       const systemPrompt = options.systemPrompt ?? messages.filter((m) => m.role === "system").flatMap((m) => m.content.filter((b) => b.type === "text")).map((b) => b.text).join("\n");
       if (options.stream) {
         const stream = client.messages.stream({
@@ -1628,25 +1855,39 @@ function createAnthropicProvider(config, modelAlias) {
               yield { type: "text", text: event.delta.text };
             } else if (event.delta.type === "input_json_delta") {
               currentToolArgs += event.delta.partial_json;
+              if (!builtInToolNames.has(currentToolName)) {
+                yield {
+                  type: "tool_call_delta",
+                  toolCall: {
+                    id: currentToolId,
+                    name: currentToolName,
+                    arguments: event.delta.partial_json
+                  }
+                };
+              }
+            }
+          }
+          if (event.type === "content_block_stop" && currentToolId && currentToolName) {
+            if (builtInToolNames.has(currentToolName)) {
               yield {
-                type: "tool_call_delta",
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolId,
+                  name: NATIVE_SEARCH_MARKER,
+                  arguments: currentToolArgs,
+                  metadata: { builtIn: true }
+                }
+              };
+            } else {
+              yield {
+                type: "tool_call",
                 toolCall: {
                   id: currentToolId,
                   name: currentToolName,
-                  arguments: event.delta.partial_json
+                  arguments: currentToolArgs
                 }
               };
             }
-          }
-          if (event.type === "content_block_stop" && currentToolId && currentToolName) {
-            yield {
-              type: "tool_call",
-              toolCall: {
-                id: currentToolId,
-                name: currentToolName,
-                arguments: currentToolArgs
-              }
-            };
             currentToolId = "";
             currentToolName = "";
             currentToolArgs = "";
@@ -2228,6 +2469,11 @@ async function searchSearxng(query, baseUrl, maxResults) {
   url.searchParams.set("format", "json");
   const response = await fetch(url.toString());
   if (!response.ok) {
+    if (response.status === 403) {
+      throw new Error(
+        `SearXNG returned 403 Forbidden. The JSON format is likely disabled on this instance. Enable it in settings.yml under search.formats by adding "json" to the list.`
+      );
+    }
     throw new Error(`SearXNG error: ${response.status} ${response.statusText}`);
   }
   const data = await response.json();
@@ -2256,12 +2502,13 @@ function createWebSearchTool(config) {
         required: ["query"]
       }
     },
-    requiresPermission: false,
+    requiresPermission: true,
     async execute(input) {
       const query = String(input["query"] ?? "");
       if (!query) {
         return { content: "Error: query is required", isError: true };
       }
+      logger.info("web_search", `Agent web search via ${webSearchConfig.provider}: "${query}"`);
       try {
         let results;
         switch (webSearchConfig.provider) {
@@ -3791,55 +4038,10 @@ async function resolveSummarizationModel(configModel, activeModel) {
   return null;
 }
 
-// src/core/init.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
-var PROJECT_CONFIG_TEMPLATE = `version: 1
-# Project-level overrides (merged with ~/.copair/config.yaml)
-# Uncomment and customize as needed:
-#
-# default_model: claude-sonnet
-#
-# context:
-#   summarization_model: qwen-7b
-#   max_sessions: 20
-#   knowledge_max_size: 8192
-#
-# permissions:
-#   mode: ask
-#   allow_commands:
-#     - git status
-#     - git diff
-`;
-function ensureProjectInit(cwd) {
-  const copairDir = join5(cwd, ".copair");
-  const alreadyInit = existsSync8(copairDir);
-  try {
-    mkdirSync3(join5(copairDir, "commands"), { recursive: true });
-    const innerGitignore = join5(copairDir, ".gitignore");
-    if (!existsSync8(innerGitignore)) {
-      writeFileSync3(innerGitignore, "sessions/\n", { mode: 420 });
-    }
-    const projectConfig = join5(cwd, ".copair.yaml");
-    if (!existsSync8(projectConfig)) {
-      writeFileSync3(projectConfig, PROJECT_CONFIG_TEMPLATE, { mode: 420 });
-    }
-    const rootGitignore = join5(cwd, ".gitignore");
-    if (existsSync8(rootGitignore)) {
-      const content = readFileSync5(rootGitignore, "utf8");
-      if (!content.includes(".copair/sessions")) {
-        writeFileSync3(rootGitignore, content.trimEnd() + "\n.copair/sessions/\n");
-      }
-    }
-  } catch {
-  }
-  return !alreadyInit;
-}
-
 // src/core/version-check.ts
 import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { join as join6, resolve as resolve7, dirname as dirname3 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join5, resolve as resolve7, dirname as dirname3 } from "path";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var _dir2 = dirname3(fileURLToPath2(import.meta.url));
@@ -3854,7 +4056,7 @@ var pkg2 = (() => {
   return { name: "copair", version: "0.1.0" };
 })();
 var CACHE_DIR = resolve7(process.env["HOME"] ?? "~", ".copair");
-var CACHE_FILE = join6(CACHE_DIR, "version-check.json");
+var CACHE_FILE = join5(CACHE_DIR, "version-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 async function fetchLatestVersion() {
   try {
@@ -3869,7 +4071,7 @@ async function fetchLatestVersion() {
   }
 }
 async function readCache() {
-  if (!existsSync9(CACHE_FILE)) return null;
+  if (!existsSync8(CACHE_FILE)) return null;
   try {
     const raw = await readFile5(CACHE_FILE, "utf8");
     return JSON.parse(raw);
@@ -3924,6 +4126,7 @@ Update available: ${pkg2.version} \u2192 ${latest}  (npm i -g ${pkg2.name})
 // src/core/approval-gate.ts
 import { resolve as resolvePath } from "path";
 import chalk5 from "chalk";
+var PERMISSION_SENSITIVE_FILES = ["config.yaml", "allow.yaml"];
 var RISK_TABLE = {
   // ── Read-only: never need approval ──────────────────────────────────────
   read: () => "safe",
@@ -3934,6 +4137,8 @@ var RISK_TABLE = {
   edit: () => "needs-approval",
   // ── Arbitrary shell: always needs approval ──────────────────────────────
   bash: () => "needs-approval",
+  // ── Web search: always prompt even in auto-approve (network + token cost) ──
+  web_search: () => "always-ask",
   // ── Git: split by subcommand ────────────────────────────────────────────
   git: (input) => {
     const args = (typeof input.args === "string" ? input.args : "").trim();
@@ -3992,7 +4197,12 @@ var ApprovalGate = class {
     if (typeof filePath !== "string") return false;
     const abs = resolvePath(filePath);
     for (const trusted of this.trustedPaths) {
-      if (abs === trusted || abs.startsWith(trusted + "/")) return true;
+      if (abs === trusted || abs.startsWith(trusted + "/")) {
+        if (PERMISSION_SENSITIVE_FILES.some((name) => abs.endsWith("/" + name))) {
+          return false;
+        }
+        return true;
+      }
     }
     return false;
   }
@@ -4010,16 +4220,18 @@ var ApprovalGate = class {
   async allow(toolName, input) {
     if (this.isTrustedPath(toolName, input)) return true;
     if (this.mode === "deny") return false;
-    if (this.classify(toolName, input) === "safe") return true;
-    if (this.mode === "auto-approve") return true;
+    const risk = this.classify(toolName, input);
+    if (risk === "safe") return true;
+    if (this.mode === "auto-approve" && risk !== "always-ask") return true;
     if (this.allowList?.matches(toolName, input)) return true;
     const key = sessionKey(toolName, input);
     if (this.alwaysAllow.has(key)) return true;
     if (this.bridge?.approveAllForTurn) return true;
+    const defaultAllow = risk === "always-ask";
     if (this.bridge) {
       return this.bridgePrompt(toolName, input, key);
     }
-    return this.legacyPrompt(toolName, input, key);
+    return this.legacyPrompt(toolName, input, key, defaultAllow);
   }
   /** Bridge-based approval: emit event and await response from ink UI. */
   bridgePrompt(toolName, input, key) {
@@ -4058,12 +4270,18 @@ var ApprovalGate = class {
       });
     });
   }
-  /** Legacy approval prompt: direct stdin (kept for backward compatibility). */
-  async legacyPrompt(toolName, input, key) {
+  /** Legacy approval prompt: direct stdin (kept for backward compatibility).
+   *
+   * @param defaultAllow  When true (used for `always-ask` tools like web_search),
+   *   pressing Enter without typing confirms the action.  For all other tools the
+   *   safe default is to deny on empty input.
+   */
+  async legacyPrompt(toolName, input, key, defaultAllow = false) {
     const summary = formatSummary(toolName, input);
     const boxWidth = Math.max(summary.length + 6, 56);
     const topBar = "\u2500".repeat(boxWidth);
     const pad = " ".repeat(Math.max(0, boxWidth - summary.length - 2));
+    const allowLabel = defaultAllow ? chalk5.green("[y/\u23CE]") : chalk5.green("[y]");
     process.stdout.write("\n");
     process.stdout.write(chalk5.yellow(`  \u250C\u2500 \u26A0  Approval required ${"\u2500".repeat(Math.max(0, boxWidth - 23))}\u2510
 `));
@@ -4072,7 +4290,7 @@ var ApprovalGate = class {
     process.stdout.write(chalk5.yellow(`  \u2514${topBar}\u2518
 `));
     process.stdout.write(
-      `  ${chalk5.green("[y]")} allow   ${chalk5.cyan("[a]")} always   ${chalk5.red("[n]")} deny  ${chalk5.yellow("\u203A")} `
+      `  ${allowLabel} allow   ${chalk5.cyan("[a]")} always   ${chalk5.red("[n]")} deny  ${chalk5.yellow("\u203A")} `
     );
     const answer = await ask();
     if (answer === null) {
@@ -4085,7 +4303,7 @@ var ApprovalGate = class {
       process.stdout.write(chalk5.green("  \u2713 Always allowed.\n\n"));
       return true;
     }
-    if (trimmed === "y" || trimmed === "yes") {
+    if (trimmed === "y" || trimmed === "yes" || trimmed === "" && defaultAllow) {
       process.stdout.write(chalk5.green("  \u2713 Allowed.\n\n"));
       return true;
     }
@@ -4127,6 +4345,9 @@ function formatSummary(toolName, input) {
     case "edit":
       raw = `edit  ${input.file_path}`;
       break;
+    case "web_search":
+      raw = `Copair web search  "${input.query}"`;
+      break;
     default:
       raw = `${toolName}  ${JSON.stringify(input)}`;
       break;
@@ -4656,7 +4877,7 @@ function ApprovalHandler({ bridge }) {
 }
 
 // src/cli/ui/app.tsx
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 var DEFAULT_UI_CONFIG = {
   bordered_input: true,
   status_bar: true,
@@ -4689,6 +4910,139 @@ function useSpinner(active) {
   const elapsedStr = secs < 60 ? `${secs}s` : `${Math.floor(secs / 60)}m ${String(secs % 60).padStart(2, "0")}s`;
   return { frame: SPINNER_FRAMES[frameIdx], elapsed: elapsedStr };
 }
+function renderInline(text) {
+  const parts = [];
+  let remaining = text;
+  let key = 0;
+  while (remaining.length > 0) {
+    const boldMatch = remaining.match(/^\*\*(.+?)\*\*/);
+    if (boldMatch) {
+      parts.push(/* @__PURE__ */ jsx6(Text6, { bold: true, children: boldMatch[1] }, key++));
+      remaining = remaining.slice(boldMatch[0].length);
+      continue;
+    }
+    const italicMatch = remaining.match(/^\*(.+?)\*/);
+    if (italicMatch) {
+      parts.push(/* @__PURE__ */ jsx6(Text6, { italic: true, children: italicMatch[1] }, key++));
+      remaining = remaining.slice(italicMatch[0].length);
+      continue;
+    }
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch) {
+      parts.push(/* @__PURE__ */ jsx6(Text6, { color: "cyan", bold: true, children: codeMatch[1] }, key++));
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const nextSpecial = remaining.search(/[*`]/);
+    if (nextSpecial === -1) {
+      parts.push(remaining);
+      break;
+    }
+    if (nextSpecial === 0) {
+      parts.push(remaining[0]);
+      remaining = remaining.slice(1);
+    } else {
+      parts.push(remaining.slice(0, nextSpecial));
+      remaining = remaining.slice(nextSpecial);
+    }
+  }
+  return parts.length === 1 ? parts[0] : /* @__PURE__ */ jsx6(Fragment2, { children: parts });
+}
+function renderMarkdownBlocks(text) {
+  const lines = text.split("\n");
+  const elements = [];
+  let key = 0;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      const lang = trimmed.slice(3).trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) i++;
+      elements.push(
+        /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginY: 1, children: [
+          lang && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: lang }),
+          /* @__PURE__ */ jsx6(Box6, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column", children: codeLines.map((cl, ci) => /* @__PURE__ */ jsx6(Text6, { color: "white", children: cl }, ci)) })
+        ] }, key++)
+      );
+      continue;
+    }
+    const headerMatch = trimmed.match(/^(#{1,6})\s+(.+)/);
+    if (headerMatch) {
+      const level = headerMatch[1].length;
+      const content = headerMatch[2];
+      elements.push(
+        /* @__PURE__ */ jsxs6(Text6, { bold: true, color: level <= 2 ? "white" : void 0, children: [
+          level <= 2 ? "\n" : "",
+          content
+        ] }, key++)
+      );
+      i++;
+      continue;
+    }
+    if (/^[-*_]{3,}$/.test(trimmed)) {
+      elements.push(
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2500".repeat(40) }, key++)
+      );
+      i++;
+      continue;
+    }
+    const ulMatch = trimmed.match(/^[-*+]\s+(.*)/);
+    if (ulMatch) {
+      elements.push(
+        /* @__PURE__ */ jsxs6(Text6, { wrap: "wrap", children: [
+          "  ",
+          "\u2022",
+          " ",
+          renderInline(ulMatch[1])
+        ] }, key++)
+      );
+      i++;
+      continue;
+    }
+    const olMatch = trimmed.match(/^(\d+)[.)]\s+(.*)/);
+    if (olMatch) {
+      elements.push(
+        /* @__PURE__ */ jsxs6(Text6, { wrap: "wrap", children: [
+          "  ",
+          olMatch[1],
+          ". ",
+          renderInline(olMatch[2])
+        ] }, key++)
+      );
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith(">")) {
+      const content = trimmed.replace(/^>\s?/, "");
+      elements.push(
+        /* @__PURE__ */ jsxs6(Text6, { dimColor: true, wrap: "wrap", children: [
+          "  ",
+          "\u2502",
+          " ",
+          renderInline(content)
+        ] }, key++)
+      );
+      i++;
+      continue;
+    }
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    elements.push(
+      /* @__PURE__ */ jsx6(Text6, { wrap: "wrap", children: renderInline(line) }, key++)
+    );
+    i++;
+  }
+  return elements;
+}
 var CopairApp = forwardRef(function CopairApp2({
   bridge,
   model,
@@ -4786,6 +5140,12 @@ var CopairApp = forwardRef(function CopairApp2({
         { id: nextId.current++, type: "error", content: `\u2717 ${tool.label} denied` }
       ]);
     };
+    const onDiff = (diff) => {
+      setStaticItems((items) => [
+        ...items,
+        { id: nextId.current++, type: "diff", content: "", diff }
+      ]);
+    };
     const onError = (message) => {
       setStaticItems((items) => [
         ...items,
@@ -4816,6 +5176,7 @@ var CopairApp = forwardRef(function CopairApp2({
     bridge.on("tool-start", onToolStart);
     bridge.on("tool-complete", onToolComplete);
     bridge.on("tool-denied", onToolDenied);
+    bridge.on("diff", onDiff);
     bridge.on("error", onError);
     bridge.on("usage", onUsage);
     bridge.on("turn-complete", onTurnComplete);
@@ -4825,6 +5186,7 @@ var CopairApp = forwardRef(function CopairApp2({
       bridge.off("tool-start", onToolStart);
       bridge.off("tool-complete", onToolComplete);
       bridge.off("tool-denied", onToolDenied);
+      bridge.off("diff", onDiff);
       bridge.off("error", onError);
       bridge.off("usage", onUsage);
       bridge.off("turn-complete", onTurnComplete);
@@ -4860,9 +5222,11 @@ var CopairApp = forwardRef(function CopairApp2({
             "  ",
             item.content
           ] }, item.id);
+        case "diff":
+          return item.diff ? /* @__PURE__ */ jsx6(DiffView, { diff: item.diff }, item.id) : null;
         case "text":
         default:
-          return /* @__PURE__ */ jsx6(Text6, { wrap: "wrap", children: item.content }, item.id);
+          return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: renderMarkdownBlocks(item.content) }, item.id);
       }
     } }),
     state.phase === "thinking" && /* @__PURE__ */ jsxs6(Text6, { children: [
@@ -4874,7 +5238,7 @@ var CopairApp = forwardRef(function CopairApp2({
         /* @__PURE__ */ jsx6(Text6, { color: "gray", children: spinner.elapsed })
       ] })
     ] }),
-    liveText && /* @__PURE__ */ jsx6(Text6, { wrap: "wrap", children: liveText }),
+    liveText && /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: renderMarkdownBlocks(liveText) }),
     liveTool && /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
       "  ",
       "\u25CF",
@@ -4967,7 +5331,7 @@ var ToolExecutor = class {
 };
 
 // src/core/allow-list.ts
-import { readFileSync as readFileSync6, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync9 } from "fs";
 import { resolve as resolve8 } from "path";
 import { homedir as homedir2 } from "os";
 import { parse as parseYaml3 } from "yaml";
@@ -5036,9 +5400,9 @@ function loadAllowList(projectDir) {
   });
 }
 function readAllowFile(filePath) {
-  if (!existsSync10(filePath)) return {};
+  if (!existsSync9(filePath)) return {};
   try {
-    const raw = parseYaml3(readFileSync6(filePath, "utf-8"));
+    const raw = parseYaml3(readFileSync5(filePath, "utf-8"));
     return {
       bash: toStringArray(raw.bash),
       git: toStringArray(raw.git),
@@ -5084,7 +5448,7 @@ import chalk6 from "chalk";
 // package.json
 var package_default = {
   name: "@dugleelabs/copair",
-  version: "1.0.1",
+  version: "1.1.0",
   description: "Model-agnostic AI coding agent for the terminal",
   type: "module",
   main: "dist/index.js",
@@ -5241,20 +5605,20 @@ var DEFAULT_PRICING = /* @__PURE__ */ new Map([
 ]);
 
 // src/cli/ui/input-history.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync11 } from "fs";
-import { join as join7, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync10 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
 import { homedir as homedir3 } from "os";
 var MAX_HISTORY = 500;
 function resolveHistoryPath(cwd) {
-  const projectPath = join7(cwd, ".copair", "history");
-  if (existsSync11(join7(cwd, ".copair"))) {
+  const projectPath = join6(cwd, ".copair", "history");
+  if (existsSync10(join6(cwd, ".copair"))) {
     return projectPath;
   }
-  return join7(homedir3(), ".copair", "history");
+  return join6(homedir3(), ".copair", "history");
 }
 function loadHistory(historyPath) {
   try {
-    const content = readFileSync7(historyPath, "utf-8");
+    const content = readFileSync6(historyPath, "utf-8");
     return content.split("\n").filter(Boolean);
   } catch {
     return [];
@@ -5263,10 +5627,10 @@ function loadHistory(historyPath) {
 function saveHistory(historyPath, entries) {
   const trimmed = entries.slice(-MAX_HISTORY);
   const dir = dirname4(historyPath);
-  if (!existsSync11(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  if (!existsSync10(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync4(historyPath, trimmed.join("\n") + "\n", "utf-8");
+  writeFileSync3(historyPath, trimmed.join("\n") + "\n", "utf-8");
 }
 function appendHistory(historyPath, entry) {
   const entries = loadHistory(historyPath);
@@ -5278,7 +5642,7 @@ function appendHistory(historyPath, entry) {
 
 // src/cli/ui/completion-providers.ts
 import { readdirSync } from "fs";
-import { join as join8, dirname as dirname5, basename } from "path";
+import { join as join7, dirname as dirname5, basename } from "path";
 var SlashCommandProvider = class {
   id = "slash-commands";
   commands;
@@ -5316,7 +5680,7 @@ var FilePathProvider = class {
   complete(input) {
     const lastToken = input.split(/\s+/).pop() ?? "";
     try {
-      const dir = lastToken.endsWith("/") ? join8(this.cwd, lastToken) : join8(this.cwd, dirname5(lastToken));
+      const dir = lastToken.endsWith("/") ? join7(this.cwd, lastToken) : join7(this.cwd, dirname5(lastToken));
       const prefix = lastToken.endsWith("/") ? "" : basename(lastToken);
       const beforeToken = input.slice(0, input.length - lastToken.length);
       const entries = readdirSync(dir, { withFileTypes: true });
@@ -5368,6 +5732,447 @@ var CompletionEngine = class {
   }
 };
 
+// src/init/GlobalInitManager.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir4 } from "os";
+import * as readline from "readline";
+var GLOBAL_CONFIG_TEMPLATE = `# Copair global configuration
+# Generated by Copair on first run \u2014 edit as needed
+
+# provider:
+#   name: anthropic          # anthropic | openai | google | ollama
+#   model: claude-sonnet-4-6
+#   api_key: your-api-key-here
+#   endpoint: ~              # optional override (e.g. for local Ollama)
+
+# identity:
+#   name: ~                  # used in git co-author trailers
+#   email: ~
+
+# ui:
+#   status_bar: true
+#   syntax_highlight: true
+#   vi_mode: false
+#   bordered_input: true
+
+# permissions:
+#   mode: ask                # ask | auto | deny
+
+# context:
+#   summarization_model: ~   # model used for session summarisation
+#   max_sessions: 50
+`;
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim().toLowerCase());
+    });
+  });
+}
+var GlobalInitManager = class {
+  globalDir;
+  constructor(homeDir) {
+    this.globalDir = join8(homeDir ?? homedir4(), ".copair");
+  }
+  async check(options = { ci: false }) {
+    if (existsSync11(this.globalDir)) {
+      return { skipped: true, declined: false, created: false };
+    }
+    if (options.ci) {
+      return { skipped: false, declined: true, created: false };
+    }
+    const answer = await prompt("Set up global Copair config at ~/.copair/? (Y/n) ");
+    const declined = answer === "n" || answer === "no";
+    if (declined) {
+      return { skipped: false, declined: true, created: false };
+    }
+    await this.scaffold();
+    return { skipped: false, declined: false, created: true };
+  }
+  async scaffold() {
+    mkdirSync4(this.globalDir, { recursive: true });
+    const configPath = join8(this.globalDir, "config.yaml");
+    if (!existsSync11(configPath)) {
+      writeFileSync4(configPath, GLOBAL_CONFIG_TEMPLATE, { mode: 384 });
+    }
+  }
+};
+
+// src/init/ProjectInitManager.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
+import * as readline2 from "readline";
+var PROJECT_CONFIG_TEMPLATE = `# Copair project configuration
+# Overrides ~/.copair/config.yaml for this project
+# This file is gitignored \u2014 do not commit
+
+# provider:
+#   model: ~                 # override model for this project
+
+# permissions:
+#   mode: ask
+`;
+function prompt2(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim().toLowerCase());
+    });
+  });
+}
+var ProjectInitManager = class {
+  async check(cwd, options) {
+    const copairDir = join9(cwd, ".copair");
+    if (existsSync12(copairDir)) {
+      return { alreadyInitialised: true, declined: false, created: false };
+    }
+    if (options.ci) {
+      process.stderr.write(
+        "Copair: .copair/ not found. In CI mode, automatic init is skipped.\nRun copair interactively once to initialise this project.\n"
+      );
+      return { alreadyInitialised: false, declined: true, created: false };
+    }
+    const answer = await prompt2("Trust this folder and allow Copair to run here? (y/N) ");
+    const accepted = answer === "y" || answer === "yes";
+    if (!accepted) {
+      return { alreadyInitialised: false, declined: true, created: false };
+    }
+    await this.scaffold(cwd);
+    return { alreadyInitialised: false, declined: false, created: true };
+  }
+  async scaffold(cwd) {
+    const copairDir = join9(cwd, ".copair");
+    mkdirSync5(join9(copairDir, "commands"), { recursive: true });
+    const configPath = join9(copairDir, "config.yaml");
+    if (!existsSync12(configPath)) {
+      writeFileSync5(configPath, PROJECT_CONFIG_TEMPLATE, { mode: 420 });
+    }
+  }
+};
+var DECLINED_MESSAGE = "Copair not initialised. Run copair again in a trusted folder.";
+
+// src/init/GitignoreManager.ts
+import { existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
+import * as readline3 from "readline";
+var FULL_PATTERNS = [".copair/", ".copair"];
+function prompt3(question) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim().toLowerCase());
+    });
+  });
+}
+var GitignoreManager = class {
+  /**
+   * Owns the full classify → prompt → consolidate flow.
+   * Runs on every startup. Skips silently if already fully covered.
+   * In CI mode applies consolidation silently without prompting.
+   */
+  async ensureCovered(cwd, options) {
+    const coverage = await this.classify(cwd);
+    if (coverage === "full") return;
+    if (options.ci) {
+      await this.consolidate(cwd);
+      return;
+    }
+    const answer = await prompt3("Add .copair/ to .gitignore? (Y/n) ");
+    const declined = answer === "n" || answer === "no";
+    if (!declined) {
+      await this.consolidate(cwd);
+    }
+  }
+  async classify(cwd) {
+    const gitignorePath = join10(cwd, ".gitignore");
+    if (!existsSync13(gitignorePath)) return "none";
+    const lines = readFileSync7(gitignorePath, "utf8").split(/\r?\n/).map((l) => l.trim());
+    for (const line of lines) {
+      if (FULL_PATTERNS.includes(line)) return "full";
+    }
+    const hasPartial = lines.some(
+      (l) => l.startsWith(".copair/") && !FULL_PATTERNS.includes(l)
+    );
+    return hasPartial ? "partial" : "none";
+  }
+  async consolidate(cwd) {
+    const gitignorePath = join10(cwd, ".gitignore");
+    let lines = [];
+    if (existsSync13(gitignorePath)) {
+      lines = readFileSync7(gitignorePath, "utf8").split(/\r?\n/);
+    }
+    const filtered = lines.filter((l) => {
+      const trimmed = l.trim();
+      return !trimmed.startsWith(".copair/") || FULL_PATTERNS.includes(trimmed);
+    });
+    while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+      filtered.pop();
+    }
+    filtered.push("", "# Copair runtime state", ".copair/", "");
+    writeFileSync6(gitignorePath, filtered.join("\n"), { encoding: "utf8" });
+  }
+};
+
+// src/knowledge/KnowledgeManager.ts
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join11 } from "path";
+import * as readline4 from "readline";
+var KB_FILENAME2 = "COPAIR_KNOWLEDGE.md";
+var DEFAULT_CONFIG = {
+  warn_size_kb: 8,
+  max_size_kb: 16
+};
+var TRIGGER_PATTERNS = [
+  /^[^/]+\/$/,
+  // new top-level directory
+  /(?:^|\/)(?:index|main|app|server|bin\/)\.[jt]sx?$/,
+  // entry points
+  /(?:^|\/)(?:package\.json|tsconfig.*\.json|\.env\.example|Dockerfile|docker-compose\.ya?ml)$/
+  // config files
+];
+var SKIP_PATTERNS = [
+  /(?:^|\/)tests?\//,
+  // test files
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/
+];
+function promptUser(question) {
+  const rl = readline4.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim().toLowerCase());
+    });
+  });
+}
+var KnowledgeManager = class {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  load(cwd) {
+    const filePath = join11(cwd, KB_FILENAME2);
+    if (!existsSync14(filePath)) {
+      return { found: false, content: null, sizeBytes: 0 };
+    }
+    try {
+      const content = readFileSync8(filePath, "utf8");
+      const sizeBytes = Buffer.byteLength(content, "utf8");
+      return { found: true, content, sizeBytes };
+    } catch {
+      return { found: false, content: null, sizeBytes: 0 };
+    }
+  }
+  injectIntoSystemPrompt(content) {
+    return `<knowledge>
+${content.trim()}
+</knowledge>
+
+`;
+  }
+  checkSizeBudget(sizeBytes) {
+    const warnBytes = this.config.warn_size_kb * 1024;
+    const maxBytes = this.config.max_size_kb * 1024;
+    if (sizeBytes > maxBytes) {
+      throw new Error(
+        `COPAIR_KNOWLEDGE.md exceeds the ${this.config.max_size_kb} KB hard cap (${Math.round(sizeBytes / 1024)} KB). Reduce the file size before starting a session.`
+      );
+    }
+    if (sizeBytes > warnBytes) {
+      process.stderr.write(
+        `[knowledge] Warning: COPAIR_KNOWLEDGE.md is ${Math.round(sizeBytes / 1024)} KB (recommended max: ${this.config.warn_size_kb} KB). Consider trimming it to keep prompts efficient.
+`
+      );
+    }
+  }
+  /**
+   * Evaluate whether the knowledge file needs updating after a task.
+   * Returns a proposed update description if an update is warranted, null otherwise.
+   */
+  evaluateForUpdate(filesChanged, _diff) {
+    if (filesChanged.length === 0) return null;
+    const nonTestFiles = filesChanged.filter(
+      (f) => !SKIP_PATTERNS.some((p) => p.test(f))
+    );
+    if (nonTestFiles.length === 0) return null;
+    const triggers = nonTestFiles.filter(
+      (f) => TRIGGER_PATTERNS.some((p) => p.test(f))
+    );
+    if (triggers.length === 0) return null;
+    return `The following changes may affect the knowledge file:
+` + triggers.map((f) => `  - ${f}`).join("\n") + "\nConsider updating COPAIR_KNOWLEDGE.md to reflect these changes.";
+  }
+  async proposeUpdate(cwd, proposedDiff) {
+    process.stdout.write(
+      "\n[knowledge] Proposed update to COPAIR_KNOWLEDGE.md:\n\n" + proposedDiff + "\n"
+    );
+    const answer = await promptUser("Apply this update to COPAIR_KNOWLEDGE.md? (Y/n) ");
+    const declined = answer === "n" || answer === "no";
+    if (declined) return false;
+    await this.applyUpdate(cwd, proposedDiff);
+    return true;
+  }
+  applyUpdate(cwd, content) {
+    const filePath = join11(cwd, KB_FILENAME2);
+    const sizeBytes = Buffer.byteLength(content, "utf8");
+    const maxBytes = this.config.max_size_kb * 1024;
+    if (sizeBytes > maxBytes) {
+      throw new Error(
+        `Cannot apply update: result would be ${Math.round(sizeBytes / 1024)} KB, exceeding the ${this.config.max_size_kb} KB cap.`
+      );
+    }
+    writeFileSync7(filePath, content, { encoding: "utf8", mode: 420 });
+  }
+};
+
+// src/knowledge/KnowledgeSetupFlow.ts
+import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join12 } from "path";
+import * as readline5 from "readline";
+var SECTIONS = [
+  {
+    key: "directory-map",
+    heading: "## Directory Map",
+    question: 'What are the key directories in this project and what does each own?\n(e.g. "src/ \u2014 all TypeScript source", "bin/ \u2014 CLI entry point")',
+    skippable: false
+  },
+  {
+    key: "tech-stack",
+    heading: "## Tech Stack",
+    question: 'What language, runtime, and key frameworks are in use?\n(e.g. "TypeScript / Node.js 20+, pnpm, vitest")',
+    skippable: false
+  },
+  {
+    key: "naming-conventions",
+    heading: "## Naming Conventions",
+    question: 'Any naming conventions for files, components, variables, or API routes?\n(Type "skip" to omit this section)',
+    skippable: true
+  },
+  {
+    key: "entry-points",
+    heading: "## Entry Points",
+    question: 'What are the key entry points \u2014 main file, config files, bootstrap?\n(e.g. "bin/copair.ts \u2014 CLI entry", "src/session/SessionBootstrap.ts \u2014 startup")',
+    skippable: false
+  },
+  {
+    key: "off-limits",
+    heading: "## Off-Limits",
+    question: 'Any files or directories Copair must not touch without explicit instruction?\n(Type "skip" to omit this section)',
+    skippable: true
+  }
+];
+function createRl() {
+  return readline5.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function ask2(question) {
+  const rl = createRl();
+  return new Promise((resolve9) => {
+    rl.question(question + "\n> ", (answer) => {
+      rl.close();
+      resolve9(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const rl = createRl();
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const lower = answer.trim().toLowerCase();
+      resolve9(lower !== "n" && lower !== "no");
+    });
+  });
+}
+var KnowledgeSetupFlow = class {
+  /**
+   * Prompts the user to set up a COPAIR_KNOWLEDGE.md.
+   * Returns true if a file was written, false if the user declined.
+   */
+  async run(cwd) {
+    const shouldSetup = await confirm(
+      "No knowledge file found. Set one up now? (Y/n) "
+    );
+    if (!shouldSetup) return false;
+    process.stdout.write(
+      "\nLet's build your COPAIR_KNOWLEDGE.md \u2014 a navigation map for Copair.\nAnswer each section (press Enter to confirm).\n\n"
+    );
+    const sections = [];
+    for (const section of SECTIONS) {
+      process.stdout.write(`--- ${section.heading.replace("## ", "")} ---
+`);
+      const answer = await ask2(section.question);
+      if (section.skippable && answer.toLowerCase() === "skip") {
+        process.stdout.write("Skipped.\n\n");
+        continue;
+      }
+      if (!answer.trim()) {
+        process.stdout.write("Skipped (empty).\n\n");
+        continue;
+      }
+      sections.push({ heading: section.heading, content: answer });
+      process.stdout.write("\n");
+    }
+    if (sections.length === 0) {
+      process.stdout.write("No sections provided \u2014 skipping knowledge file creation.\n");
+      return false;
+    }
+    const lines = ["# Copair Knowledge Base", ""];
+    for (const { heading, content } of sections) {
+      lines.push(heading);
+      const contentLines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const line of contentLines) {
+        lines.push(line.startsWith("-") ? line : `- ${line}`);
+      }
+      lines.push("");
+    }
+    const fileContent = lines.join("\n");
+    process.stdout.write("\n--- Draft COPAIR_KNOWLEDGE.md ---\n\n");
+    process.stdout.write(fileContent);
+    process.stdout.write("\n--- End of draft ---\n\n");
+    const write = await confirm("Write COPAIR_KNOWLEDGE.md? (Y/n) ");
+    if (!write) {
+      process.stdout.write("Skipped \u2014 will prompt again next session start.\n");
+      return false;
+    }
+    writeFileSync8(join12(cwd, KB_FILENAME2), fileContent, {
+      encoding: "utf8",
+      mode: 420
+    });
+    process.stdout.write(
+      `
+Wrote ${KB_FILENAME2}. Commit it to version control like README.md.
+
+`
+    );
+    return true;
+  }
+};
+
+// src/utils/environmentUtils.ts
+function isCI() {
+  return !process.stdin.isTTY || !!process.env["CI"] || process.env["COPAIR_CI"] === "1";
+}
+
 // src/index.ts
 function resolveModel(config, modelOverride) {
   const modelAlias = modelOverride ?? config.default_model;
@@ -5421,6 +6226,18 @@ Continue from where we left off.`
 async function main() {
   const cliOpts = parseArgs();
   checkForUpdates();
+  const ci = isCI();
+  const cwd = process.cwd();
+  const globalInitManager = new GlobalInitManager();
+  await globalInitManager.check({ ci });
+  const projectInitManager = new ProjectInitManager();
+  const projectInit = await projectInitManager.check(cwd, { ci });
+  if (projectInit.declined) {
+    console.log(DECLINED_MESSAGE);
+    process.exit(0);
+  }
+  const gitignoreManager = new GitignoreManager();
+  await gitignoreManager.ensureCovered(cwd, { ci });
   const config = loadConfig();
   const { providerName, modelAlias, providerConfig } = resolveModel(
     config,
@@ -5453,50 +6270,45 @@ async function main() {
       }
     });
   }
-  const firstInit = ensureProjectInit(process.cwd());
-  if (firstInit) {
-    console.log("Initialized .copair/ for this project. Config: .copair.yaml");
+  gate.addTrustedPath(join13(cwd, ".copair"));
+  const gitCtx = detectGitContext(cwd);
+  const knowledgeManager = new KnowledgeManager({
+    warn_size_kb: config.knowledge.warn_size_kb,
+    max_size_kb: config.knowledge.max_size_kb
+  });
+  const knowledgeResult = knowledgeManager.load(cwd);
+  let knowledgePrefix = "";
+  if (knowledgeResult.found && knowledgeResult.content) {
+    knowledgeManager.checkSizeBudget(knowledgeResult.sizeBytes);
+    knowledgePrefix = knowledgeManager.injectIntoSystemPrompt(knowledgeResult.content);
+  } else if (!ci) {
+    const setupFlow = new KnowledgeSetupFlow();
+    const written = await setupFlow.run(cwd);
+    if (written) {
+      const refreshed = knowledgeManager.load(cwd);
+      if (refreshed.found && refreshed.content) {
+        knowledgeManager.checkSizeBudget(refreshed.sizeBytes);
+        knowledgePrefix = knowledgeManager.injectIntoSystemPrompt(refreshed.content);
+      }
+    }
   }
-  gate.addTrustedPath(join9(process.cwd(), ".copair"));
-  gate.addTrustedPath(join9(process.cwd(), ".copair.yaml"));
-  const gitCtx = detectGitContext(process.cwd());
-  const knowledgeBase = new KnowledgeBase(process.cwd(), config.context.knowledge_max_size);
+  const knowledgeBase = new KnowledgeBase(cwd, config.context.knowledge_max_size);
   setKnowledgeBase(knowledgeBase);
-  const kbSection = knowledgeBase.getSystemPromptSection();
   const agent = new Agent(provider, modelAlias, toolRegistry, executor, {
     bridge: agentBridge,
     systemPrompt: `You are Copair, an AI coding assistant.
 
 Environment:
-- Working directory: ${process.cwd()}
-- All file paths MUST be absolute (start with ${process.cwd()}/)
-
-Context awareness:
-- Your context includes this system prompt, the full conversation history (all prior messages in this session), and any project knowledge shown below.
-- When asked about context, awareness, or what you know \u2014 answer from the conversation history and the knowledge section below. Do NOT read COPAIR_KNOWLEDGE.md or any other file to answer meta-questions about your own state.
-- The knowledge base below (if present) was already loaded from COPAIR_KNOWLEDGE.md at startup. Use the update_knowledge tool only to ADD new entries, not to read existing ones.
-
-Rules:
-- You MUST use tools to perform actions. NEVER describe or narrate actions \u2014 execute them.
-- NEVER simulate, roleplay, or pretend to run commands. If you need to do something, call the tool.
-- Be brief. No preamble, no filler. No summaries between steps.
-- If a tool returns an error, adjust your approach \u2014 do NOT repeat the same call.
-
-Work habits:
-- Read before editing. Keep changes minimal.
-- Auto-commit each discrete feature, fix, or refactor. Do not batch unrelated changes.
-- When you learn something project-specific (conventions, patterns, architectural decisions), use the update_knowledge tool to record it.
+- Working directory: ${cwd}
+- All file paths MUST be absolute (start with ${cwd}/)
 
-Git:
-- Branches: <type>/<kebab-desc> (feat, fix, chore, docs, refactor, test, perf)
-- Commits: <type>(<scope>): <imperative subject, max 72 chars>
-  Body: 2-3 concise bullets. Co-authored-by is auto-appended.
-- NEVER use --no-verify, --force, or --no-gpg-sign.` + kbSection
+` + // [2] Knowledge block — injected before file context
+    knowledgePrefix + "Context awareness:\n- Your context includes this system prompt, the full conversation history (all prior messages in this session), and any project knowledge shown above in <knowledge> tags.\n- When asked about context, awareness, or what you know \u2014 answer from the conversation history and the knowledge section. Do NOT read COPAIR_KNOWLEDGE.md to answer meta-questions about your own state.\n- COPAIR_KNOWLEDGE.md is a navigation map, not a context dump. Never write ephemeral notes or session context into it. Propose targeted diffs only when structure, conventions, or entry points change.\n\nRules:\n- You MUST use tools to perform actions. NEVER describe or narrate actions \u2014 execute them.\n- NEVER simulate, roleplay, or pretend to run commands. If you need to do something, call the tool.\n- Be brief. No preamble, no filler. No summaries between steps.\n- If a tool returns an error, adjust your approach \u2014 do NOT repeat the same call.\n\nWork habits:\n- Read before editing. Keep changes minimal.\n- Auto-commit each discrete feature, fix, or refactor. Do not batch unrelated changes.\n\nGit:\n- Branches: <type>/<kebab-desc> (feat, fix, chore, docs, refactor, test, perf)\n- Commits: <type>(<scope>): <imperative subject, max 72 chars>\n  Body: 2-3 concise bullets. Co-authored-by is auto-appended.\n- NEVER use --no-verify, --force, or --no-gpg-sign."
   });
-  const sessionManager = new SessionManager(process.cwd());
-  const sessionsDir = resolveSessionsDir(process.cwd());
-  warnIfSessionsTracked(process.cwd());
-  await SessionManager.migrateGlobalRecovery(sessionsDir, process.cwd());
+  const sessionManager = new SessionManager(cwd);
+  const sessionsDir = resolveSessionsDir(cwd);
+  warnIfSessionsTracked(cwd);
+  await SessionManager.migrateGlobalRecovery(sessionsDir, cwd);
   await SessionManager.cleanup(sessionsDir, config.context.max_sessions);
   let sessionResumed = false;
   const sessions = await SessionManager.listSessions(sessionsDir);
@@ -5531,14 +6343,14 @@ Git:
   let identifierDerived = sessionResumed;
   setSessionManagerRef(sessionManager);
   const agentContext = {
-    cwd: process.cwd(),
+    cwd,
     model: modelAlias,
     branch: gitCtx.branch
   };
   const cmdRegistry = new CommandRegistry();
   const workflowCmd = createWorkflowCommand(
-    async (prompt) => {
-      await agent.handleMessage(prompt);
+    async (prompt4) => {
+      await agent.handleMessage(prompt4);
     },
     async (input) => {
       const result = await cmdRegistry.execute(input, { ...agentContext, model: agent.model });
@@ -5554,7 +6366,7 @@ Git:
     workflowCmd
   );
   const tokenTracker = new TokenTracker(DEFAULT_PRICING);
-  const historyPath = resolveHistoryPath(process.cwd());
+  const historyPath = resolveHistoryPath(cwd);
   const inputHistory = loadHistory(historyPath);
   const completionEngine = new CompletionEngine();
   const cmdNames = /* @__PURE__ */ new Map();
@@ -5567,7 +6379,7 @@ Git:
   cmdNames.set("clear", "Clear conversation");
   cmdNames.set("model", "Switch model");
   completionEngine.addProvider(new SlashCommandProvider(cmdNames));
-  completionEngine.addProvider(new FilePathProvider(process.cwd()));
+  completionEngine.addProvider(new FilePathProvider(cwd));
   printBanner(modelAlias);
   await new Promise((r) => setTimeout(r, 50));
   let appHandle = null;