@harperfast/agent 0.16.6 → 0.16.8

package/dist/{agent.js → chunk-LSVGOLBU.js}

@@ -1,14 +1,15 @@
-#!/usr/bin/env node
-
 // ink/emitters/listener.ts
 import React, { useCallback, useEffect } from "react";
 var listenersMap = {};
+var emittedMap = {};
 function useListener(name, listener, deps) {
   const listenerRef = React.useRef(listener);
   React.useEffect(() => {
     listenerRef.current = listener;
   }, [listener]);
-  const callback = useCallback((newValue, trigger) => listenerRef.current(newValue, trigger), [deps]);
+  const callback = useCallback((newValue, trigger) => {
+    return listenerRef.current(newValue, trigger);
+  }, [deps]);
   useEffect(() => {
     if (!listenersMap[name]) {
       listenersMap[name] = [];
@@ -38,6 +39,7 @@ async function onceListener(name) {
   });
 }
 function emitToListeners(name, value, trigger) {
+  emittedMap[name] = value;
   const listeners = listenersMap[name];
   if (listeners) {
     const stableCopyOfListeners = listeners.slice();
@@ -46,6 +48,9 @@ function emitToListeners(name, value, trigger) {
     }
   }
 }
+function lastEmittedValue(name) {
+  return emittedMap[name];
+}
 function addListener(name, callback) {
   if (!listenersMap[name]) {
     listenersMap[name] = [];
@@ -62,151 +67,6 @@ function curryEmitToListeners(name, value, trigger) {
   return (e) => emitToListeners(name, value, trigger ?? e);
 }
 
-// utils/sessions/rateLimits.ts
-var RateLimitTracker = class {
-  status = {
-    limitRequests: null,
-    limitTokens: null,
-    remainingRequests: null,
-    remainingTokens: null,
-    resetRequests: null,
-    resetTokens: null,
-    retryAfter: null
-  };
-  updateFromHeaders(headers) {
-    const normalizedHeaders = {};
-    for (const key of Object.keys(headers)) {
-      normalizedHeaders[key.toLowerCase()] = headers[key];
-    }
-    const getHeader = (name) => {
-      const value = normalizedHeaders[name.toLowerCase()];
-      return Array.isArray(value) ? value[0] : value;
-    };
-    const limitRequests = getHeader("x-ratelimit-limit-requests") || getHeader("anthropic-ratelimit-requests-limit") || getHeader("x-ratelimit-limit") || getHeader("ratelimit-limit") || getHeader("x-request-limit");
-    const limitTokens = getHeader("x-ratelimit-limit-tokens") || getHeader("anthropic-ratelimit-tokens-limit") || getHeader("x-token-limit");
-    const remainingRequests = getHeader("x-ratelimit-remaining-requests") || getHeader("anthropic-ratelimit-requests-remaining") || getHeader("x-ratelimit-remaining") || getHeader("ratelimit-remaining") || getHeader("x-request-remaining");
-    const remainingTokens = getHeader("x-ratelimit-remaining-tokens") || getHeader("anthropic-ratelimit-tokens-remaining") || getHeader("x-token-remaining");
-    const resetRequests = getHeader("x-ratelimit-reset-requests") || getHeader("anthropic-ratelimit-requests-reset") || getHeader("x-ratelimit-reset") || getHeader("ratelimit-reset") || getHeader("x-request-reset");
-    const resetTokens = getHeader("x-ratelimit-reset-tokens") || getHeader("anthropic-ratelimit-tokens-reset") || getHeader("x-token-reset");
-    const retryAfter = getHeader("retry-after");
-    if (limitRequests) {
-      this.status.limitRequests = parseInt(limitRequests, 10);
-    }
-    if (limitTokens) {
-      this.status.limitTokens = parseInt(limitTokens, 10);
-    }
-    if (remainingRequests) {
-      this.status.remainingRequests = parseInt(remainingRequests, 10);
-    }
-    if (remainingTokens) {
-      this.status.remainingTokens = parseInt(remainingTokens, 10);
-    }
-    if (resetRequests) {
-      this.status.resetRequests = resetRequests;
-    }
-    if (resetTokens) {
-      this.status.resetTokens = resetTokens;
-    }
-    if (retryAfter) {
-      this.status.retryAfter = parseInt(retryAfter, 10);
-    }
-  }
-  isApproachingLimit(threshold) {
-    const usage = this.getUsagePercentage();
-    return {
-      requests: usage.requests >= threshold,
-      tokens: usage.tokens >= threshold
-    };
-  }
-  getStatus() {
-    return { ...this.status };
-  }
-  getUsagePercentage() {
-    const requests = this.status.limitRequests && this.status.remainingRequests !== null ? 100 * (1 - this.status.remainingRequests / this.status.limitRequests) : 0;
-    const tokens = this.status.limitTokens && this.status.remainingTokens !== null ? 100 * (1 - this.status.remainingTokens / this.status.limitTokens) : 0;
-    return { requests, tokens };
-  }
-  reset() {
-    this.status = {
-      limitRequests: null,
-      limitTokens: null,
-      remainingRequests: null,
-      remainingTokens: null,
-      resetRequests: null,
-      resetTokens: null,
-      retryAfter: null
-    };
-  }
-};
-var rateLimitTracker = new RateLimitTracker();
-
-// lifecycle/patchFetch.ts
-var originalFetch = globalThis.fetch;
-if (originalFetch) {
-  globalThis.fetch = async (...args) => {
-    const response = await originalFetch(...args);
-    const headers = {};
-    response.headers.forEach((value, key) => {
-      headers[key] = value;
-    });
-    const commonHeaders = [
-      "x-ratelimit-limit-requests",
-      "x-ratelimit-limit-tokens",
-      "x-ratelimit-remaining-requests",
-      "x-ratelimit-remaining-tokens",
-      "x-ratelimit-reset-requests",
-      "x-ratelimit-reset-tokens",
-      "anthropic-ratelimit-requests-limit",
-      "anthropic-ratelimit-requests-remaining",
-      "anthropic-ratelimit-requests-reset",
-      "anthropic-ratelimit-tokens-limit",
-      "anthropic-ratelimit-tokens-remaining",
-      "anthropic-ratelimit-tokens-reset",
-      "retry-after"
-    ];
-    for (const key of commonHeaders) {
-      if (!headers[key]) {
-        const val = response.headers.get(key);
-        if (val) {
-          headers[key] = val;
-        }
-      }
-    }
-    rateLimitTracker.updateFromHeaders(headers);
-    emitToListeners("SettingsUpdated", void 0);
-    const retryAfter = response.headers.get("retry-after");
-    if (retryAfter) {
-      const seconds = parseInt(retryAfter, 10);
-      if (!isNaN(seconds) && seconds > 0) {
-        emitToListeners("PushNewMessages", [{
-          type: "interrupted",
-          text: `Rate limit reached. Sleeping for ${seconds} seconds (Retry-After)...`,
-          version: 1
-        }]);
-        await new Promise((resolve2) => setTimeout(resolve2, seconds * 1e3));
-      }
-    }
-    return response;
-  };
-}
-
-// agent.ts
-import chalk7 from "chalk";
-
-// agent/AgentManager.ts
-import { Agent as Agent3 } from "@openai/agents";
-
-// ink/contexts/globalPlanContext.ts
-var globalPlanContext = {
-  planDescription: "",
-  planItems: [],
-  progress: 0
-};
-
-// lifecycle/defaultInstructions.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-
 // utils/files/harperApp.ts
 import { existsSync } from "fs";
 import path, { dirname, join } from "path";
@@ -274,110 +134,6 @@ function bootstrapTrackedState() {
   };
 }
 
-// lifecycle/defaultInstructions.ts
-function defaultInstructions() {
-  const harperAppExists = existsSync2(join2(trackedState.cwd, "config.yaml"));
-  const vibing = harperAppExists ? "updating" : "creating";
-  return `You are working on ${vibing} a harper app with the user.`;
-}
-
-// lifecycle/getModel.ts
-import { anthropic } from "@ai-sdk/anthropic";
-import { google } from "@ai-sdk/google";
-import { openai } from "@ai-sdk/openai";
-import { aisdk } from "@openai/agents-extensions/ai-sdk";
-import { createOllama, ollama } from "ollama-ai-provider-v2";
-
-// agent/defaults.ts
-var defaultModelToken = "default";
-var defaultOpenAIModel = "gpt-5.2";
-var defaultOpenAICompactionModel = "gpt-5-nano";
-var defaultAnthropicModel = "claude-4-6-opus-latest";
-var defaultAnthropicCompactionModel = "claude-4-5-haiku-latest";
-var defaultGoogleModel = "gemini-3-pro";
-var defaultGoogleCompactionModel = "gemini-2.5-flash-lite";
-var defaultOllamaModel = "ollama-qwen3.5";
-var defaultOllamaCompactionModel = "ollama-qwen3.5:2b";
-var defaultModels = [
-  defaultOpenAIModel,
-  defaultAnthropicModel,
-  defaultGoogleModel,
-  defaultOllamaModel
-];
-var defaultCompactionModels = [
-  defaultOpenAICompactionModel,
-  defaultAnthropicCompactionModel,
-  defaultGoogleCompactionModel,
-  defaultOllamaCompactionModel
-];
-
-// utils/ollama/normalizeOllamaBaseUrl.ts
-function normalizeOllamaBaseUrl(baseUrl) {
-  let url = baseUrl.trim();
-  if (!url.startsWith("http://") && !url.startsWith("https://")) {
-    url = `http://${url}`;
-  }
-  const urlObj = new URL(url);
-  if (!urlObj.port) {
-    urlObj.port = "11434";
-  }
-  let pathname = urlObj.pathname;
-  if (pathname.endsWith("/")) {
-    pathname = pathname.slice(0, -1);
-  }
-  if (!pathname.endsWith("/api")) {
-    pathname += "/api";
-  }
-  urlObj.pathname = pathname;
-  return urlObj.toString().replace(/\/$/, "");
-}
-
-// lifecycle/getModel.ts
-function isOpenAIModel(modelName) {
-  if (!modelName || modelName === defaultOpenAIModel) {
-    return true;
-  }
-  return !modelName.startsWith("claude-") && !modelName.startsWith("gemini-") && !modelName.startsWith("ollama-") && !modelName.includes(":");
-}
-function getProvider(modelName) {
-  if (modelName.startsWith("claude-")) {
-    return "Anthropic";
-  }
-  if (modelName.startsWith("gemini-")) {
-    return "Google";
-  }
-  if (modelName.startsWith("ollama-") || modelName.includes(":")) {
-    return "Ollama";
-  }
-  return "OpenAI";
-}
-function getModel(modelName) {
-  if (modelName.startsWith("claude-")) {
-    return aisdk(anthropic(modelName));
-  }
-  if (modelName.startsWith("gemini-")) {
-    return aisdk(google(modelName));
-  }
-  if (modelName.startsWith("ollama-") || modelName.includes(":")) {
-    const ollamaBaseUrl = process.env.OLLAMA_BASE_URL ? normalizeOllamaBaseUrl(process.env.OLLAMA_BASE_URL) : void 0;
-    const ollamaProvider = ollamaBaseUrl ? createOllama({ baseURL: ollamaBaseUrl, compatibility: "strict" }) : ollama;
-    return aisdk(ollamaProvider(getModelName(modelName)));
-  }
-  return aisdk(openai(modelName));
-}
-function getModelName(modelName) {
-  if (modelName.startsWith("claude-")) {
-    return modelName;
-  }
-  if (modelName.startsWith("gemini-")) {
-    return modelName;
-  }
-  if (modelName.startsWith("ollama-")) {
-    return modelName.slice(7);
-  }
-  return modelName;
-}
-
 // lifecycle/handleExit.ts
 import { getGlobalTraceProvider } from "@openai/agents";
 
@@ -385,7 +141,7 @@ import { getGlobalTraceProvider } from "@openai/agents";
 import spawn from "cross-spawn";
 import { execSync } from "child_process";
 import { homedir } from "os";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 var HarperProcess = class {
   childProcess = null;
   externalPid = null;
@@ -421,7 +177,7 @@ var HarperProcess = class {
     this.stopTailingLogs();
   }
   startTailingLogs() {
-    const logPath = join3(homedir(), "hdb", "log", "hdb.log");
+    const logPath = join2(homedir(), "hdb", "log", "hdb.log");
     this.logTailProcess = spawn("tail", ["-f", logPath], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -501,38 +257,181 @@ async function handleExit() {
   process.exit(0);
 }
 
-// lifecycle/readAgentSkillsRoot.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { join as join4 } from "path";
-
-// lifecycle/agentsSkillReference.ts
-var agentsSkillDir = ".agents/skills/harper-best-practices";
-var agentsSkillReference = `${agentsSkillDir}/SKILL.md`;
+// utils/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+var ERROR_LOG_PATH = join3(homedir2(), ".harper", "harper-agent-errors");
+function logError(error) {
+  const message = error instanceof Error ? error.stack || error.message : String(error);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logEntry = `[${timestamp}] ${message}
 
-// lifecycle/readAgentSkillsRoot.ts
-function readAgentSkillsRoot() {
-  const agentsFile = join4(trackedState.cwd, agentsSkillReference);
-  const agentsMdExists = existsSync3(agentsFile);
-  if (agentsMdExists) {
-    return readFileSync(agentsFile, "utf8");
+`;
+  try {
+    const dir = dirname2(ERROR_LOG_PATH);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    appendFileSync(ERROR_LOG_PATH, logEntry, "utf8");
+  } catch (err) {
+    console.error("Failed to write to error log:", err);
+    console.error("Original error:", error);
   }
 }
+function setupGlobalErrorHandlers() {
+  process.on("uncaughtException", (error) => {
+    logError(error);
+    console.error("Uncaught Exception:", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logError(reason);
+    console.error("Unhandled Rejection:", reason);
+  });
+}
 
-// tools/browser/browserClickTool.ts
-import { tool } from "@openai/agents";
-import { z } from "zod";
+// agent/AgentManager.ts
+import { Agent as Agent3 } from "@openai/agents";
 
-// tools/browser/browserManager.ts
-var browser = null;
-var page = null;
-var logs = [];
-async function getBrowser() {
-  if (!browser) {
-    let puppeteer;
-    try {
-      puppeteer = await import("puppeteer");
-    } catch {
-      throw new Error(
+// lifecycle/defaultInstructions.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+function defaultInstructions() {
+  const harperAppExists = existsSync3(join4(trackedState.cwd, "config.yaml"));
+  const vibing = harperAppExists ? "updating" : "creating";
+  return `You are working on ${vibing} a harper app with the user.`;
+}
+
+// lifecycle/getModel.ts
+import { anthropic } from "@ai-sdk/anthropic";
+import { google } from "@ai-sdk/google";
+import { openai } from "@ai-sdk/openai";
+import { aisdk } from "@openai/agents-extensions/ai-sdk";
+import { createOllama, ollama } from "ollama-ai-provider-v2";
+
+// agent/defaults.ts
+var defaultModelToken = "default";
+var defaultOpenAIModel = "gpt-5.2";
+var defaultOpenAICompactionModel = "gpt-5-nano";
+var defaultAnthropicModel = "claude-4-6-opus-latest";
+var defaultAnthropicCompactionModel = "claude-4-5-haiku-latest";
+var defaultGoogleModel = "gemini-3-pro";
+var defaultGoogleCompactionModel = "gemini-2.5-flash-lite";
+var defaultOllamaModel = "ollama-qwen3.5";
+var defaultOllamaCompactionModel = "ollama-qwen3.5:2b";
+var defaultModels = [
+  defaultOpenAIModel,
+  defaultAnthropicModel,
+  defaultGoogleModel,
+  defaultOllamaModel
+];
+var defaultCompactionModels = [
+  defaultOpenAICompactionModel,
+  defaultAnthropicCompactionModel,
+  defaultGoogleCompactionModel,
+  defaultOllamaCompactionModel
+];
+
+// utils/ollama/normalizeOllamaBaseUrl.ts
+function normalizeOllamaBaseUrl(baseUrl) {
+  let url = baseUrl.trim();
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `http://${url}`;
+  }
+  const urlObj = new URL(url);
+  if (!urlObj.port) {
+    urlObj.port = "11434";
+  }
+  let pathname = urlObj.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  if (!pathname.endsWith("/api")) {
+    pathname += "/api";
+  }
+  urlObj.pathname = pathname;
+  return urlObj.toString().replace(/\/$/, "");
+}
+
+// lifecycle/getModel.ts
+function isOpenAIModel(modelName) {
+  if (!modelName || modelName === defaultOpenAIModel) {
+    return true;
+  }
+  return !modelName.startsWith("claude-") && !modelName.startsWith("gemini-") && !modelName.startsWith("ollama-") && !modelName.includes(":");
+}
+function getProvider(modelName) {
+  if (modelName.startsWith("claude-")) {
+    return "Anthropic";
+  }
+  if (modelName.startsWith("gemini-")) {
+    return "Google";
+  }
+  if (modelName.startsWith("ollama-") || modelName.includes(":")) {
+    return "Ollama";
+  }
+  return "OpenAI";
+}
+function getModel(modelName) {
+  if (modelName.startsWith("claude-")) {
+    return aisdk(anthropic(modelName));
+  }
+  if (modelName.startsWith("gemini-")) {
+    return aisdk(google(modelName));
+  }
+  if (modelName.startsWith("ollama-") || modelName.includes(":")) {
+    const ollamaBaseUrl = process.env.OLLAMA_BASE_URL ? normalizeOllamaBaseUrl(process.env.OLLAMA_BASE_URL) : void 0;
+    const ollamaProvider = ollamaBaseUrl ? createOllama({ baseURL: ollamaBaseUrl, compatibility: "strict" }) : ollama;
+    return aisdk(ollamaProvider(getModelName(modelName)));
+  }
+  return aisdk(openai(modelName));
+}
+function getModelName(modelName) {
+  if (modelName.startsWith("claude-")) {
+    return modelName;
+  }
+  if (modelName.startsWith("gemini-")) {
+    return modelName;
+  }
+  if (modelName.startsWith("ollama-")) {
+    return modelName.slice(7);
+  }
+  return modelName;
+}
+
+// lifecycle/readAgentSkillsRoot.ts
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { join as join5 } from "path";
+
+// lifecycle/agentsSkillReference.ts
+var agentsSkillDir = ".agents/skills/harper-best-practices";
+var agentsSkillReference = `${agentsSkillDir}/SKILL.md`;
+
+// lifecycle/readAgentSkillsRoot.ts
+function readAgentSkillsRoot() {
+  const agentsFile = join5(trackedState.cwd, agentsSkillReference);
+  const agentsMdExists = existsSync4(agentsFile);
+  if (agentsMdExists) {
+    return readFileSync(agentsFile, "utf8");
+  }
+}
+
+// tools/browser/browserClickTool.ts
+import { tool } from "@openai/agents";
+import { z } from "zod";
+
+// tools/browser/browserManager.ts
+var browser = null;
+var page = null;
+var logs = [];
+async function getBrowser() {
+  if (!browser) {
+    let puppeteer;
+    try {
+      puppeteer = await import("puppeteer");
+    } catch {
+      throw new Error(
         "Puppeteer is not installed. Browser tools require puppeteer. Please install it with `npm install puppeteer`."
       );
     }
@@ -814,21 +713,21 @@ function getEnv(newKey, oldKey) {
 import { tool as tool10 } from "@openai/agents";
 import { readdirSync, readFileSync as readFileSync2 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 import { z as z10 } from "zod";
 var require2 = createRequire(import.meta.url);
-var harperSkillsModuleDir = dirname2(
+var harperSkillsModuleDir = dirname3(
   require2.resolve("@harperfast/skills/package.json")
 );
-var harperBestPracticesDir = join5(
+var harperBestPracticesDir = join6(
   harperSkillsModuleDir,
   "harper-best-practices"
 );
-var skillRootFile = join5(
+var skillRootFile = join6(
   harperBestPracticesDir,
   "SKILL.md"
 );
-var rulesDir = join5(
+var rulesDir = join6(
   harperBestPracticesDir,
   "rules"
 );
@@ -864,7 +763,7 @@ async function execute10({ skill }) {
     return "No skill requested.";
   }
   try {
-    const filePath = join5(rulesDir, `${skill}.md`);
+    const filePath = join6(rulesDir, `${skill}.md`);
     const content = readFileSync2(filePath, "utf8");
     agentManager.session?.addSkillRead?.(skill);
     return content;
@@ -899,42 +798,6 @@ import path3 from "path";
 // utils/files/aiignore.ts
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import path2 from "path";
-
-// utils/logger.ts
-import { appendFileSync, existsSync as existsSync4, mkdirSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join6 } from "path";
-var ERROR_LOG_PATH = join6(homedir2(), ".harper", "harper-agent-errors");
-function logError(error) {
-  const message = error instanceof Error ? error.stack || error.message : String(error);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const logEntry = `[${timestamp}] ${message}
-
-`;
-  try {
-    const dir = dirname3(ERROR_LOG_PATH);
-    if (!existsSync4(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    appendFileSync(ERROR_LOG_PATH, logEntry, "utf8");
-  } catch (err) {
-    console.error("Failed to write to error log:", err);
-    console.error("Original error:", error);
-  }
-}
-function setupGlobalErrorHandlers() {
-  process.on("uncaughtException", (error) => {
-    logError(error);
-    console.error("Uncaught Exception:", error);
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (reason) => {
-    logError(reason);
-    console.error("Unhandled Rejection:", reason);
-  });
-}
-
-// utils/files/aiignore.ts
 var ignorePatterns = [];
 function loadAiIgnore() {
   const ignorePath = path2.join(trackedState.cwd, ".aiignore");
@@ -1165,11 +1028,11 @@ function pickExistingSkill(candidates) {
   }
   return null;
 }
-async function requiredSkillForOperation(path10, type) {
+async function requiredSkillForOperation(path9, type) {
   if (type === "delete_file") {
     return null;
   }
-  const p = normalizedPath(path10);
+  const p = normalizedPath(path9);
   const read = await getSkillsRead();
   if (p.includes("/resources/") || p.startsWith("resources/") || p.endsWith("resources.ts") || p.endsWith("resources.js")) {
     if (!read.includes("automatic-apis")) {
@@ -1282,9 +1145,9 @@ import { z as z12 } from "zod";
 var ToolParameters11 = z12.object({
   path: z12.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
 });
-async function execute12({ path: path10 }) {
+async function execute12({ path: path9 }) {
   try {
-    const target = resolvePath(trackedState.cwd, path10);
+    const target = resolvePath(trackedState.cwd, path9);
     const stat = statSync(target);
     if (!stat.isDirectory()) {
       return `Path is not a directory: ${target}`;
@@ -2281,14 +2144,14 @@ var hitHarperAPITool = tool35({
     }
     return false;
   },
-  async execute({ path: path10 = "/openapi", port, method = "GET", body }) {
+  async execute({ path: path9 = "/openapi", port, method = "GET", body }) {
     try {
       const effectivePort = port ?? (harperProcess.running ? harperProcess.httpPort : void 0);
       if (!effectivePort) {
         return `Error: No Harper application is currently running and no port was specified.`;
       }
       const response = await fetch(
-        `http://localhost:${effectivePort}${path10.startsWith("/") ? "" : "/"}${path10}`,
+        `http://localhost:${effectivePort}${path9.startsWith("/") ? "" : "/"}${path9}`,
         {
           method,
           headers: body ? { "Content-Type": "application/json" } : {},
@@ -2393,29 +2256,35 @@ var stopHarperTool = tool38({
   }
 });
 
-// tools/plan/addPlanItemTool.ts
+// tools/plan/createAddPlanItemTool.ts
 import { tool as tool39 } from "@openai/agents";
 import { z as z39 } from "zod";
 var AddPlanItemParameters = z39.object({
   text: z39.string().describe("The description of the task or milestone to add to the plan.")
 });
-var addPlanItemTool = tool39({
-  name: "add_plan_item",
-  description: "Add a new item to the plan.",
-  parameters: AddPlanItemParameters,
-  async execute({ text }) {
-    const newItems = [
-      ...globalPlanContext.planItems,
-      {
-        id: globalPlanContext.planItems.length + 1,
-        text,
-        status: "todo"
-      }
-    ];
-    emitToListeners("SetPlanItems", newItems);
-    return `Added plan item: ${text}`;
-  }
-});
+function createAddPlanItemTool(session) {
+  return tool39({
+    name: "add_plan_item",
+    description: "Add a new item to the plan.",
+    parameters: AddPlanItemParameters,
+    async execute({ text }) {
+      const planContext = await session.getPlanState();
+      const existingPlanItems = planContext.planItems;
+      const newItems = [
+        ...existingPlanItems,
+        {
+          id: existingPlanItems.length + 1,
+          text,
+          status: "todo"
+        }
+      ];
+      planContext.planItems = newItems;
+      session.setPlanState(planContext);
+      emitToListeners("SetPlanItems", newItems);
+      return `Added plan item: ${text}`;
+    }
+  });
+}
 
 // tools/plan/setPlanDescriptionTool.ts
 import { tool as tool40 } from "@openai/agents";
@@ -2423,15 +2292,20 @@ import { z as z40 } from "zod";
 var SetPlanDescriptionParameters = z40.object({
   description: z40.string().describe("A high-level description of the overall plan and goals.")
 });
-var setPlanDescriptionTool = tool40({
-  name: "set_plan_description",
-  description: "Set the high-level description for the current plan.",
-  parameters: SetPlanDescriptionParameters,
-  async execute({ description }) {
-    emitToListeners("SetPlanDescription", description);
-    return `Plan description updated to: ${description}`;
-  }
-});
+function createSetPlanDescriptionTool(session) {
+  return tool40({
+    name: "set_plan_description",
+    description: "Set the high-level description for the current plan.",
+    parameters: SetPlanDescriptionParameters,
+    async execute({ description }) {
+      const planContext = await session.getPlanState();
+      planContext.planDescription = description;
+      session.setPlanState(planContext);
+      emitToListeners("SetPlanDescription", description);
+      return `Plan description updated to: ${description}`;
+    }
+  });
+}
 
 // tools/plan/setPlanItemsTool.ts
 import { tool as tool41 } from "@openai/agents";
@@ -2439,20 +2313,25 @@ import { z as z41 } from "zod";
 var SetPlanItemsParameters = z41.object({
   items: z41.array(z41.string()).describe("An array of task descriptions to set as the plan items.")
 });
-var setPlanItemsTool = tool41({
-  name: "set_plan_items",
-  description: "Set multiple plan items at once, replacing any existing items.",
-  parameters: SetPlanItemsParameters,
-  async execute({ items }) {
-    const newItems = items.map((text, index) => ({
-      id: index + 1,
-      text,
-      status: "todo"
-    }));
-    emitToListeners("SetPlanItems", newItems);
-    return `Set ${newItems.length} plan items.`;
-  }
-});
+function createSetPlanItemsTool(session) {
+  return tool41({
+    name: "set_plan_items",
+    description: "Set multiple plan items at once, replacing any existing items.",
+    parameters: SetPlanItemsParameters,
+    async execute({ items }) {
+      const planContext = await session.getPlanState();
+      const newItems = items.map((text, index) => ({
+        id: index + 1,
+        text,
+        status: "todo"
+      }));
+      planContext.planItems = newItems;
+      session.setPlanState(planContext);
+      emitToListeners("SetPlanItems", newItems);
+      return `Set ${newItems.length} plan items.`;
+    }
+  });
+}
 
 // tools/plan/updatePlanItemTool.ts
 import { tool as tool42 } from "@openai/agents";
@@ -2464,32 +2343,51 @@ var UpdatePlanItemParameters = z42.object({
     "The new status of the task."
   )
 });
-var updatePlanItemTool = tool42({
-  name: "update_plan_item",
-  description: "Update an existing plan item.",
-  parameters: UpdatePlanItemParameters,
-  async execute({ id, text, status }) {
-    const newItems = globalPlanContext.planItems.map((item) => {
-      if (item.id === id) {
-        return {
-          ...item,
-          text: text || item.text,
-          status: status && status !== "unchanged" ? status : item.status
-        };
-      }
-      return item;
-    });
-    const itemExists = globalPlanContext.planItems.some((item) => item.id === id);
-    if (!itemExists) {
-      return `Error: Plan item with ID ${id} not found.`;
+function createUpdatePlanItemTool(session) {
+  return tool42({
+    name: "update_plan_item",
+    description: "Update an existing plan item.",
+    parameters: UpdatePlanItemParameters,
+    async execute({ id, text, status }) {
+      const planContext = await session.getPlanState();
+      const planItems = planContext?.planItems ?? [];
+      const itemExists = planItems.some((item) => item.id === id);
+      if (!itemExists) {
+        return `Error: Plan item with ID ${id} not found.`;
+      }
+      const newItems = planItems.map((item) => {
+        if (item.id === id) {
+          return {
+            ...item,
+            text: text || item.text,
+            status: status && status !== "unchanged" ? status : item.status
+          };
+        }
+        return item;
+      });
+      planContext.planItems = newItems;
+      session.setPlanState(planContext);
+      emitToListeners("SetPlanItems", newItems);
+      return `Updated plan item ${id}`;
     }
-    emitToListeners("SetPlanItems", newItems);
-    return `Updated plan item ${id}`;
-  }
-});
+  });
+}
 
 // tools/factory.ts
-function createTools() {
+function createSharedTools(session) {
+  return [
+    collectFeedbackTool,
+    createAddPlanItemTool(session),
+    createSetPlanDescriptionTool(session),
+    createSetPlanItemsTool(session),
+    createUpdatePlanItemTool(session),
+    getHarperConfigSchemaTool,
+    getHarperResourceInterfaceTool,
+    getHarperSchemaGraphQLTool,
+    getHarperSkillTool
+  ];
+}
+function createCLITools(_session) {
   return [
     browserClickTool,
     browserCloseTool,
@@ -2500,19 +2398,13 @@ function createTools() {
     browserNavigateTool,
     browserScreenshotTool,
     browserTypeTool,
-    addPlanItemTool,
     changeCwdTool,
     checkHarperStatusTool,
-    collectFeedbackTool,
     codeInterpreterTool,
     createApplyPatchTool(),
     createNewHarperApplicationTool,
     egrepTool,
     findTool,
-    getHarperConfigSchemaTool,
-    getHarperResourceInterfaceTool,
-    getHarperSchemaGraphQLTool,
-    getHarperSkillTool,
     gitAddTool,
     gitBranchTool,
     gitCommitTool,
@@ -2526,13 +2418,10 @@ function createTools() {
     readHarperLogsTool,
     setInterpreterAutoApproveTool,
     setPatchAutoApproveTool,
-    setPlanDescriptionTool,
-    setPlanItemsTool,
     setShellAutoApproveTool,
     shellTool,
     startHarperTool,
-    stopHarperTool,
-    updatePlanItemTool
+    stopHarperTool
   ];
 }
 
@@ -2829,7 +2718,11 @@ var DiskSession = class extends MemorySession {
     await this.ready;
     const sessionId = await this.getSessionId();
     const storage = await this.loadStorage();
-    return storage.plan?.[sessionId] ?? null;
+    return storage.plan?.[sessionId] ?? {
+      planDescription: "",
+      planItems: [],
+      progress: 0
+    };
   }
   async setPlanState(state) {
     await this.ready;
@@ -3123,14 +3016,17 @@ var MemoryCompactionSession = class {
     }
     if (this.planStateLocal) {
       const existing = base ?? { planDescription: "", planItems: [], progress: 0 };
-      const merged = {
+      return {
         ...existing,
         ...this.planStateLocal,
         planItems: Array.isArray(this.planStateLocal.planItems) ? this.planStateLocal.planItems : existing.planItems
       };
-      return merged;
     }
-    return base;
+    return base || {
+      planDescription: "",
+      planItems: [],
+      progress: 0
+    };
   }
   async setPlanState(state) {
     const u = this.underlyingSession;
@@ -3454,51 +3350,129 @@ var CostTracker = class {
 };
 var costTracker = new CostTracker();
 
-// utils/strings/isTrue.ts
-function isTrue(v) {
-  if (v === void 0) {
-    return false;
-  }
-  const val = v.trim().toLowerCase();
-  return val === "true" || val === "y" || val === "1" || val === "yes" || val === "on" || val === "approved" || val === "approve";
-}
-
-// agent/showErrorToUser.ts
-function showErrorToUser(error, lastToolCallInfo) {
-  logError(error);
-  const err = error ?? {};
-  const name = err.name || "Error";
-  const message = err.message || String(err);
-  const code = err.code ? ` code=${err.code}` : "";
-  const status = err.status || err.statusCode || err.response?.status;
-  const statusStr = status ? ` status=${status}` : "";
-  const callIdMatch = message.match(/function call\s+(call_[A-Za-z0-9_-]+)/i);
-  const callId = callIdMatch?.[1];
-  const isNoToolOutput = /No tool output found for function call/i.test(message || "");
-  const hint = isNoToolOutput ? `
-Hint: A tool likely threw or returned no result. Ensure tools always return a structured object (e.g., { status, output }) and never throw. If this followed a tool call${callId ? ` (${callId})` : ""}${lastToolCallInfo ? `: ${lastToolCallInfo}` : ""}, review that tool's implementation and logs.` : "";
-  let responseDataSnippet = "";
-  const data = err.response?.data ?? err.data;
-  if (data) {
-    try {
-      const s = typeof data === "string" ? data : JSON.stringify(data);
-      responseDataSnippet = `
-Response data: ${s.slice(0, 500)}${s.length > 500 ? "\u201A\xC4\xB6" : ""}`;
-    } catch {
-    }
-  }
-  const stack = err.stack ? `
-Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
-  const lastTool = lastToolCallInfo ? `
-Last tool call: ${lastToolCallInfo}` : "";
-  const composed = `${name}:${code}${statusStr} ${message}${hint}${lastTool}${responseDataSnippet}${stack}`;
-  emitToListeners("SetInputMode", "denied");
-  setTimeout(curryEmitToListeners("SetInputMode", "waiting"), 1e3);
-  emitToListeners("PushNewMessages", [{
-    type: "agent",
-    text: composed,
-    version: 1
-  }]);
+// utils/sessions/rateLimits.ts
+var RateLimitTracker = class {
+  status = {
+    limitRequests: null,
+    limitTokens: null,
+    remainingRequests: null,
+    remainingTokens: null,
+    resetRequests: null,
+    resetTokens: null,
+    retryAfter: null
+  };
+  updateFromHeaders(headers) {
+    const normalizedHeaders = {};
+    for (const key of Object.keys(headers)) {
+      normalizedHeaders[key.toLowerCase()] = headers[key];
+    }
+    const getHeader = (name) => {
+      const value = normalizedHeaders[name.toLowerCase()];
+      return Array.isArray(value) ? value[0] : value;
+    };
+    const limitRequests = getHeader("x-ratelimit-limit-requests") || getHeader("anthropic-ratelimit-requests-limit") || getHeader("x-ratelimit-limit") || getHeader("ratelimit-limit") || getHeader("x-request-limit");
+    const limitTokens = getHeader("x-ratelimit-limit-tokens") || getHeader("anthropic-ratelimit-tokens-limit") || getHeader("x-token-limit");
+    const remainingRequests = getHeader("x-ratelimit-remaining-requests") || getHeader("anthropic-ratelimit-requests-remaining") || getHeader("x-ratelimit-remaining") || getHeader("ratelimit-remaining") || getHeader("x-request-remaining");
+    const remainingTokens = getHeader("x-ratelimit-remaining-tokens") || getHeader("anthropic-ratelimit-tokens-remaining") || getHeader("x-token-remaining");
+    const resetRequests = getHeader("x-ratelimit-reset-requests") || getHeader("anthropic-ratelimit-requests-reset") || getHeader("x-ratelimit-reset") || getHeader("ratelimit-reset") || getHeader("x-request-reset");
+    const resetTokens = getHeader("x-ratelimit-reset-tokens") || getHeader("anthropic-ratelimit-tokens-reset") || getHeader("x-token-reset");
+    const retryAfter = getHeader("retry-after");
+    if (limitRequests) {
+      this.status.limitRequests = parseInt(limitRequests, 10);
+    }
+    if (limitTokens) {
+      this.status.limitTokens = parseInt(limitTokens, 10);
+    }
+    if (remainingRequests) {
+      this.status.remainingRequests = parseInt(remainingRequests, 10);
+    }
+    if (remainingTokens) {
+      this.status.remainingTokens = parseInt(remainingTokens, 10);
+    }
+    if (resetRequests) {
+      this.status.resetRequests = resetRequests;
+    }
+    if (resetTokens) {
+      this.status.resetTokens = resetTokens;
+    }
+    if (retryAfter) {
+      this.status.retryAfter = parseInt(retryAfter, 10);
+    }
+  }
+  isApproachingLimit(threshold) {
+    const usage = this.getUsagePercentage();
+    return {
+      requests: usage.requests >= threshold,
+      tokens: usage.tokens >= threshold
+    };
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  getUsagePercentage() {
+    const requests = this.status.limitRequests && this.status.remainingRequests !== null ? 100 * (1 - this.status.remainingRequests / this.status.limitRequests) : 0;
+    const tokens = this.status.limitTokens && this.status.remainingTokens !== null ? 100 * (1 - this.status.remainingTokens / this.status.limitTokens) : 0;
+    return { requests, tokens };
+  }
+  reset() {
+    this.status = {
+      limitRequests: null,
+      limitTokens: null,
+      remainingRequests: null,
+      remainingTokens: null,
+      resetRequests: null,
+      resetTokens: null,
+      retryAfter: null
+    };
+  }
+};
+var rateLimitTracker = new RateLimitTracker();
+
+// utils/strings/isTrue.ts
+function isTrue(v) {
+  if (v === void 0) {
+    return false;
+  }
+  const val = v.trim().toLowerCase();
+  return val === "true" || val === "y" || val === "1" || val === "yes" || val === "on" || val === "approved" || val === "approve";
+}
+
+// agent/showErrorToUser.ts
+function showErrorToUser(error, lastToolCallInfo) {
+  logError(error);
+  const err = error ?? {};
+  const name = err.name || "Error";
+  const message = err.message || String(err);
+  const code = err.code ? ` code=${err.code}` : "";
+  const status = err.status || err.statusCode || err.response?.status;
+  const statusStr = status ? ` status=${status}` : "";
+  const callIdMatch = message.match(/function call\s+(call_[A-Za-z0-9_-]+)/i);
+  const callId = callIdMatch?.[1];
+  const isNoToolOutput = /No tool output found for function call/i.test(message || "");
+  const hint = isNoToolOutput ? `
+Hint: A tool likely threw or returned no result. Ensure tools always return a structured object (e.g., { status, output }) and never throw. If this followed a tool call${callId ? ` (${callId})` : ""}${lastToolCallInfo ? `: ${lastToolCallInfo}` : ""}, review that tool's implementation and logs.` : "";
+  let responseDataSnippet = "";
+  const data = err.response?.data ?? err.data;
+  if (data) {
+    try {
+      const s = typeof data === "string" ? data : JSON.stringify(data);
+      responseDataSnippet = `
+Response data: ${s.slice(0, 500)}${s.length > 500 ? "\u201A\xC4\xB6" : ""}`;
+    } catch {
+    }
+  }
+  const stack = err.stack ? `
+Stack: ${String(err.stack).split("\n").slice(0, 8).join("\n")}` : "";
+  const lastTool = lastToolCallInfo ? `
+Last tool call: ${lastToolCallInfo}` : "";
+  const composed = `${name}:${code}${statusStr} ${message}${hint}${lastTool}${responseDataSnippet}${stack}`;
+  emitToListeners("SetInputMode", "denied");
+  setTimeout(curryEmitToListeners("SetInputMode", "waiting"), 1e3);
+  emitToListeners("PushNewMessages", [{
+    type: "agent",
+    text: composed,
+    version: 1
+  }]);
 }
 
 // agent/runAgentForOnePass.ts
@@ -3506,8 +3480,9 @@ async function runAgentForOnePass(agent, session, input, controller, isPrompt) {
   let lastToolCallInfo = null;
   try {
     let hasStartedResponse = false;
+    const planContext = await session.getPlanState();
     let adjustedInput = input;
-    const noPlanYet = globalPlanContext.planItems.length === 0 && (!globalPlanContext.planDescription || globalPlanContext.planDescription.trim().length === 0);
+    const noPlanYet = planContext.planItems.length === 0 && (!planContext?.planDescription || planContext?.planDescription.trim().length === 0);
     if (noPlanYet && typeof input === "string") {
       const planningInstruction = [
         isPrompt ? "The following request is from a non-interactive prompt. You MUST establish a comprehensive plan first, then execute it autonomously until completion." : "If there is no current plan, first establish one and keep it updated:",
@@ -3861,6 +3836,65 @@ async function runAgentForOnePass(agent, session, input, controller, isPrompt) {
   }
 }
 
+// agent/translateSessionItemsToMessages.ts
+function translateSessionItemsToMessages(items) {
+  const messages = [];
+  if (items.length > 0) {
+    let id = 0;
+    for (const item of items) {
+      if (item.type === "message" && item.role === "user") {
+        messages.push({
+          id: id++,
+          type: "user",
+          text: item.content,
+          version: 1
+        });
+      } else if (item.type === "message" && item.role === "assistant") {
+        if (typeof item.content === "string") {
+          messages.push({
+            id: id++,
+            type: "agent",
+            text: item.content,
+            version: 1
+          });
+        } else if (Array.isArray(item.content)) {
+          for (const part of item.content) {
+            if (part.type === "text" || part.type === "output_text") {
+              messages.push({
+                id: id++,
+                type: "agent",
+                text: part.text,
+                version: 1
+              });
+            } else if (part.type === "tool_call" || part.type === "function_call") {
+              const args = typeof part.arguments === "string" ? part.arguments : part.arguments ? JSON.stringify(part.arguments) : "";
+              const displayedArgs = args ? `(${args})` : "()";
+              messages.push({
+                id: id++,
+                type: "tool",
+                text: part.name,
+                args: displayedArgs,
+                version: 1
+              });
+            }
+          }
+        }
+      } else if (item.type === "function_call") {
+        const args = typeof item.arguments === "string" ? item.arguments : item.arguments ? JSON.stringify(item.arguments) : "";
+        const displayedArgs = args ? `(${args})` : "()";
+        messages.push({
+          id: id++,
+          type: "tool",
+          text: item.name,
+          args: displayedArgs,
+          version: 1
+        });
+      }
+    }
+  }
+  return messages;
+}
+
 // agent/AgentManager.ts
 var AgentManager = class _AgentManager {
   isInitialized = false;
@@ -3870,121 +3904,39 @@ var AgentManager = class _AgentManager {
   agent = null;
   session = null;
   initialMessages = [];
-  static instantiateAgent(tools) {
+  static instantiateAgent(tools, instructions) {
     return new Agent3({
       name: "Harper Agent",
       model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
       modelSettings: getModelSettings(trackedState.model),
-      instructions: readAgentSkillsRoot() || defaultInstructions(),
+      instructions: instructions || readAgentSkillsRoot() || defaultInstructions(),
       tools
     });
   }
-  async initialize() {
+  async initialize(agent, session) {
     if (this.isInitialized) {
       return;
     }
-    this.agent = _AgentManager.instantiateAgent(createTools());
-    this.session = createSession(trackedState.sessionPath);
+    this.session = session || createSession(trackedState.sessionPath);
+    this.agent = agent || _AgentManager.instantiateAgent([
+      ...createSharedTools(this.session),
+      ...createCLITools(this.session)
+    ]);
     try {
       const plan = await this.session?.getPlanState?.();
       if (plan && typeof plan === "object") {
         if (typeof plan.planDescription === "string") {
-          globalPlanContext.planDescription = plan.planDescription;
           emitToListeners("SetPlanDescription", plan.planDescription);
         }
         if (Array.isArray(plan.planItems)) {
-          globalPlanContext.planItems = plan.planItems;
-          const completedCount = plan.planItems.filter(
-            (it) => it?.status === "done" || it?.status === "not-needed"
-          ).length;
-          const progress = plan.planItems.length === 0 ? 0 : Math.round(completedCount / plan.planItems.length * 100);
-          globalPlanContext.progress = progress;
           emitToListeners("SetPlanItems", plan.planItems);
         }
       }
     } catch {
     }
-    try {
-      addListener("SetPlanDescription", async (desc) => {
-        try {
-          await this.session?.setPlanState?.({ planDescription: desc });
-        } catch {
-        }
-      });
-      addListener("SetPlanItems", async (items) => {
-        if (Array.isArray(items)) {
-          globalPlanContext.planItems = items;
-          const completedCount = items.filter((it) => it?.status === "done" || it?.status === "not-needed").length;
-          globalPlanContext.progress = items.length > 0 ? Math.round(completedCount / items.length * 100) : 0;
-        }
-        try {
-          const completedCount = Array.isArray(items) ? items.filter((it) => it?.status === "done" || it?.status === "not-needed").length : 0;
-          const progress = Array.isArray(items) && items.length > 0 ? Math.round(completedCount / items.length * 100) : 0;
-          await this.session?.setPlanState?.({ planItems: items, progress });
-        } catch {
-        }
-      });
-    } catch {
-    }
     if (trackedState.sessionPath) {
       const items = await this.session.getItems();
-      if (items.length > 0) {
-        const messages = [];
-        let id = 0;
-        for (const item of items) {
-          if (item.type === "message" && item.role === "user") {
-            messages.push({
-              id: id++,
-              type: "user",
-              text: item.content,
-              version: 1
-            });
-          } else if (item.type === "message" && item.role === "assistant") {
-            if (typeof item.content === "string") {
-              messages.push({
-                id: id++,
-                type: "agent",
-                text: item.content,
-                version: 1
-              });
-            } else if (Array.isArray(item.content)) {
-              for (const part of item.content) {
-                if (part.type === "text" || part.type === "output_text") {
-                  messages.push({
-                    id: id++,
-                    type: "agent",
-                    text: part.text,
-                    version: 1
-                  });
-                } else if (part.type === "tool_call" || part.type === "function_call") {
-                  const args = typeof part.arguments === "string" ? part.arguments : part.arguments ? JSON.stringify(part.arguments) : "";
-                  const displayedArgs = args ? `(${args})` : "()";
-                  messages.push({
-                    id: id++,
-                    type: "tool",
-                    text: part.name,
-                    args: displayedArgs,
-                    version: 1
-                  });
-                }
-              }
-            }
-          } else if (item.type === "function_call") {
-            const args = typeof item.arguments === "string" ? item.arguments : item.arguments ? JSON.stringify(item.arguments) : "";
-            const displayedArgs = args ? `(${args})` : "()";
-            messages.push({
-              id: id++,
-              type: "tool",
-              text: item.name,
-              args: displayedArgs,
-              version: 1
-            });
-          }
-        }
-        if (messages.length > 0) {
-          this.initialMessages = messages;
-        }
-      }
+      this.initialMessages = translateSessionItemsToMessages(items);
     }
     this.isInitialized = true;
     if (trackedState.prompt?.trim?.()?.length) {
@@ -4053,7 +4005,8 @@ var AgentManager = class _AgentManager {
         }
       }
       if (trackedState.autonomous && !this.resumeState) {
-        const planItems = globalPlanContext.planItems;
+        const planState = await this.session.getPlanState();
+        const planItems = planState.planItems;
         const hasPlan = planItems.length > 0;
         const allDone = hasPlan && planItems.every((item) => item.status === "done" || item.status === "not-needed");
         if (allDone) {
@@ -4105,2833 +4058,32 @@ var AgentManager = class _AgentManager {
 };
 var agentManager = new AgentManager();
 
-// ink/main.tsx
-import { render, useApp } from "ink";
-import "react";
-
-// ink/components/ChatContent.tsx
-import { Spinner as Spinner2 } from "@inkjs/ui";
-import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
-import React11, { useCallback as useCallback5, useEffect as useEffect8, useMemo as useMemo10, useRef as useRef2, useState as useState13 } from "react";
-
-// ink/contexts/ChatContext.tsx
-import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2, useState as useState2 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var ChatContext = createContext2(void 0);
-var useChat = () => {
-  const context = useContext2(ChatContext);
-  if (!context) {
-    throw new Error("useChat must be used within a ChatProvider");
-  }
-  return context;
-};
-var initialMessages = [];
-function getInitialMessages() {
-  if (initialMessages.length === 0) {
-    initialMessages = agentManager.initialMessages ? agentManager.initialMessages.map((m, index) => ({
-      ...m,
-      id: index,
-      version: m.version ?? 1
-    })) : [{
-      id: 0,
-      type: "agent",
-      text: 'What shall we build today? (Type "/clear" to reset, "/skills" to add skills, or "/exit" to quit)',
-      version: 1
-    }];
-  }
-  return initialMessages;
-}
-var ChatProvider = ({
-  children
-}) => {
-  const [messages, setMessages] = useState2(getInitialMessages());
-  const [userInputMode, setUserInputMode] = useState2("waiting");
-  const [isThinking, setIsThinking] = useState2(false);
-  const [isCompacting, setIsCompacting] = useState2(false);
-  const [pullingState, setPullingState] = useState2(null);
-  const [focusedArea, setFocusedArea] = useState2("input");
-  useListener("PushNewMessages", (messages2) => {
-    setMessages((prev) => {
-      return prev.concat(
-        messages2.map((message, index) => ({ ...message, id: prev.length + index, version: 1 }))
-      );
-    });
-  }, []);
-  useListener("SetInputMode", (newInputMode) => {
-    setUserInputMode(newInputMode);
-  }, []);
-  useListener("SetThinking", (value2) => {
-    setIsThinking(Boolean(value2));
-  }, []);
-  useListener("SetCompacting", (value2) => {
-    setIsCompacting(Boolean(value2));
-  }, []);
-  useListener("SetPulling", (value2) => {
-    setPullingState(value2);
-  }, []);
-  useListener("InterruptThought", () => {
-    setIsThinking(false);
-  }, []);
-  useListener("UpdateLastMessageText", (text) => {
-    setMessages((prev) => {
-      if (prev.length === 0) {
-        return prev;
-      }
-      const lastIndex = [...prev].reverse().findIndex((m) => m.type === "agent");
-      if (lastIndex === -1) {
-        return prev;
-      }
-      const actualIndex = prev.length - 1 - lastIndex;
-      const last = prev[actualIndex];
-      const updated = [...prev];
-      updated[actualIndex] = {
-        ...last,
-        text: last.text + text,
-        version: last.version + 1
-      };
-      return updated;
-    });
-  }, []);
-  useListener("ClearChatHistory", () => {
-    agentManager.session?.clearSession();
-    setMessages([{
-      id: 0,
-      type: "agent",
-      text: "Chat cleared. What shall we build today?",
-      version: 1
-    }]);
-  }, []);
-  const value = useMemo2(() => ({
-    messages,
-    userInputMode,
-    isThinking,
-    isCompacting,
-    pullingState,
-    focusedArea,
-    setFocusedArea
-  }), [messages, userInputMode, isThinking, isCompacting, pullingState, focusedArea]);
-  return /* @__PURE__ */ jsx2(ChatContext.Provider, { value, children });
-};
-
-// ink/bindings/useMessageListener.ts
-var hasShownInterruptHint = false;
-function useMessageListener() {
-  const { userInputMode, isThinking } = useChat();
-  useListener("InterruptThought", () => {
-    agentManager.interrupt();
-    emitToListeners("PushNewMessages", [
-      {
-        type: "interrupted",
-        text: "- thought interrupted -",
-        version: 1
-      }
-    ]);
-  }, []);
-  useListener("PushNewMessages", async (messages) => {
-    for (const message of messages) {
-      if ((message.type === "user" || message.type === "prompt") && message.text) {
-        const lowerText = message.text.toLowerCase();
-        if (lowerText === "exit" || lowerText === "bye") {
-          await handleExit();
-        }
-        if (isThinking) {
-          if (!hasShownInterruptHint) {
-            hasShownInterruptHint = true;
-            emitToListeners("PushNewMessages", [{
-              type: "interrupted",
-              text: "- to interrupt the current thinking, press escape -",
-              version: 1
-            }]);
-          }
-          agentManager.enqueueUserInput(message.text);
-          message.handled = true;
-        } else if (!message.handled) {
-          void agentManager.runTask(message.text, message.type === "prompt");
-        }
-      }
-    }
-  }, [userInputMode, isThinking]);
-}
-
-// ink/constants/footerHeight.ts
-var footerHeight = 2;
-
-// ink/contexts/ApprovalContext.tsx
-import { createContext as createContext3, useCallback as useCallback2, useContext as useContext3, useMemo as useMemo3, useState as useState3 } from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
-var ApprovalContext = createContext3(void 0);
-var useApproval = () => {
-  const context = useContext3(ApprovalContext);
-  if (!context) {
-    throw new Error("useApproval must be used within an ApprovalProvider");
-  }
-  return context;
-};
-var ApprovalProvider = ({ children }) => {
-  const [payload, setPayload] = useState3(null);
-  const [toolInfos] = useState3(/* @__PURE__ */ new Map());
-  const registerToolInfo = useCallback2(
-    (info) => {
-      toolInfos.set(info.callId, info);
-    },
-    [toolInfos]
-  );
-  useListener("OpenApprovalViewer", (p) => {
-    let finalPayload = { ...p, openedAt: Date.now() };
-    if (p.mode === "info" && p.callId) {
-      const info = toolInfos.get(p.callId);
-      if (info) {
-        finalPayload = { ...finalPayload, ...info };
-      }
-    } else if (p.callId) {
-      registerToolInfo({
-        callId: p.callId,
-        type: p.type,
-        path: p.path,
-        diff: p.diff,
-        code: p.code,
-        commands: p.commands
-      });
-    }
-    setPayload(finalPayload);
-  }, [registerToolInfo, toolInfos]);
-  useListener("CloseApprovalViewer", () => {
-    setPayload(null);
-  }, []);
-  const value = useMemo3(() => ({
-    payload,
-    setPayload,
-    registerToolInfo
-  }), [payload, registerToolInfo]);
-  return /* @__PURE__ */ jsx3(ApprovalContext.Provider, { value, children });
-};
-
-// ink/contexts/PlanContext.tsx
-import { createContext as createContext4, useContext as useContext4, useMemo as useMemo4, useState as useState4 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var PlanContext = createContext4(globalPlanContext);
-var usePlan = () => {
-  const context = useContext4(PlanContext);
-  if (!context) {
-    throw new Error("usePlan must be used within a PlanProvider");
-  }
-  return context;
-};
-var PlanProvider = ({
-  children
-}) => {
-  const [planDescription, setPlanDescription] = useState4(globalPlanContext.planDescription);
-  const [planItems, setPlanItems] = useState4(globalPlanContext.planItems);
-  const [progress, setProgress] = useState4(globalPlanContext.progress);
-  useListener("SetPlanDescription", (newGoal) => {
-    globalPlanContext.planDescription = newGoal;
-    setPlanDescription(newGoal);
-  }, []);
-  useListener("SetPlanItems", (planItems2) => {
-    globalPlanContext.planItems = planItems2;
-    const completedCount = planItems2.filter((item) => item.status === "done" || item.status === "not-needed").length;
-    const progress2 = planItems2.length === 0 ? 0 : Math.round(completedCount / planItems2.length * 100);
-    globalPlanContext.progress = progress2;
-    setPlanItems(planItems2);
-    setProgress(progress2);
-  }, []);
-  const value = useMemo4(() => ({
-    progress,
-    planDescription,
-    planItems
-  }), [progress, planDescription, planItems]);
-  return /* @__PURE__ */ jsx4(PlanContext.Provider, { value, children });
+export {
+  useListener,
+  emitToListeners,
+  lastEmittedValue,
+  curryEmitToListeners,
+  rateLimitTracker,
+  trackedState,
+  resetTrackedState,
+  defaultModelToken,
+  defaultOpenAIModel,
+  defaultOpenAICompactionModel,
+  defaultAnthropicModel,
+  defaultAnthropicCompactionModel,
+  defaultGoogleModel,
+  defaultGoogleCompactionModel,
+  defaultOllamaModel,
+  defaultOllamaCompactionModel,
+  isOpenAIModel,
+  handleExit,
+  setupGlobalErrorHandlers,
+  updateEnv,
+  fetchOllamaModels,
+  excludeFalsy,
+  useActions,
+  ActionsProvider,
+  isTrue,
+  AgentManager,
+  agentManager
 };
-
-// ink/library/useTerminalSize.ts
-import { useStdout } from "ink";
-import { useEffect as useEffect3, useState as useState5 } from "react";
-function useTerminalSize() {
-  const { stdout } = useStdout();
-  const [size, setSize] = useState5({
-    rows: stdout?.rows ?? 24,
-    columns: stdout?.columns ?? 80
-  });
-  useEffect3(() => {
-    if (!stdout || !stdout.isTTY) {
-      return;
-    }
-    const handleResize = () => {
-      setSize({
-        rows: stdout.rows ?? 24,
-        columns: stdout.columns ?? 80
-      });
-    };
-    stdout.on("resize", handleResize);
-    return () => {
-      stdout.off("resize", handleResize);
-    };
-  }, [stdout]);
-  return size;
-}
-
-// ink/library/wrapText.ts
-function wrapText(text, width) {
-  if (width <= 1) {
-    return text ? [text] : [""];
-  }
-  const hardLines = text.split("\n");
-  const allWrappedLines = [];
-  for (const hardLine of hardLines) {
-    if (hardLine.length === 0) {
-      allWrappedLines.push("");
-      continue;
-    }
-    const words = hardLine.split(/(\s+)/);
-    let currentLine = "";
-    for (const token of words) {
-      if (token.length === 0) {
-        continue;
-      }
-      if (currentLine.length + token.length <= width) {
-        currentLine += token;
-      } else {
-        if (currentLine) {
-          allWrappedLines.push(currentLine.trimEnd());
-        }
-        if (token.trim().length === 0) {
-          currentLine = "";
-        } else if (token.length > width) {
-          for (let i = 0; i < token.length; i += width) {
-            const chunk = token.slice(i, i + width);
-            if (chunk.length === width) {
-              allWrappedLines.push(chunk);
-            } else {
-              currentLine = chunk;
-            }
-          }
-        } else {
-          currentLine = token;
-        }
-      }
-    }
-    if (currentLine) {
-      allWrappedLines.push(currentLine.trimEnd());
-    }
-  }
-  return allWrappedLines.length ? allWrappedLines : [""];
-}
-
-// ink/components/ActionsView.tsx
-import { Box as Box3, Text as Text3, useInput } from "ink";
-import { useCallback as useCallback3, useEffect as useEffect5, useState as useState7 } from "react";
-
-// ink/components/ActionItemRow.tsx
-import { Spinner } from "@inkjs/ui";
-import { Box, Text } from "ink";
-import { memo } from "react";
-import { jsx as jsx5, jsxs } from "react/jsx-runtime";
-var ActionItemRow = memo(
-  ({ item, isSelected, isFocused, width }) => {
-    const statusColor = item.running ? "yellow" : item.status === "approved" || item.status === "succeeded" || typeof item.exitCode === "number" && item.exitCode === 0 ? "green" : item.status === "denied" || item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 ? "red" : "cyan";
-    const selectionColor = isFocused ? "cyan" : "gray";
-    const pipe = /* @__PURE__ */ jsx5(Text, { color: isSelected ? selectionColor : "gray", bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " });
-    const statusLabel = item.running ? " " : item.kind === "approval" ? item.status === "approved" ? " approved" : item.status === "denied" ? " denied" : "" : typeof item.exitCode === "number" ? ` ${item.exitCode}` : "";
-    const statusLabelWidth = item.running ? 2 : statusLabel.length;
-    const pipeWidth = 3;
-    const nameWithSpace = `${item.title} `;
-    const availableForDetail = width - pipeWidth - nameWithSpace.length - statusLabelWidth;
-    const fullDetail = item.detail || "";
-    let displayedDetail = fullDetail;
-    if (availableForDetail < fullDetail.length) {
-      if (availableForDetail > 3) {
-        displayedDetail = fullDetail.slice(0, availableForDetail - 3) + "...";
-      } else {
-        displayedDetail = fullDetail.slice(0, Math.max(0, availableForDetail));
-      }
-    }
-    return /* @__PURE__ */ jsxs(Box, { children: [
-      pipe,
-      /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
-        /* @__PURE__ */ jsx5(Text, { color: statusColor, bold: true, children: item.title }),
-        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-          " ",
-          displayedDetail
-        ] })
-      ] }),
-      /* @__PURE__ */ jsx5(Box, { children: item.running ? /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx5(Text, { color: "yellow" }),
-        /* @__PURE__ */ jsx5(Spinner, { type: "dots" })
-      ] }) : /* @__PURE__ */ jsx5(Text, { color: statusColor, bold: true, children: statusLabel }) })
-    ] });
-  }
-);
-
-// ink/components/VirtualList.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import { forwardRef, useEffect as useEffect4, useImperativeHandle, useMemo as useMemo5, useRef, useState as useState6 } from "react";
-import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
-function getDefaultKey(item, index) {
-  if (item && typeof item === "object") {
-    if ("id" in item && (typeof item.id === "string" || typeof item.id === "number")) {
-      return String(item.id);
-    }
-    if ("key" in item && (typeof item.key === "string" || typeof item.key === "number")) {
-      return String(item.key);
-    }
-  }
-  return String(index);
-}
-var VirtualListInner = (props, ref) => {
-  const {
-    items,
-    renderItem,
-    getItemHeight: getItemHeightProp,
-    itemHeight: fixedItemHeight,
-    selectedIndex = 0,
-    keyExtractor,
-    height: propHeight,
-    reservedLines = 0,
-    showOverflowIndicators = true,
-    overflowIndicatorThreshold = 1,
-    renderOverflowTop,
-    renderOverflowBottom,
-    renderFiller,
-    onViewportChange
-  } = props;
-  const { rows: terminalRows } = useTerminalSize();
-  const resolvedHeight = useMemo5(() => {
-    if (typeof propHeight === "number") {
-      return propHeight;
-    }
-    if (typeof propHeight === "string" && propHeight.endsWith("%")) {
-      const percent = parseFloat(propHeight) / 100;
-      return Math.floor(terminalRows * percent);
-    }
-    return Math.max(1, terminalRows - reservedLines);
-  }, [propHeight, terminalRows, reservedLines]);
-  const getItemHeight = useMemo5(() => {
-    if (getItemHeightProp) {
-      return getItemHeightProp;
-    }
-    if (fixedItemHeight) {
-      return () => fixedItemHeight;
-    }
-    return () => 1;
-  }, [getItemHeightProp, fixedItemHeight]);
-  const indicatorLines = showOverflowIndicators ? 2 : 0;
-  const availableHeight = Math.max(0, resolvedHeight - indicatorLines);
-  const [viewportOffset, setViewportOffset] = useState6(0);
-  const lastItemsLength = useRef(items.length);
-  const viewportOffsetRef = useRef(viewportOffset);
-  useEffect4(() => {
-    viewportOffsetRef.current = viewportOffset;
-  }, [viewportOffset]);
-  const clampedSelectedIndex = Math.max(0, Math.min(selectedIndex, items.length - 1));
-  const { visibleCount, visibleItems } = useMemo5(() => {
-    if (availableHeight <= 0) {
-      return { visibleCount: 0, visibleItems: [] };
-    }
-    let currentHeight = 0;
-    let count = 0;
-    const visibleItems2 = [];
-    for (let i = viewportOffset; i < items.length; i++) {
-      const h = getItemHeight(items[i], i);
-      if (currentHeight + h > availableHeight && count > 0) {
-        break;
-      }
-      currentHeight += h;
-      count++;
-      visibleItems2.push(items[i]);
-    }
-    return { visibleCount: count, visibleItems: visibleItems2 };
-  }, [items, viewportOffset, availableHeight, getItemHeight]);
-  useEffect4(() => {
-    if (items.length === 0 || availableHeight <= 0) {
-      lastItemsLength.current = items.length;
-      return;
-    }
-    const currentViewportOffset = viewportOffsetRef.current;
-    const isSelectingLast = clampedSelectedIndex === items.length - 1;
-    const wasAtBottom = lastItemsLength.current > 0 && currentViewportOffset + visibleCount >= lastItemsLength.current - 1;
-    lastItemsLength.current = items.length;
-    if (clampedSelectedIndex < currentViewportOffset) {
-      setViewportOffset(clampedSelectedIndex);
-      return;
-    }
-    let heightToSelected = 0;
-    let isVisible = false;
-    for (let i = currentViewportOffset; i <= clampedSelectedIndex; i++) {
-      const h = getItemHeight(items[i], i);
-      if (heightToSelected + h > availableHeight) {
-        isVisible = false;
-        break;
-      }
-      heightToSelected += h;
-      if (i === clampedSelectedIndex) {
-        isVisible = true;
-      }
-    }
-    if (!isVisible || isSelectingLast || wasAtBottom) {
-      let tempOffset = clampedSelectedIndex;
-      let hSum2 = 0;
-      while (tempOffset >= 0) {
-        const h = getItemHeight(items[tempOffset], tempOffset);
-        if (hSum2 + h > availableHeight) {
-          tempOffset++;
-          break;
-        }
-        hSum2 += h;
-        if (tempOffset === 0) {
-          break;
-        }
-        tempOffset--;
-      }
-      const finalOffset = Math.max(0, tempOffset);
-      if (finalOffset !== currentViewportOffset) {
-        setViewportOffset(finalOffset);
-      }
-    }
-  }, [clampedSelectedIndex, items, availableHeight, getItemHeight, visibleCount]);
-  const viewport = useMemo5(
-    () => ({
-      offset: viewportOffset,
-      visibleCount,
-      totalCount: items.length
-    }),
-    [viewportOffset, visibleCount, items.length]
-  );
-  const isInitialMount = useRef(true);
-  useEffect4(() => {
-    if (isInitialMount.current) {
-      if (items.length > 0 && availableHeight > 0) {
-        isInitialMount.current = false;
-        let tempOffset = items.length - 1;
-        let hSum2 = 0;
-        while (tempOffset >= 0) {
-          const h = getItemHeight(items[tempOffset], tempOffset);
-          if (hSum2 + h > availableHeight) {
-            tempOffset++;
-            break;
-          }
-          hSum2 += h;
-          if (tempOffset === 0) {
-            break;
-          }
-          tempOffset--;
-        }
-        setViewportOffset(Math.max(0, tempOffset));
-      }
-    }
-  }, [availableHeight, items.length, getItemHeight]);
-  useEffect4(() => {
-    onViewportChange?.(viewport);
-  }, [viewport, onViewportChange]);
-  useImperativeHandle(
-    ref,
-    () => ({
-      scrollToIndex: (index, alignment = "auto") => {
-        const clampedIndex = Math.max(0, Math.min(index, items.length - 1));
-        let newOffset = viewportOffset;
-        switch (alignment) {
-          case "top":
-            newOffset = clampedIndex;
-            break;
-          case "center": {
-            let hSum2 = 0;
-            let tempOffset = clampedIndex;
-            while (tempOffset >= 0 && hSum2 < availableHeight / 2) {
-              hSum2 += getItemHeight(items[tempOffset], tempOffset);
-              tempOffset--;
-            }
-            newOffset = tempOffset + 1;
-            break;
-          }
-          case "bottom": {
-            let hSum2 = 0;
-            let tempOffset = clampedIndex;
-            while (tempOffset >= 0 && hSum2 < availableHeight) {
-              const h = getItemHeight(items[tempOffset], tempOffset);
-              if (hSum2 + h > availableHeight) {
-                tempOffset++;
-                break;
-              }
-              hSum2 += h;
-              if (tempOffset === 0) {
-                break;
-              }
-              tempOffset--;
-            }
-            newOffset = tempOffset;
-            break;
-          }
-          case "auto":
-          default: {
-            if (clampedIndex < viewportOffset) {
-              newOffset = clampedIndex;
-            } else {
-              let heightToSelected = 0;
-              let isVisible = false;
-              for (let i = viewportOffset; i <= clampedIndex; i++) {
-                const h = getItemHeight(items[i], i);
-                if (heightToSelected + h > availableHeight) {
-                  isVisible = false;
-                  break;
-                }
-                heightToSelected += h;
-                if (i === clampedIndex) {
-                  isVisible = true;
-                }
-              }
-              if (!isVisible) {
-                let hSum2 = 0;
-                let tempOffset = clampedIndex;
-                while (tempOffset >= 0) {
-                  const h = getItemHeight(items[tempOffset], tempOffset);
-                  if (hSum2 + h > availableHeight) {
-                    tempOffset++;
-                    break;
-                  }
-                  hSum2 += h;
-                  if (tempOffset === 0) {
-                    break;
-                  }
-                  tempOffset--;
-                }
-                newOffset = tempOffset;
-              }
-            }
-          }
-        }
-        setViewportOffset(Math.max(0, newOffset));
-      },
-      getViewport: () => viewport
-    }),
-    [items, viewportOffset, availableHeight, getItemHeight, viewport]
-  );
-  const overflowTop = viewportOffset;
-  let itemsFittingBelow = 0;
-  let hSum = 0;
-  for (let i = viewportOffset; i < items.length; i++) {
-    const h = getItemHeight(items[i], i);
-    if (hSum + h > availableHeight) {
-      break;
-    }
-    hSum += h;
-    itemsFittingBelow++;
-  }
-  const overflowBottom = Math.max(0, items.length - viewportOffset - itemsFittingBelow);
-  const defaultOverflowTop = (count) => {
-    if (count < overflowIndicatorThreshold) {
-      return null;
-    }
-    return /* @__PURE__ */ jsx6(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-      "\u25B2 ",
-      count,
-      " more"
-    ] }) });
-  };
-  const defaultOverflowBottom = (count) => {
-    if (count < overflowIndicatorThreshold) {
-      return null;
-    }
-    return /* @__PURE__ */ jsx6(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-      "\u25BC ",
-      count,
-      " more"
-    ] }) });
-  };
-  const topIndicator = renderOverflowTop ?? defaultOverflowTop;
-  const bottomIndicator = renderOverflowBottom ?? defaultOverflowBottom;
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: resolvedHeight, children: [
-    showOverflowIndicators && /* @__PURE__ */ jsx6(Box2, { height: 1, children: topIndicator(overflowTop) }),
-    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
-      visibleItems.map((item, idx) => {
-        const actualIndex = viewportOffset + idx;
-        const key = keyExtractor ? keyExtractor(item, actualIndex) : getDefaultKey(item, actualIndex);
-        const itemProps = {
-          item,
-          index: actualIndex,
-          isSelected: actualIndex === clampedSelectedIndex
-        };
-        return /* @__PURE__ */ jsx6(Box2, { height: getItemHeight(item, actualIndex), overflow: "hidden", children: renderItem(itemProps) }, key);
-      }),
-      renderFiller && hSum < availableHeight && /* @__PURE__ */ jsx6(Box2, { flexDirection: "column", flexGrow: 1, children: renderFiller(availableHeight - hSum) })
-    ] }),
-    showOverflowIndicators && /* @__PURE__ */ jsx6(Box2, { height: 1, children: bottomIndicator(overflowBottom) })
-  ] });
-};
-var VirtualList = forwardRef(VirtualListInner);
-
-// ink/components/ActionsView.tsx
-import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
-function ActionsView({ height, isFocused }) {
-  const { actions } = useActions();
-  const [selectedIndex, setSelectedIndex] = useState7(0);
-  const size = useTerminalSize();
-  const timelineWidth = Math.floor(size.columns * 0.65);
-  const statusWidth = size.columns - timelineWidth;
-  useEffect5(() => {
-    if (actions.length > 0) {
-      setSelectedIndex(actions.length - 1);
-    }
-  }, [actions.length]);
-  useInput((_, key) => {
-    if (!isFocused) {
-      return;
-    }
-    if (key.upArrow) {
-      setSelectedIndex((prev) => Math.max(0, prev - 1));
-    }
-    if (key.downArrow) {
-      setSelectedIndex((prev) => Math.min(actions.length - 1, prev + 1));
-    }
-    if (key.return) {
-      const selected = actions[selectedIndex];
-      if (selected && (selected.kind === "apply_patch" || selected.kind === "approval" || selected.title === "shell" || selected.title === "code_interpreter")) {
-        if (selected.callId) {
-          emitToListeners("OpenApprovalViewer", {
-            type: selected.kind === "apply_patch" ? "update_file" : selected.title,
-            mode: "info",
-            callId: selected.callId,
-            actionId: selected.id
-          });
-        }
-      }
-    }
-  });
-  const renderOverflowTop = useCallback3((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsx7(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
-    count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-      " ",
-      "\u25B2 ",
-      count,
-      " more"
-    ] })
-  ] }), []);
-  const renderOverflowBottom = useCallback3((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsx7(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
-    count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-      " ",
-      "\u25BC ",
-      count,
-      " more"
-    ] })
-  ] }), []);
-  const renderFiller = useCallback3((h) => /* @__PURE__ */ jsx7(Box3, { flexDirection: "column", children: Array.from({ length: h }).map((_, i) => /* @__PURE__ */ jsx7(Box3, { children: /* @__PURE__ */ jsx7(Text3, { color: "gray", dimColor: true, children: "\u2502" }) }, i)) }), []);
-  const getItemHeight = useCallback3((_item) => 1, []);
-  if (actions.length === 0) {
-    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexGrow: 1, height, children: [
-      /* @__PURE__ */ jsx7(Box3, { children: /* @__PURE__ */ jsx7(Text3, { italic: true, color: "gray", children: "No actions yet." }) }),
-      Array.from({ length: height - 1 }).map((_, i) => /* @__PURE__ */ jsx7(Box3, { children: /* @__PURE__ */ jsx7(Text3, {}) }, i))
-    ] });
-  }
-  return /* @__PURE__ */ jsx7(Box3, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx7(
-    VirtualList,
-    {
-      items: actions,
-      getItemHeight,
-      height,
-      selectedIndex,
-      renderOverflowTop,
-      renderOverflowBottom,
-      renderFiller,
-      renderItem: ({ item, isSelected }) => /* @__PURE__ */ jsx7(ActionItemRow, { item, isSelected, isFocused, width: statusWidth - 2 })
-    }
-  ) });
-}
-
-// ink/components/CostView.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import "react";
-
-// ink/contexts/CostContext.tsx
-import { createContext as createContext5, useContext as useContext5, useMemo as useMemo6, useState as useState8 } from "react";
-import { jsx as jsx8 } from "react/jsx-runtime";
-var CostContext = createContext5(void 0);
-var useCost = () => {
-  const context = useContext5(CostContext);
-  if (!context) {
-    throw new Error("useCost must be used within a CostProvider");
-  }
-  return context;
-};
-var CostProvider = ({
-  children
-}) => {
-  const [cost, setCost] = useState8({
-    totalCost: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    cachedInputTokens: 0,
-    hasUnknownPrices: false
-  });
-  useListener("UpdateCost", (newCost) => {
-    setCost(newCost);
-  }, []);
-  const value = useMemo6(() => ({
-    cost
-  }), [cost]);
-  return /* @__PURE__ */ jsx8(CostContext.Provider, { value, children });
-};
-
-// ink/components/CostView.tsx
-import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
-function CostView({ isDense = false }) {
-  const { cost } = useCost();
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, paddingTop: isDense ? 0 : 1, children: [
-    /* @__PURE__ */ jsx9(Box4, { marginBottom: isDense ? 0 : 1, children: /* @__PURE__ */ jsx9(Text4, { bold: true, underline: true, color: "cyan", children: "Session Cost Breakdown" }) }),
-    /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx9(Box4, { width: 20, children: /* @__PURE__ */ jsx9(Text4, { children: "Total Cost:" }) }),
-      /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
-        "$",
-        cost.totalCost.toFixed(4)
-      ] }),
-      cost.hasUnknownPrices && /* @__PURE__ */ jsx9(Text4, { color: "yellow", children: "(est.)" })
-    ] }),
-    /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx9(Box4, { width: 20, children: /* @__PURE__ */ jsx9(Text4, { children: "Input Tokens:" }) }),
-      /* @__PURE__ */ jsx9(Text4, { children: cost.inputTokens.toLocaleString() })
-    ] }),
-    /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx9(Box4, { width: 20, children: /* @__PURE__ */ jsx9(Text4, { children: "Cached Tokens:" }) }),
-      /* @__PURE__ */ jsx9(Text4, { color: "gray", children: cost.cachedInputTokens.toLocaleString() })
-    ] }),
-    /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx9(Box4, { width: 20, children: /* @__PURE__ */ jsx9(Text4, { children: "Output Tokens:" }) }),
-      /* @__PURE__ */ jsx9(Text4, { children: cost.outputTokens.toLocaleString() })
-    ] })
-  ] });
-}
-
-// ink/components/MessageLineItem.tsx
-import { Box as Box5, Text as Text5 } from "ink";
-import { memo as memo2 } from "react";
-import { Fragment, jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
-var MessageLineItem = memo2(
-  ({
-    item,
-    isSelected,
-    isFocused,
-    indent = 0
-  }) => {
-    const color = messageTypeToColor(item.type);
-    const label = item.type === "interrupted" ? "" : item.type.toUpperCase();
-    const selectionColor = isFocused ? "cyan" : "gray";
-    return /* @__PURE__ */ jsxs5(Box5, { children: [
-      /* @__PURE__ */ jsx10(Text5, { color: isSelected ? selectionColor : "gray", dimColor: !isSelected, bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " }),
-      /* @__PURE__ */ jsx10(Box5, { paddingLeft: indent, children: item.isFirstLine ? /* @__PURE__ */ jsxs5(Text5, { children: [
-        label && /* @__PURE__ */ jsxs5(Text5, { bold: true, color, children: [
-          label,
-          item.type === "tool" ? ": " : item.isArgsLine ? " args: " : ": "
-        ] }),
-        item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx10(Text5, { children: item.text.startsWith(item.toolName) ? /* @__PURE__ */ jsxs5(Fragment, { children: [
-          /* @__PURE__ */ jsx10(Text5, { color: "white", bold: true, children: item.toolName }),
-          /* @__PURE__ */ jsx10(Text5, { dimColor: true, italic: true, children: item.text.slice(item.toolName.length) })
-        ] }) : /* @__PURE__ */ jsx10(Text5, { dimColor: true, italic: true, children: item.text.startsWith(" ") ? item.text : ` ${item.text}` }) }) : /* @__PURE__ */ jsx10(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text })
-      ] }) : /* @__PURE__ */ jsx10(Text5, { children: item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx10(Text5, { dimColor: true, italic: true, children: item.text }) : /* @__PURE__ */ jsx10(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text }) }) })
-    ] });
-  }
-);
-function messageTypeToColor(type) {
-  switch (type) {
-    case "prompt":
-    case "user":
-      return "green";
-    case "agent":
-      return "cyan";
-    case "interrupted":
-      return "gray";
-    default:
-      return "magenta";
-  }
-}
-
-// ink/components/PlanView.tsx
-import { ProgressBar } from "@inkjs/ui";
-import { Box as Box6, Text as Text6 } from "ink";
-import "react";
-import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
-function PlanView() {
-  const { planDescription, planItems, progress } = usePlan();
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", flexGrow: 1, children: [
-    /* @__PURE__ */ jsx11(Box6, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx11(Text6, { italic: true, children: planDescription }) }),
-    /* @__PURE__ */ jsx11(Box6, { flexDirection: "column", flexGrow: 1, children: planItems.map((planItem) => /* @__PURE__ */ jsx11(Box6, { children: /* @__PURE__ */ jsxs6(
-      Text6,
-      {
-        color: planItem.status === "done" ? "green" : planItem.status === "in-progress" ? "yellow" : planItem.status === "not-needed" ? "gray" : "white",
-        dimColor: planItem.status === "not-needed",
-        children: [
-          planItem.status === "done" ? " \u25CF " : planItem.status === "in-progress" ? " \u25B6 " : planItem.status === "not-needed" ? " \u25CC " : " \u25CB ",
-          planItem.text
-        ]
-      }
-    ) }, planItem.id)) }),
-    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
-        "PROGRESS: ",
-        progress,
-        "%"
-      ] }),
-      /* @__PURE__ */ jsx11(ProgressBar, { value: progress })
-    ] })
-  ] });
-}
-
-// ink/components/SettingsView.tsx
-import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
-import path9 from "path";
-import { useEffect as useEffect6, useMemo as useMemo8, useState as useState10 } from "react";
-
-// ink/contexts/SettingsContext.tsx
-import { createContext as createContext6, useContext as useContext6, useMemo as useMemo7, useState as useState9 } from "react";
-import { jsx as jsx12 } from "react/jsx-runtime";
-var SettingsContext = createContext6(void 0);
-var useSettings = () => {
-  const context = useContext6(SettingsContext);
-  if (!context) {
-    throw new Error("useSettings must be used within a SettingsProvider");
-  }
-  return context;
-};
-var SettingsProvider = ({
-  children
-}) => {
-  const [version, setVersion] = useState9(0);
-  useListener("SettingsUpdated", () => {
-    setVersion((v) => v + 1);
-  }, []);
-  const value = useMemo7(() => ({
-    version,
-    model: trackedState.model,
-    compactionModel: trackedState.compactionModel,
-    sessionPath: trackedState.sessionPath,
-    cwd: trackedState.cwd,
-    useFlexTier: trackedState.useFlexTier,
-    currentTurn: trackedState.currentTurn,
-    maxTurns: trackedState.maxTurns,
-    maxCost: trackedState.maxCost,
-    autoApproveCodeInterpreter: trackedState.autoApproveCodeInterpreter,
-    autoApprovePatches: trackedState.autoApprovePatches,
-    autoApproveShell: trackedState.autoApproveShell,
-    monitorRateLimits: trackedState.monitorRateLimits,
-    rateLimitThreshold: trackedState.rateLimitThreshold,
-    rateLimitStatus: rateLimitTracker.getStatus()
-  }), [version]);
-  return /* @__PURE__ */ jsx12(SettingsContext.Provider, { value, children });
-};
-
-// ink/components/SettingsView.tsx
-import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
-function SettingsView({ isDense = false }) {
-  const {
-    model,
-    compactionModel,
-    sessionPath,
-    cwd,
-    useFlexTier,
-    currentTurn,
-    maxTurns,
-    maxCost,
-    autoApproveCodeInterpreter: initialAutoApproveCodeInterpreter,
-    autoApprovePatches: initialAutoApprovePatches,
-    autoApproveShell: initialAutoApproveShell,
-    monitorRateLimits: initialMonitorRateLimits,
-    rateLimitThreshold: initialRateLimitThreshold,
-    rateLimitStatus
-  } = useSettings();
-  const { focusedArea } = useChat();
-  const [autoApproveCodeInterpreter, setAutoApproveCodeInterpreter] = useState10(initialAutoApproveCodeInterpreter);
-  const [autoApprovePatches, setAutoApprovePatches] = useState10(initialAutoApprovePatches);
-  const [autoApproveShell, setAutoApproveShell] = useState10(initialAutoApproveShell);
-  const [monitorRateLimits, setMonitorRateLimits] = useState10(initialMonitorRateLimits);
-  useEffect6(() => {
-    setAutoApproveCodeInterpreter(initialAutoApproveCodeInterpreter);
-  }, [initialAutoApproveCodeInterpreter]);
-  useEffect6(() => {
-    setAutoApprovePatches(initialAutoApprovePatches);
-  }, [initialAutoApprovePatches]);
-  useEffect6(() => {
-    setAutoApproveShell(initialAutoApproveShell);
-  }, [initialAutoApproveShell]);
-  useEffect6(() => {
-    setMonitorRateLimits(initialMonitorRateLimits);
-  }, [initialMonitorRateLimits]);
-  const [selectedIndex, setSelectedIndex] = useState10(0);
-  const selectableOptions = useMemo8(() => [
-    {
-      label: "Code Interpreter",
-      value: autoApproveCodeInterpreter,
-      envKey: "HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER",
-      setter: setAutoApproveCodeInterpreter
-    },
-    {
-      label: "File Patches",
-      value: autoApprovePatches,
-      envKey: "HARPER_AGENT_AUTO_APPROVE_PATCHES",
-      setter: setAutoApprovePatches
-    },
-    {
-      label: "Shell Commands",
-      value: autoApproveShell,
-      envKey: "HARPER_AGENT_AUTO_APPROVE_SHELL",
-      setter: setAutoApproveShell
-    },
-    {
-      label: "Monitor Rate Limits",
-      value: monitorRateLimits,
-      envKey: "HARPER_AGENT_MONITOR_RATE_LIMITS",
-      setter: (val) => {
-        setMonitorRateLimits(val);
-        updateEnv("HARPER_AGENT_MONITOR_RATE_LIMITS", val ? "true" : "false");
-        emitToListeners("SettingsUpdated", void 0);
-      }
-    },
-    {
-      label: "<edit settings>",
-      isAction: true,
-      action: bootstrapConfig
-    }
-  ], [autoApproveCodeInterpreter, autoApprovePatches, autoApproveShell, monitorRateLimits]);
-  useInput2((_input, key) => {
-    if (focusedArea !== "status") {
-      return;
-    }
-    if (key.upArrow) {
-      setSelectedIndex((prev) => prev > 0 ? prev - 1 : selectableOptions.length - 1);
-    }
-    if (key.downArrow) {
-      setSelectedIndex((prev) => prev < selectableOptions.length - 1 ? prev + 1 : 0);
-    }
-    if (key.return || _input === " ") {
-      const selected = selectableOptions[selectedIndex];
-      if (!selected) {
-        return;
-      }
-      if ("isAction" in selected && selected.isAction) {
-        selected.action();
-      } else if ("setter" in selected) {
-        const newValue = !selected.value;
-        selected.setter(newValue);
-        updateEnv(selected.envKey, newValue ? "1" : "0");
-        emitToListeners("SettingsUpdated", void 0);
-      }
-    }
-  });
-  const displayPath = useMemo8(() => {
-    if (!sessionPath) {
-      return null;
-    }
-    const relative = path9.relative(cwd, sessionPath);
-    if (!relative.startsWith("..") && !path9.isAbsolute(relative)) {
-      return `./${relative}`;
-    }
-    return sessionPath;
-  }, [cwd, sessionPath]);
-  const marginBottom = isDense ? 0 : 1;
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", flexGrow: 1, paddingLeft: 1, children: [
-    /* @__PURE__ */ jsx13(Box7, { marginBottom, children: /* @__PURE__ */ jsx13(Text7, { bold: true, underline: true, color: "cyan", children: "Configuration" }) }),
-    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Model:" }) }),
-      /* @__PURE__ */ jsx13(Text7, { children: model })
-    ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Compaction Model:" }) }),
-      /* @__PURE__ */ jsx13(Text7, { children: compactionModel })
-    ] }),
-    displayPath && /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Session Path:" }) }),
-      /* @__PURE__ */ jsx13(Text7, { children: displayPath })
-    ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Flex Tier:" }) }),
-      /* @__PURE__ */ jsx13(Text7, { children: useFlexTier ? "Yes" : "No" })
-    ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Current Turn:" }) }),
-      /* @__PURE__ */ jsxs7(Text7, { children: [
-        currentTurn,
-        " / ",
-        maxTurns
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Rate Limit @:" }) }),
-      /* @__PURE__ */ jsxs7(Text7, { children: [
-        initialRateLimitThreshold,
-        "%"
-      ] })
-    ] }),
-    rateLimitStatus && /* @__PURE__ */ jsxs7(Box7, { marginBottom, flexDirection: "column", children: [
-      rateLimitStatus.retryAfter !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
-        /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { color: "red", children: "Retry After:" }) }),
-        /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
-          rateLimitStatus.retryAfter,
-          "s"
-        ] })
-      ] }),
-      (rateLimitStatus.limitRequests !== null || rateLimitStatus.remainingRequests !== null) && /* @__PURE__ */ jsxs7(Box7, { children: [
-        /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "RPM Limit:" }) }),
-        /* @__PURE__ */ jsxs7(Text7, { children: [
-          rateLimitStatus.remainingRequests ?? "?",
-          " / ",
-          rateLimitStatus.limitRequests ?? "?",
-          " (Reset:",
-          " ",
-          rateLimitStatus.resetRequests ?? "?",
-          ")"
-        ] })
-      ] }),
-      rateLimitStatus.remainingTokens !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
-        /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "TPM Limit:" }) }),
-        /* @__PURE__ */ jsxs7(Text7, { children: [
-          rateLimitStatus.remainingTokens ?? "?",
-          " / ",
-          rateLimitStatus.limitTokens ?? "?",
-          " (Reset:",
-          " ",
-          rateLimitStatus.resetTokens ?? "?",
-          ")"
-        ] })
-      ] })
-    ] }),
-    maxCost !== null && /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
-      /* @__PURE__ */ jsx13(Box7, { width: 20, children: /* @__PURE__ */ jsx13(Text7, { children: "Max Cost:" }) }),
-      /* @__PURE__ */ jsxs7(Text7, { children: [
-        "$",
-        maxCost.toFixed(2)
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx13(Text7, { bold: true, children: "Auto-approvals (up/down & space to toggle):" }),
-      selectableOptions.map((option, index) => {
-        const isSelected = index === selectedIndex && focusedArea === "status";
-        return /* @__PURE__ */ jsx13(Box7, { children: /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : "white", children: [
-          isSelected ? "> " : "  ",
-          option.label,
-          "isAction" in option ? "" : `: ${option.value ? "ON" : "OFF"}`
-        ] }) }, option.label);
-      })
-    ] })
-  ] });
-}
-
-// ink/components/UserInput.tsx
-import { Box as Box9, Text as Text9 } from "ink";
-import { exec as exec4 } from "child_process";
-import { promisify as promisify13 } from "util";
-import { useCallback as useCallback4, useState as useState12 } from "react";
-
-// ink/components/BlinkingTextInput.tsx
-import chalk3 from "chalk";
-import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
-import { useEffect as useEffect7, useMemo as useMemo9, useReducer, useState as useState11 } from "react";
-import { jsx as jsx14 } from "react/jsx-runtime";
-var reducer = (state, action) => {
-  switch (action.type) {
-    case "move-cursor-left":
-      return {
-        ...state,
-        cursorOffset: Math.max(0, state.cursorOffset - 1)
-      };
-    case "move-cursor-right":
-      return {
-        ...state,
-        cursorOffset: Math.min(state.value.length, state.cursorOffset + 1)
-      };
-    case "insert":
-      return {
-        ...state,
-        previousValue: state.value,
-        value: state.value.slice(0, state.cursorOffset) + action.text + state.value.slice(state.cursorOffset),
-        cursorOffset: state.cursorOffset + action.text.length
-      };
-    case "newline":
-      return {
-        ...state,
-        previousValue: state.value,
-        value: state.value.slice(0, state.cursorOffset) + "\n" + state.value.slice(state.cursorOffset),
-        cursorOffset: state.cursorOffset + 1
-      };
-    case "delete": {
-      const newCursorOffset = Math.max(0, state.cursorOffset - 1);
-      return {
-        ...state,
-        previousValue: state.value,
-        value: state.value.slice(0, newCursorOffset) + state.value.slice(state.cursorOffset),
-        cursorOffset: newCursorOffset
-      };
-    }
-    default:
-      return state;
-  }
-};
-function BlinkingTextInput({
-  isDisabled = false,
-  defaultValue = "",
-  placeholder = "",
-  suggestions = [],
-  onChange,
-  onSubmit
-}) {
-  const [state, dispatch] = useReducer(reducer, {
-    value: defaultValue,
-    previousValue: defaultValue,
-    cursorOffset: defaultValue.length
-  });
-  const [isCursorVisible, setIsCursorVisible] = useState11(true);
-  useEffect7(() => {
-    if (isDisabled) {
-      setIsCursorVisible(false);
-      return;
-    }
-    const interval = setInterval(() => {
-      setIsCursorVisible((prev) => !prev);
-    }, 500);
-    return () => clearInterval(interval);
-  }, [isDisabled]);
-  useEffect7(() => {
-    if (state.value !== state.previousValue) {
-      onChange?.(state.value);
-    }
-  }, [state.value, state.previousValue, onChange]);
-  const suggestion = useMemo9(() => {
-    if (state.value.length === 0) {
-      return "";
-    }
-    return suggestions.find((s) => s.startsWith(state.value))?.slice(state.value.length) || "";
-  }, [state.value, suggestions]);
-  useInput3(
-    (input, key) => {
-      if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
-        return;
-      }
-      setIsCursorVisible(true);
-      if (key.return) {
-        if (key.meta) {
-          dispatch({ type: "newline" });
-          return;
-        }
-        if (suggestion) {
-          onSubmit?.(state.value + suggestion);
-        } else {
-          onSubmit?.(state.value);
-        }
-        return;
-      }
-      if (key.leftArrow) {
-        dispatch({ type: "move-cursor-left" });
-      } else if (key.rightArrow) {
-        dispatch({ type: "move-cursor-right" });
-      } else if (key.backspace || key.delete) {
-        dispatch({ type: "delete" });
-      } else if (input) {
-        dispatch({ type: "insert", text: input });
-      }
-    },
-    { isActive: !isDisabled }
-  );
-  const renderedValue = useMemo9(() => {
-    if (isDisabled) {
-      const lines2 = (state.value || (placeholder ? chalk3.dim(placeholder) : "")).split("\n");
-      return /* @__PURE__ */ jsx14(Box8, { flexDirection: "column", children: lines2.map((line, i) => /* @__PURE__ */ jsx14(Box8, { children: /* @__PURE__ */ jsx14(Text8, { children: line }) }, i)) });
-    }
-    if (state.value.length === 0) {
-      let displayContent = "";
-      if (placeholder && placeholder.length > 0) {
-        displayContent = (isCursorVisible ? chalk3.inverse(placeholder[0]) : placeholder[0]) + chalk3.dim(placeholder.slice(1));
-      } else {
-        displayContent = isCursorVisible ? chalk3.inverse(" ") : " ";
-      }
-      return /* @__PURE__ */ jsx14(Box8, { flexGrow: 1, minWidth: 1, children: /* @__PURE__ */ jsx14(Text8, { wrap: "end", children: displayContent }) });
-    }
-    const lines = state.value.split("\n");
-    const result = [];
-    let totalOffset = 0;
-    lines.forEach((line, lineIndex) => {
-      let lineContent = "";
-      for (let i = 0; i < line.length; i++) {
-        const char = line[i];
-        if (totalOffset === state.cursorOffset) {
-          lineContent += isCursorVisible ? chalk3.inverse(char) : char;
-        } else {
-          lineContent += char;
-        }
-        totalOffset++;
-      }
-      if (totalOffset === state.cursorOffset) {
-        if (lineIndex === lines.length - 1 && suggestion) {
-          lineContent += (isCursorVisible ? chalk3.inverse(suggestion[0]) : suggestion[0]) + chalk3.dim(suggestion.slice(1));
-        } else {
-          lineContent += isCursorVisible ? chalk3.inverse(" ") : " ";
-        }
-      } else if (lineIndex === lines.length - 1 && suggestion) {
-        lineContent += chalk3.dim(suggestion);
-      }
-      result.push(
-        /* @__PURE__ */ jsx14(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx14(Text8, { wrap: "end", children: lineContent }) }, lineIndex)
-      );
-      if (lineIndex < lines.length - 1) {
-        totalOffset++;
-      }
-    });
-    return /* @__PURE__ */ jsx14(Box8, { flexDirection: "column", flexGrow: 1, children: result });
-  }, [state.value, state.cursorOffset, suggestion, isCursorVisible, isDisabled, placeholder]);
-  return /* @__PURE__ */ jsx14(Box8, { flexGrow: 1, minWidth: 1, children: renderedValue });
-}
-
-// ink/components/UserInput.tsx
-import { jsx as jsx15, jsxs as jsxs8 } from "react/jsx-runtime";
-var execAsync4 = promisify13(exec4);
-var modeSuggestion = {
-  approved: ["/clear", "/skills", "/exit"],
-  approving: ["yes", "approve", "no", "deny"],
-  denied: [],
-  waiting: ["/clear", "/skills", "/exit"]
-};
-function UserInput() {
-  const { userInputMode, focusedArea } = useChat();
-  const [resetKey, setResetKey] = useState12(0);
-  const [, setBlankLines] = useState12(0);
-  useListener("ClearUserInput", () => {
-    setResetKey((prev) => prev + 1);
-  }, []);
-  const borderColor = focusedArea === "input" ? "cyan" : "gray";
-  const placeholder = calculatePlaceholder(userInputMode);
-  const onSubmitResetKey = useCallback4(async (value) => {
-    if (value.length) {
-      const trimmedValue = value.trim();
-      if (trimmedValue === "/clear") {
-        setResetKey((prev) => prev + 1);
-        emitToListeners("ClearChatHistory", void 0);
-        return;
-      }
-      if (trimmedValue === "/exit" || trimmedValue === "exit") {
-        await handleExit();
-        return;
-      }
-      if (trimmedValue === "/skills") {
-        setResetKey((prev) => prev + 1);
-        emitToListeners("PushNewMessages", [{
-          type: "user",
-          text: "/skills",
-          version: 1
-        }, {
-          type: "agent",
-          text: "Installing skills...",
-          version: 1
-        }]);
-        try {
-          const { stdout, stderr } = await execAsync4("npx skills add harperfast/skills");
-          emitToListeners(
-            "UpdateLastMessageText",
-            `
-
-Skills installation result:
-${stdout}${stderr ? `
-Errors:
-${stderr}` : ""}`
-          );
-        } catch (error) {
-          emitToListeners("UpdateLastMessageText", `
-
-Failed to install skills: ${error.message}`);
-        }
-        return;
-      }
-      setResetKey((prev) => prev + 1);
-      emitToListeners("PushNewMessages", [{ type: "user", text: trimmedValue, version: 1 }]);
-      setBlankLines(0);
-    } else {
-      setBlankLines((value2) => {
-        value2 += 1;
-        if (value2 === 2) {
-          void handleExit();
-        }
-        return value2;
-      });
-    }
-  }, []);
-  return /* @__PURE__ */ jsxs8(
-    Box9,
-    {
-      minHeight: footerHeight,
-      borderStyle: "bold",
-      borderTop: false,
-      borderColor,
-      flexDirection: "row",
-      alignItems: "flex-start",
-      gap: 1,
-      children: [
-        /* @__PURE__ */ jsx15(Box9, { marginLeft: 1, height: 1, children: /* @__PURE__ */ jsx15(Text9, { bold: true, color: borderColor, children: "\u276F" }) }),
-        /* @__PURE__ */ jsx15(Box9, { flexGrow: 1, children: /* @__PURE__ */ jsx15(
-          BlinkingTextInput,
-          {
-            placeholder,
-            onSubmit: onSubmitResetKey,
-            suggestions: modeSuggestion[userInputMode],
-            isDisabled: focusedArea !== "input"
-          },
-          resetKey
-        ) })
-      ]
-    }
-  );
-}
-function calculatePlaceholder(mode) {
-  const prefix = "  ";
-  switch (mode) {
-    case "denied":
-      return prefix + "OK! Let's find another way.";
-    case "approving":
-      return prefix + "Do you approve? yes / no";
-    default:
-    case "approved":
-    case "waiting":
-      return "";
-  }
-}
-
-// ink/components/ChatContent.tsx
-import { jsx as jsx16, jsxs as jsxs9 } from "react/jsx-runtime";
-function ChatContent() {
-  const { messages, isThinking, isCompacting, pullingState, focusedArea, setFocusedArea } = useChat();
-  const { payload } = useApproval();
-  const size = useTerminalSize();
-  useMessageListener();
-  const [activeTab, setActiveTab] = useState13("settings");
-  const [userHasSwitchedTab, setUserHasSwitchedTab] = useState13(false);
-  const { planDescription, planItems } = usePlan();
-  useEffect8(() => {
-    if (!userHasSwitchedTab && activeTab === "settings") {
-      const hasPlan = planDescription.trim().length > 0 || planItems.length > 0;
-      if (hasPlan) {
-        setActiveTab("planDescription");
-      }
-    }
-  }, [planDescription, planItems, userHasSwitchedTab, activeTab]);
-  const [selectedIndex, setSelectedIndex] = useState13(0);
-  const wrapCache = useRef2(
-    /* @__PURE__ */ new Map()
-  );
-  useInput4((input, key) => {
-    if (key.tab) {
-      const focusOrder = ["input", "timeline", "status"];
-      const currentIndex = focusOrder.indexOf(focusedArea);
-      if (key.shift || input === "\x1B[Z") {
-        const nextIndex = (currentIndex - 1 + focusOrder.length) % focusOrder.length;
-        setFocusedArea(focusOrder[nextIndex]);
-      } else {
-        const nextIndex = (currentIndex + 1) % focusOrder.length;
-        setFocusedArea(focusOrder[nextIndex]);
-      }
-      return;
-    }
-    if (focusedArea === "timeline") {
-      if (key.upArrow) {
-        setSelectedIndex((prev) => Math.max(0, prev - 1));
-      }
-      if (key.downArrow) {
-        setSelectedIndex((prev) => Math.min(Math.max(0, lineItems.length - 1), prev + 1));
-      }
-      if (key.return) {
-        const selected = lineItems[selectedIndex];
-        if (selected && selected.type === "tool" && (selected.toolName === "apply_patch" || selected.toolName === "code_interpreter" || selected.toolName === "shell")) {
-          const msg = messages.find((m) => m.id === selected.messageId);
-          if (msg && msg.callId) {
-            emitToListeners("OpenApprovalViewer", {
-              type: selected.toolName,
-              mode: "info",
-              callId: msg.callId
-            });
-          }
-        }
-      }
-    }
-    if (focusedArea === "status") {
-      if (key.leftArrow || key.rightArrow) {
-        const tabNames = ["settings", "planDescription", "actions"];
-        const currentIndex = tabNames.indexOf(activeTab);
-        if (key.leftArrow) {
-          const nextIndex = (currentIndex - 1 + tabNames.length) % tabNames.length;
-          const newTab = tabNames[nextIndex];
-          setActiveTab(newTab);
-          setUserHasSwitchedTab(true);
-        } else {
-          const nextIndex = (currentIndex + 1) % tabNames.length;
-          const newTab = tabNames[nextIndex];
-          setActiveTab(newTab);
-          setUserHasSwitchedTab(true);
-        }
-      }
-    }
-    if (key.ctrl && input === "x") {
-      void handleExit();
-    }
-    if (key.escape && isThinking && focusedArea === "input" && !payload) {
-      emitToListeners("InterruptThought", void 0);
-    }
-  });
-  const contentHeight = size.rows - footerHeight;
-  const timelineWidth = Math.floor(size.columns * 0.65);
-  const statusWidth = size.columns - timelineWidth;
-  const labelWidthFor = useCallback5((type) => {
-    if (type === "agent") {
-      return 7;
-    }
-    if (type === "prompt") {
-      return 7;
-    }
-    if (type === "user") {
-      return 6;
-    }
-    if (type === "interrupted") {
-      return 0;
-    }
-    return 6;
-  }, []);
-  const availableTextWidth = timelineWidth - 4;
-  const pullingHeight = pullingState ? 1 : 0;
-  const lineItems = useMemo10(() => {
-    const acc = [];
-    for (const msg of messages) {
-      const labelWidth = labelWidthFor(msg.type);
-      const firstLineWidth = Math.max(1, availableTextWidth - labelWidth);
-      let entry = wrapCache.current.get(msg.id);
-      if (!entry || entry.version !== msg.version || entry.width !== firstLineWidth) {
-        const textLines = wrapText(msg.text ?? "", firstLineWidth);
-        const argsLines = msg.args ? wrapText(String(msg.args), firstLineWidth) : [];
-        const msgLineItems = [];
-        if (msg.type === "tool") {
-          const toolName = msg.text ?? "";
-          const toolArgs = msg.args ?? "";
-          const toolNameWithSpace = `${toolName} `;
-          const availableForArgs = firstLineWidth - toolNameWithSpace.length;
-          let displayedArgs = toolArgs;
-          if (availableForArgs < toolArgs.length) {
-            if (availableForArgs > 3) {
-              displayedArgs = toolArgs.slice(0, availableForArgs - 3) + "...";
-            } else {
-              displayedArgs = toolArgs.slice(0, Math.max(0, availableForArgs));
-            }
-          }
-          msgLineItems.push({
-            key: `${msg.id}:tool:0`,
-            messageId: msg.id,
-            type: msg.type,
-            text: `${toolNameWithSpace}${displayedArgs}`,
-            isFirstLine: true,
-            toolName
-          });
-        } else {
-          textLines.forEach((txt, idx) => {
-            msgLineItems.push({
-              key: `${msg.id}:text:${idx}`,
-              messageId: msg.id,
-              type: msg.type,
-              text: txt,
-              isFirstLine: idx === 0
-            });
-          });
-          if (argsLines.length > 0) {
-            argsLines.forEach((txt, idx) => {
-              msgLineItems.push({
-                key: `${msg.id}:args:${idx}`,
-                messageId: msg.id,
-                type: msg.type,
-                text: txt,
-                isFirstLine: idx === 0 && textLines.length === 0,
-                isArgsLine: true
-              });
-            });
-          }
-        }
-        entry = { version: msg.version, width: firstLineWidth, lineItems: msgLineItems };
-        wrapCache.current.set(msg.id, entry);
-      }
-      acc.push(...entry.lineItems);
-    }
-    if (wrapCache.current.size > messages.length * 2) {
-      const messageIds = new Set(messages.map((m) => m.id));
-      for (const id of wrapCache.current.keys()) {
-        if (!messageIds.has(id)) {
-          wrapCache.current.delete(id);
-        }
-      }
-    }
-    return acc;
-  }, [messages, availableTextWidth, labelWidthFor]);
-  useEffect8(() => {
-    if (lineItems.length > 0 && focusedArea !== "timeline") {
-      setSelectedIndex(lineItems.length - 1);
-    }
-  }, [lineItems.length, focusedArea]);
-  useEffect8(() => {
-    if (lineItems.length > 0) {
-      setSelectedIndex(lineItems.length - 1);
-    }
-  }, [size.rows, size.columns]);
-  const tabs = useMemo10(() => [
-    { name: "settings", label: "SETTINGS" },
-    { name: "planDescription", label: "PLAN" },
-    { name: "actions", label: "ACTIONS" }
-  ], []);
-  const timelineTitle = "TIMELINE:";
-  const timelineHeaderWidth = timelineWidth - 1;
-  const showSpinner = isCompacting || isThinking || Boolean(pullingState);
-  const timelineDashes = timelineHeaderWidth - timelineTitle.length - (showSpinner ? 5 : 0);
-  const tabsTotalWidth = tabs.reduce((acc, t) => acc + t.label.length + 2, 0) + (tabs.length - 1);
-  const statusDashes = Math.max(0, statusWidth - tabsTotalWidth - 2);
-  const timelineColor = focusedArea === "timeline" ? "cyan" : "gray";
-  const statusColor = focusedArea === "status" ? "cyan" : "gray";
-  const dividerColor = focusedArea === "timeline" || focusedArea === "status" ? "cyan" : "gray";
-  const timelineBottomColor = focusedArea === "timeline" || focusedArea === "input" ? "cyan" : "gray";
-  const statusBottomColor = focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
-  const junctionLeftColor = focusedArea === "timeline" || focusedArea === "input" ? "cyan" : "gray";
-  const junctionMiddleColor = focusedArea === "timeline" || focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
-  const junctionRightColor = focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
-  const timelinePipeFiller = useCallback5((count) => /* @__PURE__ */ jsx16(Box10, { flexDirection: "column", children: Array.from({ length: count }).map((_, i) => /* @__PURE__ */ jsx16(Box10, { children: /* @__PURE__ */ jsx16(Text10, { color: "gray", dimColor: true, children: "\u2502" }) }, i)) }), []);
-  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", height: size.rows, padding: 0, children: [
-    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: 1, children: [
-      /* @__PURE__ */ jsx16(Text10, { color: timelineColor, children: "\u256D" }),
-      /* @__PURE__ */ jsx16(Text10, { bold: true, color: timelineColor, children: timelineTitle }),
-      showSpinner && /* @__PURE__ */ jsx16(Box10, { paddingLeft: 2, paddingRight: 1, children: /* @__PURE__ */ jsx16(Spinner2, { type: "clock" }) }),
-      /* @__PURE__ */ jsx16(Text10, { color: timelineColor, children: "\u2500".repeat(Math.max(0, timelineDashes)) }),
-      /* @__PURE__ */ jsx16(Text10, { color: dividerColor, children: "\u252C" }),
-      tabs.map((tab, i) => /* @__PURE__ */ jsxs9(React11.Fragment, { children: [
-        /* @__PURE__ */ jsx16(
-          Text10,
-          {
-            color: activeTab === tab.name ? "black" : statusColor,
-            backgroundColor: activeTab === tab.name ? statusColor : "",
-            bold: activeTab === tab.name,
-            children: ` ${tab.label} `
-          }
-        ),
-        i < tabs.length - 1 && /* @__PURE__ */ jsx16(Text10, { color: statusColor, children: "|" })
-      ] }, tab.name)),
-      /* @__PURE__ */ jsxs9(Text10, { color: statusColor, children: [
-        "\u2500".repeat(statusDashes),
-        "\u256E"
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: contentHeight - 2 - pullingHeight, children: [
-      /* @__PURE__ */ jsx16(
-        Box10,
-        {
-          flexDirection: "column",
-          width: timelineWidth,
-          paddingLeft: 0,
-          paddingRight: 1,
-          children: /* @__PURE__ */ jsx16(Box10, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx16(
-            VirtualList,
-            {
-              items: lineItems,
-              itemHeight: 1,
-              height: contentHeight - 2 - pullingHeight,
-              selectedIndex,
-              renderOverflowTop: useCallback5((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
-                /* @__PURE__ */ jsx16(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
-                count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
-                  " ",
-                  "\u25B2 ",
-                  count,
-                  " more"
-                ] })
-              ] }), []),
-              renderOverflowBottom: useCallback5((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
-                /* @__PURE__ */ jsx16(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
-                count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
-                  " ",
-                  "\u25BC ",
-                  count,
-                  " more"
-                ] })
-              ] }), []),
-              renderFiller: timelinePipeFiller,
-              keyExtractor: (it) => it.key,
-              renderItem: useCallback5(
-                ({ item, isSelected }) => /* @__PURE__ */ jsx16(
-                  MessageLineItem,
-                  {
-                    item,
-                    isSelected,
-                    isFocused: focusedArea === "timeline",
-                    indent: item.isFirstLine ? 0 : labelWidthFor(item.type)
-                  }
-                ),
-                [labelWidthFor, focusedArea]
-              )
-            }
-          ) })
-        }
-      ),
-      activeTab !== "shell" && activeTab !== "actions" && /* @__PURE__ */ jsx16(
-        Box10,
-        {
-          flexDirection: "column",
-          width: 1,
-          borderStyle: "round",
-          borderColor: dividerColor,
-          borderTop: false,
-          borderBottom: false,
-          borderRight: false
-        }
-      ),
-      /* @__PURE__ */ jsx16(
-        Box10,
-        {
-          flexDirection: "column",
-          width: activeTab === "shell" || activeTab === "actions" ? statusWidth : statusWidth - 1,
-          borderStyle: "round",
-          borderColor: statusColor,
-          borderTop: false,
-          borderBottom: false,
-          borderLeft: false,
-          paddingLeft: activeTab === "shell" || activeTab === "actions" ? 0 : 1,
-          paddingRight: 1,
-          children: /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", flexGrow: 1, marginTop: 0, children: [
-            activeTab === "settings" && /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", children: [
-              /* @__PURE__ */ jsx16(CostView, { isDense: true }),
-              /* @__PURE__ */ jsx16(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx16(SettingsView, { isDense: true }) })
-            ] }),
-            activeTab === "planDescription" && /* @__PURE__ */ jsx16(PlanView, {}),
-            activeTab === "actions" && /* @__PURE__ */ jsx16(
-              ActionsView,
-              {
-                height: contentHeight - 2 - pullingHeight,
-                isFocused: focusedArea === "status"
-              }
-            )
-          ] })
-        }
-      )
-    ] }),
-    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", children: [
-      pullingState && /* @__PURE__ */ jsx16(Box10, { paddingLeft: 2, paddingRight: 2, marginBottom: 0, children: /* @__PURE__ */ jsxs9(Text10, { color: "yellow", children: [
-        `\uF019 Downloading `,
-        /* @__PURE__ */ jsx16(Text10, { bold: true, children: pullingState.modelName }),
-        ` from Ollama... `,
-        /* @__PURE__ */ jsx16(Text10, { dimColor: true, children: pullingState.status === "pulling manifest" ? "initializing" : pullingState.status }),
-        pullingState.total > 0 && /* @__PURE__ */ jsxs9(Text10, { children: [
-          ` [${"=".repeat(Math.floor(pullingState.completed / pullingState.total * 20))}${" ".repeat(20 - Math.floor(pullingState.completed / pullingState.total * 20))}] `,
-          Math.round(pullingState.completed / pullingState.total * 100),
-          "%"
-        ] })
-      ] }) }),
-      /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: 1, children: [
-        /* @__PURE__ */ jsx16(Text10, { color: junctionLeftColor, children: "\u2522" }),
-        /* @__PURE__ */ jsx16(Text10, { color: timelineBottomColor, children: "\u2501".repeat(timelineWidth - 1) }),
-        /* @__PURE__ */ jsx16(Text10, { color: junctionMiddleColor, children: "\u2537" }),
-        /* @__PURE__ */ jsx16(Text10, { color: statusBottomColor, children: "\u2501".repeat(Math.max(0, statusWidth - 2)) }),
-        /* @__PURE__ */ jsx16(Text10, { color: junctionRightColor, children: "\u252A" })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx16(UserInput, {})
-  ] });
-}
-
-// ink/components/DiffApprovalView.tsx
-import { Box as Box11, Text as Text11, useInput as useInput5 } from "ink";
-import { useMemo as useMemo11, useState as useState14 } from "react";
-import { Fragment as Fragment2, jsx as jsx17, jsxs as jsxs10 } from "react/jsx-runtime";
-function DiffApprovalView() {
-  const { payload } = useApproval();
-  const size = useTerminalSize();
-  const [scrollIndex, setScrollIndex] = useState14(0);
-  const diffLines = useMemo11(() => {
-    if (!payload?.diff) {
-      return [];
-    }
-    return payload.diff.split("\n");
-  }, [payload?.diff]);
-  const wrappedLines = useMemo11(() => {
-    const result = [];
-    if (!payload) {
-      return result;
-    }
-    if (payload.type === "delete_file") {
-      result.push({ text: "Delete file: " + payload.path, color: "red" });
-      return result;
-    }
-    if (payload.type === "overwrite_file") {
-      for (const line of diffLines) {
-        let color;
-        if (line.startsWith("+")) {
-          color = "green";
-        } else if (line.startsWith("-")) {
-          color = "red";
-        }
-        const wrapped = wrapText(line, size.columns - 4);
-        for (const w of wrapped) {
-          result.push({ text: w, color });
-        }
-      }
-      return result;
-    }
-    if (payload.type === "code_interpreter" && payload.code) {
-      const lines = payload.code.split("\n");
-      for (const line of lines) {
-        const wrapped = wrapText(line, size.columns - 4);
-        for (const w of wrapped) {
-          result.push({ text: w });
-        }
-      }
-      return result;
-    }
-    if (payload.type === "shell" && payload.commands) {
-      for (const cmd of payload.commands) {
-        const wrapped = wrapText(`$ ${cmd}`, size.columns - 4);
-        for (const w of wrapped) {
-          result.push({ text: w, color: "yellow" });
-        }
-      }
-      return result;
-    }
-    for (const line of diffLines) {
-      let color;
-      if (line.startsWith("+")) {
-        color = "green";
-      } else if (line.startsWith("-")) {
-        color = "red";
-      } else if (line.startsWith("@@")) {
-        color = "cyan";
-      }
-      const wrapped = wrapText(line, size.columns - 4);
-      for (const w of wrapped) {
-        result.push({ text: w, color });
-      }
-    }
-    return result;
-  }, [diffLines, size.columns, payload]);
-  const visibleHeight = size.rows - 6;
-  useInput5((input, key) => {
-    if (!payload) {
-      return;
-    }
-    if (key.escape) {
-      if (payload.mode === "ask") {
-        emitToListeners("DenyCurrentApproval", void 0);
-      }
-      emitToListeners("CloseApprovalViewer", void 0);
-      return;
-    }
-    if (key.return) {
-      if (payload.mode === "ask") {
-        const now = Date.now();
-        if (payload.openedAt && now - payload.openedAt > 1e3) {
-          emitToListeners("ApproveCurrentApproval", void 0);
-          emitToListeners("CloseApprovalViewer", void 0);
-          emitToListeners("ClearUserInput", void 0);
-        }
-      } else {
-        emitToListeners("CloseApprovalViewer", void 0);
-      }
-      return;
-    }
-    if (payload.mode === "ask") {
-      const now = Date.now();
-      if (payload.openedAt && now - payload.openedAt > 1e3) {
-        if (input === "y") {
-          emitToListeners("ApproveCurrentApproval", void 0);
-          emitToListeners("CloseApprovalViewer", void 0);
-          emitToListeners("ClearUserInput", void 0);
-        } else if (input === "n") {
-          emitToListeners("DenyCurrentApproval", void 0);
-          emitToListeners("CloseApprovalViewer", void 0);
-          emitToListeners("ClearUserInput", void 0);
-        }
-      }
-    }
-    if (key.upArrow) {
-      setScrollIndex((prev) => Math.max(0, prev - 1));
-    }
-    if (key.downArrow) {
-      setScrollIndex((prev) => Math.min(Math.max(0, wrappedLines.length - visibleHeight), prev + 1));
-    }
-    if (key.pageUp) {
-      setScrollIndex((prev) => Math.max(0, prev - visibleHeight));
-    }
-    if (key.pageDown) {
-      setScrollIndex((prev) => Math.min(Math.max(0, wrappedLines.length - visibleHeight), prev + visibleHeight));
-    }
-  });
-  if (!payload) {
-    return null;
-  }
-  const canRespond = payload.mode === "ask" && payload.openedAt && Date.now() - payload.openedAt > 1e3;
-  return /* @__PURE__ */ jsxs10(
-    Box11,
-    {
-      position: "absolute",
-      flexDirection: "column",
-      width: size.columns,
-      height: size.rows,
-      backgroundColor: "black",
-      borderStyle: "double",
-      borderColor: "cyan",
-      children: [
-        /* @__PURE__ */ jsxs10(
-          Box11,
-          {
-            paddingX: 1,
-            borderStyle: "single",
-            borderBottomColor: "gray",
-            borderTop: false,
-            borderLeft: false,
-            borderRight: false,
-            children: [
-              /* @__PURE__ */ jsxs10(Text11, { bold: true, color: "cyan", children: [
-                payload.mode === "ask" ? "APPROVE " : "VIEW ",
-                payload.type.toUpperCase().replace("_", " ")
-              ] }),
-              /* @__PURE__ */ jsx17(Text11, { color: "gray", children: "\u2502" }),
-              payload.path && /* @__PURE__ */ jsxs10(Fragment2, { children: [
-                /* @__PURE__ */ jsxs10(Text11, { bold: true, children: [
-                  payload.type,
-                  ":"
-                ] }),
-                /* @__PURE__ */ jsx17(Text11, { children: payload.path })
-              ] })
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx17(Box11, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: wrappedLines.length === 0 ? /* @__PURE__ */ jsx17(Text11, { italic: true, color: "gray", children: "No diff content." }) : wrappedLines.slice(scrollIndex, scrollIndex + visibleHeight).map((line, i) => /* @__PURE__ */ jsx17(Text11, { color: line.color || "white", children: line.text }, i)) }),
-        /* @__PURE__ */ jsxs10(
-          Box11,
-          {
-            paddingX: 1,
-            borderStyle: "single",
-            borderTopColor: "gray",
-            borderBottom: false,
-            borderLeft: false,
-            borderRight: false,
-            children: [
-              payload.mode === "ask" ? /* @__PURE__ */ jsxs10(Box11, { flexGrow: 1, children: [
-                /* @__PURE__ */ jsx17(Text11, { color: canRespond ? "green" : "gray", children: "[Enter/y] Approve" }),
-                /* @__PURE__ */ jsx17(Text11, {}),
-                /* @__PURE__ */ jsx17(Text11, { color: canRespond ? "red" : "gray", children: "[Esc/n] Deny" }),
-                !canRespond && /* @__PURE__ */ jsx17(Text11, { color: "yellow", children: "(Wait 1s...)" })
-              ] }) : /* @__PURE__ */ jsx17(Box11, { flexGrow: 1, children: /* @__PURE__ */ jsx17(Text11, { color: "cyan", children: "[Enter/Esc] Close" }) }),
-              /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
-                "Line ",
-                scrollIndex + 1,
-                "/",
-                wrappedLines.length
-              ] })
-            ]
-          }
-        )
-      ]
-    }
-  );
-}
-
-// ink/configurationWizard/ConfigurationWizard.tsx
-import { Box as Box18, useInput as useInput10 } from "ink";
-import { Step, Stepper } from "ink-stepper";
-import { useEffect as useEffect14, useState as useState16 } from "react";
-
-// utils/files/getEnvVarForProvider.ts
-function getEnvVarForProvider(provider) {
-  switch (provider) {
-    case "Anthropic":
-      return "ANTHROPIC_API_KEY";
-    case "Google":
-      return "GOOGLE_GENERATIVE_AI_API_KEY";
-    case "OpenAI":
-      return "OPENAI_API_KEY";
-    case "Ollama":
-      return "OLLAMA_BASE_URL";
-  }
-}
-
-// utils/files/updateEnvKeyForProvider.ts
-function updateEnvKeyForProvider(provider, key) {
-  const envVar = getEnvVarForProvider(provider);
-  return updateEnv(envVar, key);
-}
-
-// ink/configurationWizard/ApiKeyStep.tsx
-import { PasswordInput } from "@inkjs/ui";
-import { Box as Box12, Text as Text12, useInput as useInput6 } from "ink";
-import { useStepperInput } from "ink-stepper";
-import { useEffect as useEffect9 } from "react";
-import { jsx as jsx18, jsxs as jsxs11 } from "react/jsx-runtime";
-function ApiKeyStep({ provider, onConfirm, onBack }) {
-  const { disableNavigation, enableNavigation } = useStepperInput();
-  useEffect9(() => {
-    disableNavigation();
-    return () => enableNavigation();
-  }, [disableNavigation, enableNavigation]);
-  useInput6((input, key) => {
-    if (key.escape) {
-      onBack();
-    }
-  });
-  const instructions = {
-    OpenAI: "Get your key at: https://platform.openai.com/api-keys",
-    Anthropic: "Get your key at: https://console.anthropic.com/settings/keys",
-    Google: "Get your key at: https://aistudio.google.com/app/apikey",
-    Ollama: ""
-  };
-  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs11(Text12, { children: [
-      "Can you provide us with your ",
-      provider,
-      " API key?"
-    ] }),
-    /* @__PURE__ */ jsx18(Text12, { dimColor: true, children: instructions[provider] }),
-    /* @__PURE__ */ jsx18(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx18(
-      PasswordInput,
-      {
-        onSubmit: (v) => {
-          if (v === "exit") {
-            emitToListeners("ExitUI", void 0);
-          } else {
-            onConfirm(v);
-          }
-        }
-      }
-    ) }),
-    /* @__PURE__ */ jsx18(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx18(Text12, { dimColor: true, children: "Press ESC to go back" }) })
-  ] });
-}
-
-// ink/configurationWizard/ApiUrlStep.tsx
-import { Box as Box13, Text as Text13, useInput as useInput7 } from "ink";
-import { useStepperInput as useStepperInput2 } from "ink-stepper";
-import { useEffect as useEffect10 } from "react";
-import { jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
-function ApiUrlStep({ provider, onConfirm, onBack }) {
-  const { disableNavigation, enableNavigation } = useStepperInput2();
-  useEffect10(() => {
-    disableNavigation();
-    return () => enableNavigation();
-  }, [disableNavigation, enableNavigation]);
-  useInput7((input, key) => {
-    if (key.escape) {
-      onBack();
-    }
-  });
-  const defaultApi = {
-    OpenAI: "",
-    Anthropic: "",
-    Google: "",
-    Ollama: "http://localhost:11434/api"
-  };
-  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs12(Text13, { children: [
-      "Where are you hosting ",
-      provider,
-      "?"
-    ] }),
-    /* @__PURE__ */ jsx19(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx19(
-      BlinkingTextInput,
-      {
-        placeholder: defaultApi[provider] || "",
-        onSubmit: (v) => {
-          if (v === "exit") {
-            emitToListeners("ExitUI", void 0);
-          } else {
-            onConfirm(v || defaultApi[provider] || "");
-          }
-        }
-      }
-    ) }),
-    /* @__PURE__ */ jsx19(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text13, { dimColor: true, children: "Press ESC to go back" }) })
-  ] });
-}
-
-// ink/configurationWizard/EnvironmentSettingsStep.tsx
-import { MultiSelect } from "@inkjs/ui";
-import { Box as Box14, Text as Text14, useInput as useInput8 } from "ink";
-import { useStepperInput as useStepperInput3 } from "ink-stepper";
-import { useEffect as useEffect11 } from "react";
-import { jsx as jsx20, jsxs as jsxs13 } from "react/jsx-runtime";
-var SETTINGS = [
-  {
-    label: "Save Harper agent memory locally",
-    value: "HARPER_AGENT_SESSION",
-    defaultValue: "./harper-agent-memory.json"
-  },
-  {
-    label: "Automatically approve code interpreter execution",
-    value: "HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER",
-    defaultValue: "1"
-  },
-  {
-    label: "Automatically approve file patches",
-    value: "HARPER_AGENT_AUTO_APPROVE_PATCHES",
-    defaultValue: "1"
-  },
-  {
-    label: "Automatically approve shell commands",
-    value: "HARPER_AGENT_AUTO_APPROVE_SHELL",
-    defaultValue: "1"
-  },
-  {
-    label: "Use flex tier for lower costs when possible",
-    value: "HARPER_AGENT_FLEX_TIER",
-    defaultValue: "true"
-  }
-];
-function EnvironmentSettingsStep({ onConfirm, onBack }) {
-  const { disableNavigation, enableNavigation } = useStepperInput3();
-  useEffect11(() => {
-    disableNavigation();
-    return () => enableNavigation();
-  }, [disableNavigation, enableNavigation]);
-  useInput8((_input, key) => {
-    if (key.escape) {
-      onBack();
-    }
-  });
-  const options = SETTINGS.map((s) => ({
-    label: s.label,
-    value: s.value
-  }));
-  const defaultValues = SETTINGS.map((s) => s.value);
-  const handleSubmit = (values) => {
-    for (const setting of SETTINGS) {
-      if (values.includes(setting.value)) {
-        updateEnv(setting.value, setting.defaultValue);
-      }
-    }
-    onConfirm();
-  };
-  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx20(Text14, { children: "Additional Settings (all enabled by default):" }),
-    /* @__PURE__ */ jsx20(
-      MultiSelect,
-      {
-        options,
-        defaultValue: defaultValues,
-        onSubmit: handleSubmit
-      }
-    ),
-    /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
-      "Press ",
-      "<space>",
-      " to toggle, ",
-      "<enter>",
-      " to confirm."
-    ] })
-  ] });
-}
-
-// ink/configurationWizard/modelsByProvider.ts
-var modelsByProvider = {
-  OpenAI: [defaultOpenAIModel, "gpt-5.0", defaultOpenAICompactionModel],
-  Anthropic: [defaultAnthropicModel, "claude-4-5-sonnet-latest", defaultAnthropicCompactionModel],
-  Google: [defaultGoogleModel, "gemini-3-flash", "gemini-2.5-flash", defaultGoogleCompactionModel],
-  Ollama: [defaultOllamaModel, "ollama-qwen3.5:27b", defaultOllamaCompactionModel]
-};
-var compactorModelsByProvider = {
-  OpenAI: modelsByProvider.OpenAI.slice().reverse(),
-  Anthropic: modelsByProvider.Anthropic.slice().reverse(),
-  Google: modelsByProvider.Google.slice().reverse(),
-  Ollama: modelsByProvider.Ollama.slice().reverse()
-};
-
-// ink/configurationWizard/ModelSelectionStep.tsx
-import { Select } from "@inkjs/ui";
-import { Box as Box15, Text as Text15, useInput as useInput9 } from "ink";
-import { useStepperInput as useStepperInput4 } from "ink-stepper";
-import { useEffect as useEffect12, useState as useState15 } from "react";
-import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
-function ModelSelectionStep({
-  title,
-  models,
-  onConfirm,
-  onBack
-}) {
-  const { disableNavigation, enableNavigation } = useStepperInput4();
-  const [isCustom, setIsCustom] = useState15(false);
-  useEffect12(() => {
-    disableNavigation();
-    return () => enableNavigation();
-  }, [isCustom, disableNavigation, enableNavigation]);
-  useInput9((input, key) => {
-    if (key.escape) {
-      if (isCustom) {
-        setIsCustom(false);
-      } else {
-        onBack();
-      }
-    }
-  });
-  if (isCustom) {
-    return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs14(Text15, { children: [
-        "Enter custom model name for: ",
-        title
-      ] }),
-      /* @__PURE__ */ jsx21(
-        BlinkingTextInput,
-        {
-          onSubmit: (v) => {
-            if (v === "exit") {
-              emitToListeners("ExitUI", void 0);
-            } else {
-              onConfirm(v);
-            }
-          }
-        }
-      ),
-      /* @__PURE__ */ jsx21(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text15, { dimColor: true, children: "Press ESC to go back to list" }) })
-    ] });
-  }
-  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx21(Text15, { children: title }),
-    /* @__PURE__ */ jsx21(
-      Select,
-      {
-        options: [
-          ...models.map((m) => ({ label: m, value: m })),
-          { label: "Other...", value: "other" }
-        ],
-        onChange: (v) => {
-          if (v === "other") {
-            setIsCustom(true);
-          } else {
-            onConfirm(v);
-          }
-        }
-      }
-    ),
-    /* @__PURE__ */ jsx21(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text15, { dimColor: true, children: "Press ESC to go back" }) })
-  ] });
-}
-
-// ink/configurationWizard/ProviderStep.tsx
-import { Select as Select2 } from "@inkjs/ui";
-import { Box as Box16, Text as Text16 } from "ink";
-import { useStepperInput as useStepperInput5 } from "ink-stepper";
-import { useEffect as useEffect13 } from "react";
-
-// ink/configurationWizard/providers.ts
-var providers = [
-  { label: "OpenAI", value: "OpenAI" },
-  { label: "Anthropic", value: "Anthropic" },
-  { label: "Google", value: "Google" },
-  { label: "Ollama", value: "Ollama" }
-];
-
-// ink/configurationWizard/ProviderStep.tsx
-import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
-function ProviderStep({ onConfirm }) {
-  const { disableNavigation, enableNavigation } = useStepperInput5();
-  useEffect13(() => {
-    disableNavigation();
-    return () => enableNavigation();
-  }, [disableNavigation, enableNavigation]);
-  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx22(Text16, { children: "What model provider would you like to use today?" }),
-    /* @__PURE__ */ jsx22(
-      Select2,
-      {
-        options: providers,
-        onChange: (v) => onConfirm(v)
-      }
-    )
-  ] });
-}
-
-// ink/configurationWizard/StepperProgress.tsx
-import { Box as Box17, Text as Text17 } from "ink";
-import { Fragment as Fragment3 } from "react";
-import { jsx as jsx23, jsxs as jsxs16 } from "react/jsx-runtime";
-var markers = {
-  completed: " \u2713 ",
-  current: " \u25CF ",
-  pending: " \u25CB "
-};
-var SEGMENT_WIDTH = 12;
-function StepperProgress({ steps, currentStep }) {
-  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx23(Box17, { children: steps.map((step) => {
-      return /* @__PURE__ */ jsx23(Box17, { width: SEGMENT_WIDTH, justifyContent: "center", children: /* @__PURE__ */ jsx23(
-        Text17,
-        {
-          color: step.completed ? "green" : step.current ? "cyan" : "gray",
-          bold: step.current,
-          dimColor: !step.completed && !step.current,
-          children: step.name
-        }
-      ) }, step.name);
-    }) }),
-    /* @__PURE__ */ jsx23(Box17, { children: steps.map((step, idx) => {
-      const marker = step.completed ? markers.completed : step.current ? markers.current : markers.pending;
-      const beforeLineColor = step.completed || idx <= currentStep ? "green" : "gray";
-      const afterLineColor = step.completed ? "green" : "gray";
-      const markerColor = step.completed ? "green" : step.current ? "cyan" : "gray";
-      return /* @__PURE__ */ jsxs16(Fragment3, { children: [
-        /* @__PURE__ */ jsx23(Text17, { color: beforeLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 2) }),
-        /* @__PURE__ */ jsx23(Text17, { color: markerColor, bold: step.current, children: marker }),
-        /* @__PURE__ */ jsx23(Text17, { color: afterLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 1) })
-      ] }, step.name);
-    }) })
-  ] });
-}
-
-// ink/configurationWizard/ConfigurationWizard.tsx
-import { jsx as jsx24, jsxs as jsxs17 } from "react/jsx-runtime";
-function ConfigurationWizard({ onComplete }) {
-  const [provider, setProvider] = useState16("OpenAI");
-  const [ollamaModels, setOllamaModels] = useState16([]);
-  useEffect14(() => {
-    if (provider === "Ollama") {
-      fetchOllamaModels().then((models2) => {
-        if (models2.length > 0) {
-          setOllamaModels(models2);
-        }
-      });
-    }
-  }, [provider]);
-  useInput10((input, key) => {
-    if (key.ctrl && input === "x") {
-      emitToListeners("ExitUI", void 0);
-    }
-  });
-  const models = provider === "Ollama" && ollamaModels.length > 0 ? [.../* @__PURE__ */ new Set([...ollamaModels, ...modelsByProvider[provider]])] : modelsByProvider[provider];
-  const compactorModels = provider === "Ollama" && ollamaModels.length > 0 ? [.../* @__PURE__ */ new Set([...ollamaModels, ...compactorModelsByProvider[provider]])] : compactorModelsByProvider[provider];
-  return /* @__PURE__ */ jsx24(Box18, { flexDirection: "column", padding: 1, minHeight: 10, children: /* @__PURE__ */ jsxs17(
-    Stepper,
-    {
-      onComplete,
-      onCancel: curryEmitToListeners("ExitUI", void 0),
-      keyboardNav: true,
-      renderProgress: StepperProgress,
-      children: [
-        /* @__PURE__ */ jsx24(Step, { name: "AI Provider", children: ({ goNext }) => /* @__PURE__ */ jsx24(
-          ProviderStep,
-          {
-            onConfirm: (p) => {
-              setProvider(p);
-              goNext();
-            }
-          }
-        ) }),
-        /* @__PURE__ */ jsx24(Step, { name: provider !== "Ollama" ? "API Key" : "API", children: ({ goNext, goBack }) => provider !== "Ollama" ? /* @__PURE__ */ jsx24(
-          ApiKeyStep,
-          {
-            provider,
-            onConfirm: (key) => {
-              updateEnvKeyForProvider(provider, key);
-              goNext();
-            },
-            onBack: goBack
-          }
-        ) : /* @__PURE__ */ jsx24(
-          ApiUrlStep,
-          {
-            provider,
-            onConfirm: (key) => {
-              updateEnvKeyForProvider(provider, key);
-              goNext();
-            },
-            onBack: goBack
-          }
-        ) }),
-        /* @__PURE__ */ jsx24(Step, { name: "Model", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx24(
-          ModelSelectionStep,
-          {
-            title: "What model would you like to use?",
-            models,
-            onConfirm: (m) => {
-              const finalModelName = provider === "Ollama" && !m.startsWith("ollama-") && !m.includes(":") ? `ollama-${m}` : m;
-              updateEnv("HARPER_AGENT_MODEL", finalModelName);
-              goNext();
-            },
-            onBack: goBack
-          }
-        ) }),
-        /* @__PURE__ */ jsx24(Step, { name: "Compactor", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx24(
-          ModelSelectionStep,
-          {
-            title: "What model should we use for memory compaction?",
-            models: compactorModels,
-            onConfirm: (m) => {
-              const finalModelName = provider === "Ollama" && !m.startsWith("ollama-") && !m.includes(":") ? `ollama-${m}` : m;
-              updateEnv("HARPER_AGENT_COMPACTION_MODEL", finalModelName);
-              goNext();
-            },
-            onBack: goBack
-          }
-        ) }),
-        /* @__PURE__ */ jsx24(Step, { name: "Settings", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx24(
-          EnvironmentSettingsStep,
-          {
-            onConfirm: () => {
-              goNext();
-            },
-            onBack: goBack
-          }
-        ) })
-      ]
-    }
-  ) });
-}
-
-// ink/main.tsx
-import { jsx as jsx25, jsxs as jsxs18 } from "react/jsx-runtime";
-function bootstrapConfig() {
-  return new Promise((resolve2) => {
-    render(/* @__PURE__ */ jsx25(MainConfig, { onComplete: resolve2 }));
-  });
-}
-function MainConfig({ onComplete }) {
-  const { exit } = useApp();
-  useListener("ExitUI", () => exit(), [exit]);
-  return /* @__PURE__ */ jsx25(ConfigurationWizard, { onComplete });
-}
-function bootstrapMain() {
-  render(/* @__PURE__ */ jsx25(MainChat, {}));
-}
-function MainChat() {
-  const { exit } = useApp();
-  useListener("ExitUI", () => exit(), [exit]);
-  return /* @__PURE__ */ jsx25(CostProvider, { children: /* @__PURE__ */ jsx25(PlanProvider, { children: /* @__PURE__ */ jsx25(ActionsProvider, { children: /* @__PURE__ */ jsx25(ApprovalProvider, { children: /* @__PURE__ */ jsx25(SettingsProvider, { children: /* @__PURE__ */ jsxs18(ChatProvider, { children: [
-    /* @__PURE__ */ jsx25(ChatContent, {}),
-    /* @__PURE__ */ jsx25(DiffApprovalView, {})
-  ] }) }) }) }) }) });
-}
-
-// utils/models/deprecations.ts
-import chalk4 from "chalk";
-var DEPRECATION_RULES = [
-  // Redirect any gpt-4o variants (including dated and -mini) to gpt-5-nano
-  {
-    match: (name) => name.toLowerCase().startsWith("gpt-4o"),
-    replacement: "gpt-5-nano",
-    reason: "OpenAI gpt-4o family is deprecated in this agent"
-  }
-];
-function getDeprecatedReplacement(modelName) {
-  if (!modelName) {
-    return null;
-  }
-  for (const rule of DEPRECATION_RULES) {
-    if (rule.match(modelName)) {
-      return { replacement: rule.replacement, rule };
-    }
-  }
-  return null;
-}
-function warnAndPersistRedirect(original, envKey, replacement, reason) {
-  const reasonSuffix = reason ? ` Reason: ${reason}.` : "";
-  console.warn(
-    chalk4.yellow(
-      `Warning: model "${original}" is deprecated and will be redirected to "${replacement}". Your environment setting (${envKey}) has been updated.${reasonSuffix}`
-    )
-  );
-  updateEnv(envKey, replacement);
-}
-
-// utils/shell/cli.ts
-import chalk5 from "chalk";
-
-// utils/package/getOwnPackageJson.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join11 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
-function getOwnPackageJson() {
-  try {
-    const packageContents = readFileSync7(join11(__dirname2, "../package.json"), "utf8");
-    return JSON.parse(packageContents);
-  } catch {
-    return { name: "@harperfast/agent", version: "0.0.0" };
-  }
-}
-
-// utils/shell/cli.ts
-function isHelpRequest(args) {
-  const helpVariants = ["--help", "-h", "help"];
-  return args.some((arg) => helpVariants.includes(arg.toLowerCase()));
-}
-function isVersionRequest(args) {
-  const versionVariants = ["--version", "-v", "version"];
-  return args.some((arg) => versionVariants.includes(arg.toLowerCase()));
-}
-function handleHelp() {
-  console.log(`
-${chalk5.bold("harper-agent")} - AI to help you with Harper app creation and modification
-
-${chalk5.bold("USAGE")}
-  $ harper-agent [options]
-  $ harper-agent [command]
-
-${chalk5.bold("OPTIONS")}
-  -h, --help              Show help information
-  -v, --version           Show version information
-  -m, --model             Specify the model to use (e.g., ${defaultOpenAIModel}, ${defaultAnthropicModel}, ${defaultOllamaModel})
-                          Can also be set via HARPER_AGENT_MODEL environment variable.
-                          For Ollama, use the ollama- prefix (e.g., ${defaultOllamaCompactionModel}).
-  -c, --compaction-model  Specify the compaction model to use (defaults to ${defaultOpenAICompactionModel}).
-                          Can also be set via HARPER_AGENT_COMPACTION_MODEL environment variable.
-  -s, --session           Specify a path to a SQLite database file to persist the chat session.
-                          Can also be set via HARPER_AGENT_SESSION environment variable.
-  --max-turns             Specify the maximum number of turns for the agent run.
-                          Can also be set via HARPER_AGENT_MAX_TURNS environment variable.
-  --max-cost              Specify the maximum cost (in USD) for the agent run.
-                          If exceeded, the agent will exit with a non-zero code.
-                          Can also be set via HARPER_AGENT_MAX_COST environment variable.
-  --flex-tier             Force the use of the flex service tier for lower costs but potentially 
-                          more errors under high system load.
-                          Can also be set via HARPER_AGENT_FLEX_TIER=true environment variable.
-  -p, --prompt            Specify a prompt to be executed autonomously until completion.
-
-${chalk5.bold("COMMANDS")}
-  --help           Show help information
-  --version        Show version information
-
-${chalk5.bold("EXAMPLES")}
-  $ harper-agent --help
-  $ harper-agent --version
-  $ harper-agent
-`);
-  process.exit(0);
-}
-function handleVersion() {
-  const pkg = getOwnPackageJson();
-  console.log(pkg.version);
-  process.exit(0);
-}
-
-// lifecycle/parseArgs.ts
-function stripQuotes(str) {
-  if (str.startsWith('"') && str.endsWith('"') || str.startsWith("'") && str.endsWith("'")) {
-    return str.slice(1, -1);
-  }
-  return str;
-}
-function parseArgs() {
-  const args = process.argv.slice(2);
-  if (isHelpRequest(args)) {
-    handleHelp();
-  }
-  if (isVersionRequest(args)) {
-    handleVersion();
-  }
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const flagPairs = [
-      ["model", ["--model", "-m", "model"]],
-      ["compactionModel", ["--compaction-model", "-c", "compaction-model"]],
-      ["sessionPath", ["--session", "-s", "session"]],
-      ["maxTurns", ["--max-turns"]],
-      ["maxCost", ["--max-cost"]],
-      ["rateLimitThreshold", ["--rate-limit-threshold"]],
-      ["prompt", ["--prompt", "-p"]]
-    ];
-    let handled = false;
-    for (const [key, prefixes] of flagPairs) {
-      for (const prefix of prefixes) {
-        if (arg === prefix) {
-          if (args[i + 1]) {
-            const val = stripQuotes(args[++i]);
-            if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
-              trackedState[key] = parseFloat(val);
-            } else {
-              trackedState[key] = val;
-            }
-          }
-          handled = true;
-          break;
-        } else if (arg.startsWith(`${prefix}=`)) {
-          const val = stripQuotes(arg.slice(prefix.length + 1));
-          if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
-            trackedState[key] = parseFloat(val);
-          } else {
-            trackedState[key] = val;
-          }
-          handled = true;
-          break;
-        }
-      }
-      if (handled) {
-        break;
-      }
-    }
-    if (handled) {
-      continue;
-    }
-    if (arg === "--flex-tier") {
-      trackedState.useFlexTier = true;
-    } else if (arg === "--no-monitor-rate-limits") {
-      trackedState.monitorRateLimits = false;
-    } else if (arg === "--autonomous" || arg === "-a") {
-      trackedState.autonomous = true;
-    }
-  }
-  if (!trackedState.model && process.env.HARPER_AGENT_MODEL) {
-    trackedState.model = process.env.HARPER_AGENT_MODEL;
-  }
-  if (!trackedState.compactionModel && process.env.HARPER_AGENT_COMPACTION_MODEL) {
-    trackedState.compactionModel = process.env.HARPER_AGENT_COMPACTION_MODEL;
-  }
-  if (!trackedState.sessionPath && process.env.HARPER_AGENT_SESSION) {
-    trackedState.sessionPath = process.env.HARPER_AGENT_SESSION;
-  }
-  if (process.env.HARPER_AGENT_MAX_TURNS) {
-    trackedState.maxTurns = parseFloat(process.env.HARPER_AGENT_MAX_TURNS);
-  }
-  if (process.env.HARPER_AGENT_MAX_COST) {
-    trackedState.maxCost = parseFloat(process.env.HARPER_AGENT_MAX_COST);
-  }
-  if (process.env.HARPER_AGENT_RATE_LIMIT_THRESHOLD) {
-    trackedState.rateLimitThreshold = parseFloat(process.env.HARPER_AGENT_RATE_LIMIT_THRESHOLD);
-  }
-  if (process.env.HARPER_AGENT_MONITOR_RATE_LIMITS === "false") {
-    trackedState.monitorRateLimits = false;
-  }
-  if (!trackedState.useFlexTier && isTrue(process.env.HARPER_AGENT_FLEX_TIER)) {
-    trackedState.useFlexTier = true;
-  }
-  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER)) {
-    trackedState.autoApproveCodeInterpreter = true;
-  }
-  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_PATCHES)) {
-    trackedState.autoApprovePatches = true;
-  }
-  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_SHELL)) {
-    trackedState.autoApproveShell = true;
-  }
-  if (isTrue(process.env.HARPER_AGENT_AUTONOMOUS)) {
-    trackedState.autonomous = true;
-  }
-  if (!trackedState.model || trackedState.model === defaultModelToken) {
-    if (process.env.ANTHROPIC_API_KEY) {
-      trackedState.model = defaultAnthropicModel;
-    } else if (process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-      trackedState.model = defaultGoogleModel;
-    } else if (process.env.OLLAMA_BASE_URL) {
-      trackedState.model = defaultOllamaModel;
-    } else {
-      trackedState.model = defaultOpenAIModel;
-    }
-  }
-  if (!trackedState.compactionModel || trackedState.compactionModel === defaultModelToken) {
-    const m = trackedState.model;
-    if (m.startsWith("claude-")) {
-      trackedState.compactionModel = defaultAnthropicCompactionModel;
-    } else if (m.startsWith("gemini-")) {
-      trackedState.compactionModel = defaultGoogleCompactionModel;
-    } else if (m.startsWith("ollama-")) {
-      trackedState.compactionModel = defaultOllamaCompactionModel;
-    } else {
-      trackedState.compactionModel = defaultOpenAICompactionModel;
-    }
-  }
-  if (!isOpenAIModel(trackedState.model)) {
-    process.env.OPENAI_AGENTS_DISABLE_TRACING = process.env.OPENAI_AGENTS_DISABLE_TRACING || "1";
-  }
-  const maybeRedirect = (current, envKey) => {
-    const hit = getDeprecatedReplacement(current);
-    if (hit) {
-      const { replacement, rule } = hit;
-      warnAndPersistRedirect(current, envKey, replacement, rule.reason);
-      return replacement;
-    }
-    return current;
-  };
-  trackedState.model = maybeRedirect(trackedState.model, "HARPER_AGENT_MODEL");
-  trackedState.compactionModel = maybeRedirect(trackedState.compactionModel, "HARPER_AGENT_COMPACTION_MODEL");
-}
-
-// utils/envLoader.ts
-import dotenv from "dotenv";
-import { existsSync as existsSync11 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join12 } from "path";
-function loadEnv() {
-  const topLevelEnvPath = join12(homedir4(), ".harper", "harper-agent-env");
-  const localEnvPath = join12(process.cwd(), ".env");
-  if (existsSync11(topLevelEnvPath)) {
-    dotenv.config({ path: topLevelEnvPath, quiet: true });
-  }
-  if (existsSync11(localEnvPath)) {
-    dotenv.config({ path: localEnvPath, override: true, quiet: true });
-  }
-}
-
-// utils/package/checkForUpdate.ts
-import { Select as Select3 } from "@inkjs/ui";
-import chalk6 from "chalk";
-import spawn2 from "cross-spawn";
-import { Box as Box19, render as render2, Text as Text18 } from "ink";
-import React21 from "react";
-
-// utils/package/getLatestVersion.ts
-async function getLatestVersion(packageName) {
-  try {
-    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
-      signal: AbortSignal.timeout(1e3)
-      // 1 second timeout
-    });
-    if (!response.ok) {
-      return null;
-    }
-    const data = await response.json();
-    return data.version;
-  } catch {
-    return null;
-  }
-}
-
-// utils/package/isVersionNewer.ts
-function isVersionNewer(latest, current) {
-  const l = latest.split(".").map((x) => parseInt(x, 10));
-  const c = current.split(".").map((x) => parseInt(x, 10));
-  for (let i = 0; i < 3; i++) {
-    let latestNumber = l[i];
-    let currentNumber = c[i];
-    if (latestNumber === void 0 || currentNumber === void 0 || isNaN(latestNumber) || isNaN(currentNumber)) {
-      break;
-    }
-    if (latestNumber > currentNumber) {
-      return true;
-    }
-    if (latestNumber < currentNumber) {
-      return false;
-    }
-  }
-  return false;
-}
-
-// utils/package/checkForUpdate.ts
-async function checkForUpdate() {
-  const pkg = getOwnPackageJson();
-  const packageName = pkg.name;
-  const packageVersion = pkg.version;
-  if (process.env.HARPER_AGENT_SKIP_UPDATE) {
-    return packageVersion;
-  }
-  try {
-    const latestVersion = await getLatestVersion(packageName);
-    if (latestVersion && isVersionNewer(latestVersion, packageVersion)) {
-      const choice = await promptForUpdateChoice(packageName, packageVersion, latestVersion);
-      if (choice === "later") {
-        return packageVersion;
-      }
-      if (choice === "never") {
-        updateEnv("HARPER_AGENT_SKIP_UPDATE", "1");
-        return packageVersion;
-      }
-      let isGlobal = false;
-      try {
-        const globalRootResult = spawn2.sync("npm", ["root", "-g"], { encoding: "utf8" });
-        const globalRoot = globalRootResult.stdout?.trim();
-        if (globalRoot && process.argv[1] && process.argv[1].startsWith(globalRoot)) {
-          isGlobal = true;
-        }
-      } catch {
-      }
-      if (isGlobal) {
-        spawn2.sync("npm", ["install", "-g", `${packageName}@latest`], { stdio: "inherit" });
-        const result2 = spawn2.sync("harper-agent", process.argv.slice(2), { stdio: "inherit" });
-        process.exit(result2.status ?? 0);
-      }
-      const lsResult = spawn2.sync("npm", ["cache", "npx", "ls", packageName], { encoding: "utf8" });
-      if (lsResult.stdout) {
-        const keys = lsResult.stdout.split("\n").map((line) => line.trim()).filter((line) => line.includes(":")).filter((line) => {
-          const [, pkgPart] = line.split(":");
-          return pkgPart && pkgPart.trim().startsWith(`${packageName}@`);
-        }).map((line) => line.split(":")[0].trim());
-        if (keys.length > 0) {
-          spawn2.sync("npm", ["cache", "npx", "rm", ...keys], { stdio: "inherit" });
-        }
-      }
-      const result = spawn2.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], { stdio: "inherit" });
-      process.exit(result.status ?? 0);
-    }
-  } catch {
-  }
-  return packageVersion;
-}
-function promptForUpdateChoice(pkgName, currentVersion, latestVersion) {
-  return new Promise((resolve2) => {
-    const app = render2(
-      React21.createElement(UpdatePrompt, {
-        packageName: pkgName,
-        currentVersion,
-        latestVersion,
-        onSelect: (c) => {
-          resolve2(c);
-          app.unmount();
-        }
-      })
-    );
-  });
-}
-function UpdatePrompt({ packageName, currentVersion, latestVersion, onSelect }) {
-  const options = [
-    {
-      label: `Update right now (will run: npx -y @harperfast/agent@latest)`,
-      value: "now"
-    },
-    { label: "Update later", value: "later" },
-    { label: "Don\u2019t ask again", value: "never" }
-  ];
-  return React21.createElement(
-    Box19,
-    { flexDirection: "column", padding: 1 },
-    React21.createElement(
-      Text18,
-      null,
-      `${chalk6.yellow("Update available:")} ${chalk6.bold(packageName)} ${chalk6.dim(`v${currentVersion}`)} \u2192 ${chalk6.green(`v${latestVersion}`)}`
-    ),
-    React21.createElement(
-      Box19,
-      { marginTop: 1 },
-      React21.createElement(Select3, {
-        options,
-        onChange: (v) => onSelect(v)
-      })
-    )
-  );
-}
-
-// utils/shell/ensureApiKey.ts
-function ensureApiKey() {
-  const models = [
-    trackedState.model,
-    trackedState.compactionModel
-  ].filter(excludeFalsy);
-  const requiredEnvVars = /* @__PURE__ */ new Set();
-  for (const model of models) {
-    if (model.startsWith("claude-")) {
-      requiredEnvVars.add("ANTHROPIC_API_KEY");
-    } else if (model.startsWith("gemini-")) {
-      requiredEnvVars.add("GOOGLE_GENERATIVE_AI_API_KEY");
-    } else if (model.startsWith("ollama-") || model.includes(":")) {
-    } else {
-      requiredEnvVars.add("OPENAI_API_KEY");
-    }
-  }
-  for (const envVar of requiredEnvVars) {
-    if (!process.env[envVar]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// agent.ts
-(async function() {
-  setupGlobalErrorHandlers();
-  loadEnv();
-  process.on("SIGINT", handleExit);
-  process.on("SIGTERM", handleExit);
-  await checkForUpdate();
-  parseArgs();
-  if (!ensureApiKey()) {
-    resetTrackedState();
-    await bootstrapConfig();
-    emitToListeners("ExitUI", void 0);
-    parseArgs();
-    if (!ensureApiKey()) {
-      console.log(chalk7.red("No key provided. Exiting."));
-      process.exit(1);
-    }
-  }
-  await agentManager.initialize();
-  bootstrapMain();
-})();